From 89a3425e87f445482cb74beceb57ea335f05e051 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Tue, 3 Feb 2026 09:40:02 -0600 Subject: [PATCH 01/48] Initial commit From 85de6c71170e8e75b4ba1fc46e1718251142763c Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Tue, 3 Feb 2026 13:03:53 -0600 Subject: [PATCH 02/48] Oracle database connector --- demos/README.md | 1 + demos/notebooks/Oracle_TCPH.ipynb | 19 ++++ documentation/usage.md | 33 ++++++- pydough/database_connectors/README.md | 2 + pydough/database_connectors/__init__.py | 2 + .../database_connectors/builtin_databases.py | 98 ++++++++++++++++++- .../database_connectors/database_connector.py | 1 + pydough/database_connectors/db_types.py | 17 +++- pydough/sqlglot/execute_relational.py | 3 + 9 files changed, 172 insertions(+), 4 deletions(-) create mode 100644 demos/notebooks/Oracle_TCPH.ipynb diff --git a/demos/README.md b/demos/README.md index 5aa94a6d3..2b1b58fae 100644 --- a/demos/README.md +++ b/demos/README.md @@ -26,4 +26,5 @@ Once the introduction notebook is complete, you can explore the other notebooks: - [SF_TPCH_q1.ipynb](notebooks/SF_TPCH_q1.ipynb) demonstrates how to connect a Snowflake database with PyDough. - [MySQL_TPCH.ipynb](notebooks/MySQL_TPCH.ipynb) demonstrates how to connect a MySQL database with PyDough. - [PG_TPCH.ipynb](notebooks/PG_TPCH.ipynb) demonstrates how to connect a Postgres database with PyDough. +- [Oracle_TPCH.ipynb](notebooks/Oracle_TPCH.ipynb) demonstrates how to connect an Oracle database with PyDough. diff --git a/demos/notebooks/Oracle_TCPH.ipynb b/demos/notebooks/Oracle_TCPH.ipynb new file mode 100644 index 000000000..5dda39b3f --- /dev/null +++ b/demos/notebooks/Oracle_TCPH.ipynb @@ -0,0 +1,19 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d1cd6a33", + "metadata": {}, + "source": [ + "# TODO" + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/documentation/usage.md b/documentation/usage.md index 5f5894687..c082751d2 100644 --- a/documentation/usage.md +++ b/documentation/usage.md @@ -345,7 +345,9 @@ Below is a list of all supported values for the database name: - `snowflake`: uses a Snowflake database. [See here](https://docs.snowflake.com/en/user-guide/python-connector.html#connecting-to-snowflake) for details on the connection API and what keyword arguments can be passed in. -- `postgres` or `postgres`: uses a Postgres database. [See here](https://www.psycopg.org/docs/) for details on the connection API and what keyword arguments can be passed in. +- `postgres`: uses a Postgres database. [See here](https://www.psycopg.org/docs/) for details on the connection API and what keyword arguments can be passed in. + +- `oracle`: uses an Oracle database. [See here](https://python-oracledb.readthedocs.io/en/latest/user_guide/installation.html) for details on the connection API and what keyword arguments can be passed in. > Note: If you installed PyDough via pip, you can install optional connectors using pip extras: > @@ -364,6 +366,7 @@ Here’s a quick reference table showing which connector is needed for each dial | `mysql` | `mysql-connector-python` | | `snowflake` | `snowflake-connector-python[pandas]` | | `postgres` | `psycopg2-binary` | +| `oracle` | `python-oracledb` | Below are examples of how to access the context and switch it out for a newly created one, either by manually setting it or by using `session.load_database`. These examples assume that there are two different sqlite database files located at `db_files/education.db` and `db_files/shakespeare.db`. @@ -439,6 +442,34 @@ You can find a full example of using MySQL database with PyDough in [this usage ``` You can find a full example of using Postgres database with PyDough in [this usage guide](./../demos/notebooks/PG_TPCH.ipynb). +- Oracle: You can connect to an Oracle database using `load_metadata_graph` and `connect_database` APIs. For example: + ```py + pydough.active_session.load_metadata_graph("../../tests/test_metadata/sample_graphs.json", "TPCH") + pydough.active_session.connect_database("oracle", + user=oracle_user, + password=oracle_password, + host=oracle_host, + port=oracle_port + service_name=oracle_service_name, + ) + ``` + Also you can use `dsn` instead of `host`, `port` and `service_name`. + + Example with a connection object + ```py + pydough.active_session.load_metadata_graph("../../tests/test_metadata/sample_graphs.json", "TPCH") + oracle_conn: oracledb.connection = oracledb.connect( + dbname=oracle_db, + user=oracle_user, + password=oracle_password, + host=oracle_host, + port=oracle_port, + service_name=oracle_service_name, + ) + pydough.active_session.connect_database("oracle", connection=oracle_conn) + ``` +You can find a full example of using an Oracle database with PyDough in [this usage guide](./../demos/notebooks/Oracle_TPCH.ipynb). + ## Evaluation APIs diff --git a/pydough/database_connectors/README.md b/pydough/database_connectors/README.md index 0ef17e5b5..b19e27071 100644 --- a/pydough/database_connectors/README.md +++ b/pydough/database_connectors/README.md @@ -19,6 +19,7 @@ The database connectors module provides functionality to manage database connect - `SNOWFLAKE`: Represents the Snowflake SQL dialect. - `MYSQL`: Represents the MySQL dialect. - `POSTGRES`: Represents the Postgres dialect + - `ORACLE`: Represents the Oracle dialect - `DatabaseContext`: Dataclass that manages the database connection and the corresponding dialect. - Fields: - `connection`: The `DatabaseConnection` object. @@ -35,6 +36,7 @@ The database connectors module provides functionality to manage database connect - `load_snowflake_connection`: Loads a Snowflake connection. - `load_mysql_connection`: Loads a MySQL database connection. - `load_postgres_connection`: Loads a Postgres database connection. +- `load_oracle_connection`: Loads an Oracle database connection. ## Usage diff --git a/pydough/database_connectors/__init__.py b/pydough/database_connectors/__init__.py index e9e71103f..7664b381d 100644 --- a/pydough/database_connectors/__init__.py +++ b/pydough/database_connectors/__init__.py @@ -5,6 +5,7 @@ "empty_connection", "load_database_context", "load_mysql_connection", + "load_oracle_connection", "load_postgres_connection", "load_snowflake_connection", "load_sqlite_connection", @@ -13,6 +14,7 @@ from .builtin_databases import ( load_database_context, load_mysql_connection, + load_oracle_connection, load_postgres_connection, load_snowflake_connection, load_sqlite_connection, diff --git a/pydough/database_connectors/builtin_databases.py b/pydough/database_connectors/builtin_databases.py index 349acb49f..21dc5fa13 100644 --- a/pydough/database_connectors/builtin_databases.py +++ b/pydough/database_connectors/builtin_databases.py @@ -13,6 +13,7 @@ __all__ = [ "load_database_context", "load_mysql_connection", + "load_oracle_connection", "load_postgres_connection", "load_snowflake_connection", "load_sqlite_connection", @@ -32,7 +33,7 @@ def load_database_context(database_name: str, **kwargs) -> DatabaseContext: Returns: The database context object. """ - supported_databases = {"postgres", "mysql", "sqlite", "snowflake"} + supported_databases = {"postgres", "mysql", "sqlite", "snowflake", "oracle"} connection: DatabaseConnection dialect: DatabaseDialect match database_name.lower(): @@ -48,6 +49,9 @@ def load_database_context(database_name: str, **kwargs) -> DatabaseContext: case "postgres": connection = load_postgres_connection(**kwargs) dialect = DatabaseDialect.POSTGRES + case "oracle": + connection = load_oracle_connection(**kwargs) + dialect = DatabaseDialect.ORACLE case _: raise PyDoughSessionException( f"Unsupported database: {database_name}. The supported databases are: {supported_databases}." @@ -296,3 +300,95 @@ def load_postgres_connection(**kwargs) -> DatabaseConnection: attempt += 1 raise ValueError(f"Failed to connect to Postgres after {attempts} attempts") + + +def load_oracle_connection(**kwargs) -> DatabaseConnection: + """ + Loads an Oracle database connection. This is done by providing a wrapper + around the DB 2.0 connect API. + + Args: + **kwargs: Either an Oracle connection object (as `connection=`) + or the required connection parameters: + - `user`: Oracle username + - `password`: Oracle password for the specified user + - `service_name`: The database service name. + Optionally, you can provide: + - `host`: Oracle server host (default: "127.0.0.1"/"localhost"). + - `port`: Oracle server port (default: 1521). + - `tcp_connect_timeout`: Timeout for the connection (default: 3 seconds). + - `attempts` (not an Oralce connector parameter): Number of connection attempts (default: 3) + - `delay` (not an Oracle connector parameter): Delay between connection attempts (default: 2 seconds). + If a connection object is provided, it will be used directly. + All arguments must be accepted by the Oracle connector connect API. + + Raises: + ImportError: If the Oracle connector is not installed. + ValueError: If required connection parameters are missing. + + Returns: + A database connection object for Oracle. + """ + try: + import oracledb + except ImportError: + raise ImportError( + "Oracle connector oracledb is not installed. Please install it with" + " `python -m pip install oracledb --upgrade`." + ) + + # Oracle python connector + connection: oracledb.connection + if connection := kwargs.pop("connection", None): + # If a connection object is provided, return it wrapped in + # DatabaseConnection + return DatabaseConnection(connection) + + # Oracle connection requires specific parameters: + # user, password and dsn or host, port and service_name instead of dsn. + # Raise an error if any of these are missing. + # NOTE: host, port are optional and will default to the oracle defaults. + # See: https://python-oracledb.readthedocs.io/en/latest/user_guide/connection_handling.html + + required_keys = ["user", "password", "service_name"] + if not all(key in kwargs for key in required_keys): + raise ValueError( + "Oracle connection requires at least the following arguments: " + + ", ".join(required_keys) + ) + + # Host is required for oracledb connector, not required for PyDough + if "host" not in kwargs: + kwargs["host"] = "localhost" + + # Default timeout for connection + if "tcp_connect_timeout" not in kwargs or kwargs["tcp_connect_timeout"] <= 0: + kwargs["tcp_connect_timeout"] = 3 + + # Default attempts for connection if not given + if not (attempts := kwargs.pop("attempts", None)): + attempts = 1 + + # Default delay between attempts for connection if not given + if not (delay := kwargs.pop("delay", None)): + delay = 2.0 + + attempt: int = 1 + + # For each attempt a connection is tried + # If it fails, there is a delay before another attempt is executed + while attempt <= attempts: + try: + connection = oracledb.connect(**kwargs) + return DatabaseConnection(connection) + + except (OSError, oracledb.Error) as err: + if attempt >= attempts: + raise ValueError( + f"Failed to connect to Oracle after {attempt} attempts: {err}" + ) + # Delay for another attempt + time.sleep(delay) + attempt += 1 + + raise ValueError(f"Failed to connect to Oracle after {attempts} attempts") diff --git a/pydough/database_connectors/database_connector.py b/pydough/database_connectors/database_connector.py index b34189442..d31593a19 100644 --- a/pydough/database_connectors/database_connector.py +++ b/pydough/database_connectors/database_connector.py @@ -109,6 +109,7 @@ class DatabaseDialect(Enum): SNOWFLAKE = "snowflake" MYSQL = "mysql" POSTGRES = "postgres" + ORACLE = "oracle" @staticmethod def from_string(dialect: str) -> "DatabaseDialect": diff --git a/pydough/database_connectors/db_types.py b/pydough/database_connectors/db_types.py index 3abf347cd..9f8c3f645 100644 --- a/pydough/database_connectors/db_types.py +++ b/pydough/database_connectors/db_types.py @@ -35,6 +35,11 @@ PostgresConn: TypeAlias = psycopg2.connection # type: ignore PostgresCursor: TypeAlias = psycopg2.cursor # type: ignore + import oracledb + + OracleConn: TypeAlias = oracledb.connection + OracleCursor: TypeAlias = oracledb.cursor + # TBD: Placeholder lines to add other dialects. # 1. Replace with actual dialect module # import dialect1_module @@ -44,8 +49,12 @@ # Dialect1_Cursor: TypeAlias = dialect1_module.Cursor # 4. Define the type aliases for database connections and cursors - DBConnection: TypeAlias = SQLiteConn | SnowflakeConn | MySQLConn | PostgresConn - DBCursor: TypeAlias = SQLiteCursor | SnowflakeCursor | MySQLCursor | PostgresCursor + DBConnection: TypeAlias = ( + SQLiteConn | SnowflakeConn | MySQLConn | PostgresConn | OracleConn + ) # type: ignore + DBCursor: TypeAlias = ( + SQLiteCursor | SnowflakeCursor | MySQLCursor | PostgresCursor | OracleCursor + ) # type: ignore else: DBConnection: TypeAlias = Any @@ -58,6 +67,8 @@ MySQLCursor: TypeAlias = Any PostgresConn: TypeAlias = Any PostgresCursor: TypeAlias = Any + OracleConn: TypeAlias = Any + OracleCursor: TypeAlias = Any # This allows us to use these type aliases in the rest of the code # without worrying about whether the specific database modules are available. @@ -66,6 +77,8 @@ "DBCursor", "MySQLConn", "MySQLCursor", + "OracleConn", + "OracleCursor", "PostgresConn", "PostgresCursor", "SQLiteConn", diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index 6e75f5868..211754f6a 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -11,6 +11,7 @@ from sqlglot import parse_one from sqlglot.dialects import Dialect as SQLGlotDialect from sqlglot.dialects import MySQL as MySQLDialect +from sqlglot.dialects import Oracle as OracleDialect from sqlglot.dialects import Postgres as PostgresDialect from sqlglot.dialects import Snowflake as SnowflakeDialect from sqlglot.dialects import SQLite as SQLiteDialect @@ -484,6 +485,8 @@ def convert_dialect_to_sqlglot(dialect: DatabaseDialect) -> SQLGlotDialect: return MySQLDialect() case DatabaseDialect.POSTGRES: return PostgresDialect() + case DatabaseDialect.ORACLE: + return OracleDialect() case _: raise NotImplementedError(f"Unsupported dialect: {dialect}") From a52e3eb23800601180a74b90e193cb8a03e85651 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Tue, 3 Feb 2026 16:13:38 -0600 Subject: [PATCH 03/48] tpch 1 demo added --- demos/notebooks/Oracle_TCPH.ipynb | 299 +++++++++++++++++++++++++++++- 1 file changed, 297 insertions(+), 2 deletions(-) diff --git a/demos/notebooks/Oracle_TCPH.ipynb b/demos/notebooks/Oracle_TCPH.ipynb index 5dda39b3f..218e6052c 100644 --- a/demos/notebooks/Oracle_TCPH.ipynb +++ b/demos/notebooks/Oracle_TCPH.ipynb @@ -5,13 +5,308 @@ "id": "d1cd6a33", "metadata": {}, "source": [ - "# TODO" + "# Oracle PyDough Database connector" + ] + }, + { + "cell_type": "markdown", + "id": "b190b0ef", + "metadata": {}, + "source": [ + "> ## πŸš€ Initial Setup\n", + ">\n", + "> ---\n", + ">\n", + "> ### 1️⃣ Oracle Database\n", + ">\n", + "> You can connect to your **own Oracle database** using your credentials β€” for example, if you have **Oracle Database Software** or another local server running.\n", + ">\n", + "> ---\n", + ">\n", + "> ### 2️⃣ Docker Image (TPC-H Database)\n", + ">\n", + "> You can also test with our **pre-built Oracle TPC-H database** available on **Docker Hub**.\n", + ">\n", + "> #### πŸ“‹ Requirements\n", + "> - Make sure you have **Docker Desktop** installed and running.\n", + ">\n", + "> #### πŸ“¦ Pull and Run the Container\n", + "> ```bash\n", + "> docker run -d --name [CONTAINER_NAME]\\\n", + "> --platform linuxamd64 \\\n", + "> -e ORACLE_PWD=[PASSWORD] \\\n", + "> -p 1521:1521 \\\n", + "> bodoai1/pydough-oracle-tpch:latest\n", + "> ```\n", + "> - Replace `[CONTAINER_NAME]` with your preferred container name. \n", + "> - Replace `[PASSWORD]` with your preferred password.\n", + ">\n", + "> *(Make sure the `1521` port is available and not being used by another container.)* \n", + "> \n", + "> ---\n", + ">\n", + "> #### πŸ”‘ Environment Variables\n", + "> To connect to this database, use:\n", + "> ```env\n", + "> ORACLE_USERNAME=toch\n", + "> ORACLE_PASSWORD=[PASSWORD]\n", + "> ```\n", + "> *(Make sure `[PASSWORD]` matches the one you used when running the container.)*\n", + ">\n", + "> ---\n", + ">\n", + "> πŸ’‘ **Tip:** \n", + "> Store these credentials in a `.env` file in your project directory for easy access and security.\n", + ">\n", + "> Example `.env` file:\n", + "> ```env\n", + "> ORACLE_USERNAME=root\n", + "> ORACLE_PASSWORD=mysecretpassword\n", + "> ```\n", + ">\n", + ">\n", + "> #### Deleting the container and image\n", + "> Once the tests have finished you can stop the container and delete it with the image using the following docker commands:\n", + ">```bash\n", + "> docker stop [CONTAINER_NAME]\n", + "> docker rm [CONTAINER_NAME]\n", + "> docker rmi bodoai1/pydough-oracle-tpch\n", + ">```" + ] + }, + { + "cell_type": "markdown", + "id": "097cba60", + "metadata": {}, + "source": [ + "> ## πŸ”Œ Installing Oracle Connector\n", + ">\n", + "> Make sure to have the **`python-oracledb`** package installed:\n", + ">\n", + "> ---\n", + ">\n", + "> - **If you're working inside the repo**:\n", + "> ```bash\n", + "> pip install -e \".[oracle]\"\n", + "> ```\n", + ">\n", + "> - **Or install the connector directly**:\n", + "> ```bash\n", + "> python -m pip install oracledb --upgrade\n", + "> ```" + ] + }, + { + "cell_type": "markdown", + "id": "1f39b2af", + "metadata": {}, + "source": [ + "> ## Importing Required Libraries\n", + ">\n", + "> ---" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b473d180", + "metadata": {}, + "outputs": [], + "source": [ + "import pydough\n", + "import datetime\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "id": "6c595441", + "metadata": {}, + "source": [ + "> ## πŸ”‘ Loading Credentials and connecting to Oracle with PyDough\n", + ">\n", + "> ---\n", + ">\n", + "> ### 1️⃣ Load Credentials from a Local `.env` File\n", + "> - The `.env` file contains your MySQL login details like:\n", + "> ```env\n", + "> ORACLE_PASSWORD=mypassword\n", + "> ```\n", + "> - These are read in Python using:\n", + "> ```python\n", + "> import os\n", + "> password = os.getenv(\"ORACLE_PASSWORD\")\n", + "> ```\n", + ">\n", + "> ---\n", + ">\n", + "> ### 2️⃣ Oracle-PyDough `connect_database()` Parameters\n", + "> - **`user`** *(required)*: Username for Oracle connection. \n", + "> - **`password`** *(required)*: Password used for MySQL connection. \n", + "> - **`service_name`** *(required)*: Oracle database service name. \n", + "> - **`host`** *(optional)*: IP to access Oracle server. Default: `\"localhost\"` or `\"127.0.0.1\"`. \n", + "> - **`port`** *(optional)*: Port number to access Oracle server. Default: `1521`. \n", + "> - **`tcp_connect_timeout`** *(optional)*: Timeout in seconds for Oracle connection. Default: `3`. \n", + "> - **`attempts`** *(optional)*: Number of times the connection is attempted. Default: `1`. \n", + "> - **`delay`** *(optional)*: Seconds to wait before another connection attempt. Default: `2`. \n", + ">\n", + "> ---\n", + ">\n", + "> ### 3️⃣ Connect to Oracle Using PyDough\n", + "> - `pydough.active_session.load_metadata_graph(...)` \n", + "> Loads a metadata graph mapping your Oracle schema (used for query planning/optimizations). \n", + "> - `connect_database(...)` \n", + "> Uses the loaded credentials to establish a live connection to your Oracle database.\n", + ">\n", + "> ---\n", + ">\n", + "> **⚠️ Notes:** \n", + "> - Ensure the `.env` exists and contains **all required keys**. \n", + "> - The metadata graph path must point to a **valid JSON file** representing your schema." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7487b588", + "metadata": {}, + "outputs": [], + "source": [ + "oracle_password = os.getenv(\"ORACLE_PASSWORD\")\n", + "oracle_tpch_db = \"tpch\"\n", + "oracle_host = \"127.0.0.1\"\n", + "connection_timeout = 2\n", + "attempts = 2 \n", + "delay = 5.0 \n", + "\n", + "pydough.active_session.load_metadata_graph(\"../../tests/test_metadata/sample_graphs.json\", \"TPCH\")\n", + "pydough.active_session.connect_database(\"oracle\", \n", + " user=\"tpch\",\n", + " password=oracle_password,\n", + " service_name=\"FREEPDB1\",\n", + " host=oracle_host,\n", + " tcp_connect_timeout=connection_timeout,\n", + " attempts=attempts,\n", + " delay=delay\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "305e11ec", + "metadata": {}, + "source": [ + "> ## ✨ Enabling PyDough's Jupyter Magic Commands\n", + ">\n", + "> ---\n", + ">\n", + "> This step loads the **`pydough.jupyter_extensions`** module, which adds custom magic commands (like `%%pydough`) to your notebook.\n", + ">\n", + "> ---\n", + ">\n", + "> ### πŸ“Œ What These Magic Commands Do\n", + "> - **Write PyDough directly** in notebook cells using:\n", + "> ```python\n", + "> %%pydough\n", + "> ```\n", + "> - **Automatically render** query results inside the notebook.\n", + ">\n", + "> ---\n", + ">\n", + "> ### πŸ’» How It Works\n", + "> This is a **Jupyter-specific feature** β€” the `%load_ext` command dynamically loads these extensions into your **current notebook session**:\n", + "> ```python\n", + "> %load_ext pydough.jupyter_extensions\n", + "> ```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93dde776", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext pydough.jupyter_extensions" + ] + }, + { + "cell_type": "markdown", + "id": "d9b9d04a", + "metadata": {}, + "source": [ + "> ## πŸ“Š Running TPC-H Query 1 with PyDough in Oracle\n", + ">\n", + "> ---\n", + ">\n", + "> This cell runs **TPC-H Query 1** using **PyDough**.\n", + ">\n", + "> ---\n", + ">\n", + "> ### πŸ“ What the Query Does\n", + "> - **Computes summary statistics**: sums, averages, and counts for orders. \n", + "> - **Groups by**: `return_flag` and `line_status`. \n", + "> - **Filters by**: a shipping date cutoff. \n", + ">\n", + "> ---\n", + ">\n", + "> ### πŸ“€ Output\n", + "> - `pydough.to_df(output)` converts the result to a **Pandas DataFrame**. \n", + "> - This makes it easy to inspect and analyze results directly in Python. \n", + ">\n", + "> ---\n", + ">" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86b45425", + "metadata": {}, + "outputs": [], + "source": [ + "%%pydough\n", + "# TPCH Q1\n", + "output = (lines.WHERE((ship_date <= datetime.date(1998, 12, 1)))\n", + " .PARTITION(name=\"groups\", by=(return_flag, status))\n", + " .CALCULATE(\n", + " L_RETURNFLAG=return_flag,\n", + " L_LINESTATUS=status,\n", + " SUM_QTY=SUM(lines.quantity),\n", + " SUM_BASE_PRICE=SUM(lines.extended_price),\n", + " SUM_DISC_PRICE=SUM(lines.extended_price * (1 - lines.discount)),\n", + " SUM_CHARGE=SUM(\n", + " lines.extended_price * (1 - lines.discount) * (1 + lines.tax)\n", + " ),\n", + " AVG_QTY=AVG(lines.quantity),\n", + " AVG_PRICE=AVG(lines.extended_price),\n", + " AVG_DISC=AVG(lines.discount),\n", + " COUNT_ORDER=COUNT(lines),\n", + " )\n", + " .ORDER_BY(L_RETURNFLAG.ASC(), L_LINESTATUS.ASC())\n", + ")\n", + "\n", + "pydough.to_df(output)" ] } ], "metadata": { + "kernelspec": { + "display_name": "PyDough", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" } }, "nbformat": 4, From 6957a69561efea6d1eac33f0723a65454fd8e7e7 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Tue, 3 Feb 2026 16:19:36 -0600 Subject: [PATCH 04/48] example modified --- demos/notebooks/Oracle_TCPH.ipynb | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/demos/notebooks/Oracle_TCPH.ipynb b/demos/notebooks/Oracle_TCPH.ipynb index 218e6052c..dde15416a 100644 --- a/demos/notebooks/Oracle_TCPH.ipynb +++ b/demos/notebooks/Oracle_TCPH.ipynb @@ -172,19 +172,22 @@ "metadata": {}, "outputs": [], "source": [ + "oracle_user = \"tpch\"\n", "oracle_password = os.getenv(\"ORACLE_PASSWORD\")\n", - "oracle_tpch_db = \"tpch\"\n", + "oracle_service_name = \"FREEPDB1\"\n", "oracle_host = \"127.0.0.1\"\n", + "oracle_port = 1521\n", "connection_timeout = 2\n", "attempts = 2 \n", "delay = 5.0 \n", "\n", "pydough.active_session.load_metadata_graph(\"../../tests/test_metadata/sample_graphs.json\", \"TPCH\")\n", "pydough.active_session.connect_database(\"oracle\", \n", - " user=\"tpch\",\n", + " user=oracle_user,\n", " password=oracle_password,\n", - " service_name=\"FREEPDB1\",\n", + " service_name=oracle_service_name,\n", " host=oracle_host,\n", + " port=oracle_port,\n", " tcp_connect_timeout=connection_timeout,\n", " attempts=attempts,\n", " delay=delay\n", From f3a0febca9b611e4e2ffdda3cc280cb0658347cb Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 4 Feb 2026 11:21:30 -0600 Subject: [PATCH 05/48] oracle transform bindings base --- pydough/sqlglot/execute_relational.py | 10 ++-- .../sqlglot/transform_bindings/__init__.py | 3 ++ .../oracle_transform_bindings.py | 50 +++++++++++++++++++ 3 files changed, 60 insertions(+), 3 deletions(-) create mode 100644 pydough/sqlglot/transform_bindings/oracle_transform_bindings.py diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index 211754f6a..20981317e 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -205,7 +205,7 @@ def apply_sqlglot_optimizer( # Replaces any grouping or ordering keys that point to a clause in the # SELECT with an index (e.g. ORDER BY 1, GROUP BY 1, 2) - replace_keys_with_indices(glot_expr) + replace_keys_with_indices(glot_expr, dialect) # Remove table aliases if there is only one Table source in the FROM clause. remove_table_aliases_conditional(glot_expr) @@ -218,7 +218,9 @@ def apply_sqlglot_optimizer( return glot_expr -def replace_keys_with_indices(glot_expr: SQLGlotExpression) -> None: +def replace_keys_with_indices( + glot_expr: SQLGlotExpression, dialect: SQLGlotDialect +) -> None: """ Runs a transformation postprocessing pass on the SQLGlot AST to make the following changes: @@ -294,7 +296,9 @@ def replace_keys_with_indices(glot_expr: SQLGlotExpression) -> None: expression.expressions[expr_idx] = collate # Replace GROUP BY keys that are in the select clause with indices. - if expression.args.get("group") is not None: + # Oracle does not support indices in the GROUP BY, for this dialect this + # step is skipped + if expression.args.get("group") is not None and dialect != OracleDialect: keys_list: list[SQLGlotExpression] = expression.args["group"].expressions for idx, key_expr in enumerate(keys_list): # Only replace with the index if the key expression appears in diff --git a/pydough/sqlglot/transform_bindings/__init__.py b/pydough/sqlglot/transform_bindings/__init__.py index d69a356df..594ec6d78 100644 --- a/pydough/sqlglot/transform_bindings/__init__.py +++ b/pydough/sqlglot/transform_bindings/__init__.py @@ -19,6 +19,7 @@ from .base_transform_bindings import BaseTransformBindings from .mysql_transform_bindings import MySQLTransformBindings +from .oracle_transform_bindings import OracleTransformBindings from .postgres_transform_bindings import PostgresTransformBindings from .sf_transform_bindings import SnowflakeTransformBindings from .sqlite_transform_bindings import SQLiteTransformBindings @@ -55,5 +56,7 @@ def bindings_from_dialect( return MySQLTransformBindings(configs, visitor) case DatabaseDialect.POSTGRES: return PostgresTransformBindings(configs, visitor) + case DatabaseDialect.ORACLE: + return OracleTransformBindings(configs, visitor) case _: raise NotImplementedError(f"Unsupported dialect: {dialect}") diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py new file mode 100644 index 000000000..159b7caf3 --- /dev/null +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -0,0 +1,50 @@ +""" +Definition of SQLGlot transformation bindings for the Oracle dialect. +""" + +__all__ = ["OracleTransformBindings"] + + +import sqlglot.expressions as sqlglot_expressions +from sqlglot.expressions import Expression as SQLGlotExpression + +import pydough.pydough_operators as pydop +from pydough.types import PyDoughType + +from .base_transform_bindings import BaseTransformBindings + + +class OracleTransformBindings(BaseTransformBindings): + """ + Subclass of BaseTransformBindings for the Oracle dialect. + """ + + PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { + pydop.ABS: "ABS", + pydop.DEFAULT_TO: "NVL", + pydop.LARGEST: "GREATEST", + pydop.SMALLEST: "LEAST", + pydop.STRIP: "TRIM", + pydop.FIND: "INSTR", + pydop.SLICE: "SUBSTR", + pydop.JOIN_STRINGS: "LISTAGG", + pydop.PERCENTILE: "PERCENTILE_CONT", + } + + """ + Mapping of PyDough operators to equivalent Oracle function names + These are used to generate anonymous function calls in SQLGlot + """ + + def convert_call_to_sqlglot( + self, + operator: pydop.PyDoughExpressionOperator, + args: list[SQLGlotExpression], + types: list[PyDoughType], + ) -> SQLGlotExpression: + if operator in self.PYDOP_TO_ORACLE_FUNC: + return sqlglot_expressions.Anonymous( + this=self.PYDOP_TO_ORACLE_FUNC[operator], expressions=args + ) + + return super().convert_call_to_sqlglot(operator, args, types) From 68b8a5f10c02128d7f5644bb6c988a6fcf800a4c Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Thu, 5 Feb 2026 10:53:59 -0600 Subject: [PATCH 06/48] oracle test infrastructure --- tests/conftest.py | 472 +- tests/test_metadata/oracle_defog_graphs.json | 4663 ++++++++++++++++++ tests/test_pipeline_oracle.py | 282 ++ 3 files changed, 5269 insertions(+), 148 deletions(-) create mode 100644 tests/test_metadata/oracle_defog_graphs.json create mode 100644 tests/test_pipeline_oracle.py diff --git a/tests/conftest.py b/tests/conftest.py index a3389f7c1..41a33480e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -238,6 +238,22 @@ def impl(name: str) -> GraphMetadata: return impl +@pytest.fixture(scope="session") +def get_oracle_defog_graphs() -> graph_fetcher: + """ + Returns the graphs for the defog database in Oracle. + """ + + @cache + def impl(name: str) -> GraphMetadata: + path: str = ( + f"{os.path.dirname(__file__)}/test_metadata/oracle_defog_graphs.json" + ) + return pydough.parse_json_metadata_from_file(file_path=path, graph_name=name) + + return impl + + @pytest.fixture(scope="session") def get_sample_graph( sample_graph_path: str, @@ -1285,6 +1301,160 @@ def postgres_params_tpch_db_context( ) +ORACLE_ENVS = ["ORACLE_PASSWORD"] +""" + Oracle environment variables required for connection. + `ORACLE_PASSWORD`: The password for Oracle. +""" + + +@pytest.fixture(scope="session") +def require_oracle_env() -> None: + """ + Check if the Oracle environment variables are set. Allowing empty strings. + Returns: + bool: True if all required Oracle environment variables are set, False otherwise. + """ + if not all(os.getenv(var) is not None for var in ORACLE_ENVS): + pytest.skip("Skipping Oracle tests: environment variables not set.") + + +ORACLE_DOCKER_CONTAINER = "oracle_tpch_test" +ORACLE_DOCKER_IMAGE = "bodoai1/pydough-oracle-tpch:latest" +ORACLE_HOST = "127.0.0.1" +ORACLE_PORT = 1521 +""" + CONSTANTS for the Oracle Docker container setup. + - ORACLE_DOCKER_CONTAINER: The name of the Docker container. + - ORACLE_DOCKER_IMAGE: The Docker image to use for the Oracle container. + - ORACLE_HOST: The host address for Oracle. + - ORACLE_PORT: The port on which Oracle is exposed. +""" + + +@pytest.fixture(scope="session") +def oracle_docker_setup() -> None: + """Set up the Oracle Docker container for testing.""" + try: + if not is_ci(): + if container_exists(ORACLE_DOCKER_CONTAINER): + if not container_is_running(ORACLE_DOCKER_CONTAINER): + subprocess.run( + ["docker", "start", ORACLE_DOCKER_CONTAINER], check=True + ) + else: + subprocess.run( + [ + "docker", + "run", + "-d", + "--name", + ORACLE_DOCKER_CONTAINER, + "--platform", + "linux/amd64", + "-p", + f"{ORACLE_PORT}:{ORACLE_PORT}", + "-e", + f"ORACLE_PWD={os.getenv('ORACLE_PASSWORD')}", + ORACLE_DOCKER_IMAGE, + ], + check=True, + ) + except subprocess.CalledProcessError as e: + pytest.fail(f"Failed to set up Oracle Docker container: {e}") + + # Check import is successful + try: + import oracledb + except ImportError as e: + raise RuntimeError("python-oracledb is not installed") from e + + # Wait for Oracle to be ready for 3 minutes max + # Check for keywords (last created schema) + conn: oracledb.Connection | None = None + for _ in range(180): + try: + if not conn: + conn = oracledb.connect( + user="tpch", + password=os.getenv("ORACLE_PASSWORD"), + host=ORACLE_HOST, + port=ORACLE_PORT, + service_name="FREEPDB1", + ) + + # Checking the last last table of keywords was loaded correctly + # before running the test + cur = conn.cursor() + cur.execute("SELECT COUNT(*) FROM lineitem") + row = cur.fetchone() + if row and row[0] == 6001215: + conn.close() + break + else: + print(f"Waiting {_ + 1}/180 seconds for data to be load...") + time.sleep(1) + + except oracledb.Error as e: + print("Error occurred while connecting to Oracle:", e) + print(f"Waiting {_ + 1}/180 seconds for Oracle to be ready...") + time.sleep(1) + else: + subprocess.run(["docker", "rm", "-f", ORACLE_DOCKER_CONTAINER]) + pytest.fail("Oracle container did not become ready in time.") + + +@pytest.fixture(scope="session") +def oracle_conn_db_context( + require_oracle_env, oracle_docker_setup +) -> Callable[[str], DatabaseContext]: + """ + This fixture is used to connect to the Oracle TPCH/Defog database using + a connection object. + Returns a DatabaseContext for the Oracle TPCH/Defog database. + """ + import oracledb + + @cache + def _impl(oracle_user: str) -> DatabaseContext: + oracle_password = os.getenv("ORACLE_PASSWORD") + + connection: oracledb.Connection = oracledb.connect( + user=oracle_user, + password=oracle_password, + host=ORACLE_HOST, + port=ORACLE_PORT, + service_name="FREEPDB1", + ) + return load_database_context( + "oracle", + connection=connection, + ) + + return _impl + + +@pytest.fixture +def oracle_params_tpch_db_context( + require_oracle_env, oracle_docker_setup +) -> DatabaseContext: + """ + This fixture is used to connect to the oracle TPCH database using + parameters instead of a connection object. + Returns a DatabaseContext for the oracle TPCH database. + """ + oracle_password: str | None = os.getenv("ORACLE_PASSWORD") + + return load_database_context( + "oracle", + user="tpch", + password=oracle_password, + host=ORACLE_HOST, + port=ORACLE_PORT, + service_name="FREEPDB1", + ) + + @pytest.fixture(scope="session") def get_pagerank_graph() -> graph_fetcher: """ @@ -2023,154 +2193,160 @@ def tpch_custom_test_data_dialect_replacements( Replace specific TPC-H custom test data with dialect-specific versions. """ if test.test_name == "string_format_specifiers": - if dialect == DatabaseDialect.MYSQL: - return PyDoughPandasTest( - string_format_specifiers_mysql, - "TPCH", - lambda: pd.DataFrame( - { - "d1": ["Sat"], - "d2": ["Jul"], - "d3": ["7"], - "d4": ["15th"], - "d5": ["15"], - "d6": ["15"], - "d7": ["000000"], - "d8": ["14"], - "d9": ["02"], - "d10": ["02"], - "d11": ["30"], - "d12": ["196"], - "d13": ["14"], - "d14": ["2"], - "d15": ["30"], - "d16": ["07"], - "d17": ["PM"], - "d18": ["02:30:45 PM"], - "d19": ["45"], - "d20": ["45"], - "d21": ["14:30:45"], - "d22": ["28"], - "d23": ["28"], - "d24": ["28"], - "d25": ["28"], - "d26": ["28"], - "d27": ["6"], - "d28": ["2023"], - "d29": ["2023"], - "d30": ["2023"], - "d31": ["23"], - "d32": ["2023-07-15"], - "d33": ["14:30"], - } - ), - "string_format_specifiers", - ) - elif dialect == DatabaseDialect.POSTGRES: - return PyDoughPandasTest( - string_format_specifiers_postgres, - "TPCH", - lambda: pd.DataFrame( - { - # HOURS / MINUTES / SECONDS - "h1": ["02"], # HH - "h2": ["02"], # HH12 - "h3": ["14"], # HH24 - "m1": ["30"], # MI - "s1": ["45"], # SS - "ms1": ["000"], # MS - "us1": ["000000"], # US - "ff1": ["0"], # FF1 - "ff2": ["00"], # FF2 - "ff3": ["000"], # FF3 - "ff4": ["0000"], # FF4 - "ff5": ["00000"], # FF5 - "ff6": ["000000"], # FF6 - "ssss1": ["52245"], # SSSS - "ssss2": ["52245"], # SSSSS - # MERIDIEM - "am1": ["PM"], # AM - "am2": ["pm"], # am - "am3": ["P.M."], # A.M. - "am4": ["p.m."], # a.m. - # YEAR FORMATS - "y1": ["2,023"], # Y,YYY - "y2": ["2023"], # YYYY - "y3": ["023"], # YYY - "y4": ["23"], # YY - "y5": ["3"], # Y - "iy1": ["2023"], # IYYY - "iy2": ["023"], # IYY - "iy3": ["23"], # IY - "iy4": ["3"], # I - # ERA - "era1": ["AD"], # AD - "era2": ["A.D."], # A.D. - # MONTH NAMES - "mon1": ["JULY "], # MONTH (blank-padded) - "mon2": ["July "], # Month - "mon3": ["july "], # month - "mon4": ["JUL"], # MON - "mon5": ["Jul"], # Mon - "mon6": ["jul"], # mon - "mon7": ["07"], # MM - # DAY NAMES - "day1": ["SATURDAY "], # DAY (blank-padded) - "day2": ["Saturday "], # Day - "day3": ["saturday "], # day - "day4": ["SAT"], # DY - "day5": ["Sat"], # Dy - "day6": ["sat"], # dy - # DAY / WEEK / YEAR METRICS - "doy1": ["196"], # DDD - "doy2": ["195"], # IDDD - "dom1": ["15"], # DD - "dow1": ["7"], # D (Sunday=1) - "dow2": ["6"], # ID (Monday=1) - "wom1": ["3"], # W - "woy1": ["28"], # WW - "woy2": ["28"], # IW - # OTHER DATE COMPONENTS - "c1": ["21"], # CC - "j1": ["2460141"], # J (Julian day number) - "q1": ["3"], # Q - "rm1": ["VII "], # RM - "rm2": ["vii "], # rm - # TIME ZONE (timestamp without time zone β†’ empty) - "tz1": [""], # TZ - "tz2": [""], # tz - "tz3": ["+00"], # TZH - "tz4": ["00"], # TZM - "tz5": ["+00"], # OF - } - ), - "string_format_specifiers", - ) - elif dialect == DatabaseDialect.SNOWFLAKE: - return PyDoughPandasTest( - string_format_specifiers_snowflake, - "TPCH", - lambda: pd.DataFrame( - { - "d1": ["2023"], # YYYY - "d2": ["23"], # YY - "d3": ["07"], # MM - "d4": ["Jul"], # Mon - "d5": ["July"], # MMMM - "d6": ["15"], # DD - "d7": ["Sat"], # DY - "d8": ["Saturday"], # DYDY - "d9": ["14"], # HH24 - "d10": ["02"], # HH12 - "d11": ["30"], # MI - "d12": ["45"], # SS - "d13": ["PM"], # AM / PM - "d14": [".000000000"], # .FF - "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) - } - ), - "string_format_specifiers", - ) + match dialect: + case DatabaseDialect.MYSQL: + return PyDoughPandasTest( + string_format_specifiers_mysql, + "TPCH", + lambda: pd.DataFrame( + { + "d1": ["Sat"], + "d2": ["Jul"], + "d3": ["7"], + "d4": ["15th"], + "d5": ["15"], + "d6": ["15"], + "d7": ["000000"], + "d8": ["14"], + "d9": ["02"], + "d10": ["02"], + "d11": ["30"], + "d12": ["196"], + "d13": ["14"], + "d14": ["2"], + "d15": ["30"], + "d16": ["07"], + "d17": ["PM"], + "d18": ["02:30:45 PM"], + "d19": ["45"], + "d20": ["45"], + "d21": ["14:30:45"], + "d22": ["28"], + "d23": ["28"], + "d24": ["28"], + "d25": ["28"], + "d26": ["28"], + "d27": ["6"], + "d28": ["2023"], + "d29": ["2023"], + "d30": ["2023"], + "d31": ["23"], + "d32": ["2023-07-15"], + "d33": ["14:30"], + } + ), + "string_format_specifiers", + ) + + case DatabaseDialect.POSTGRES: + return PyDoughPandasTest( + string_format_specifiers_postgres, + "TPCH", + lambda: pd.DataFrame( + { + # HOURS / MINUTES / SECONDS + "h1": ["02"], # HH + "h2": ["02"], # HH12 + "h3": ["14"], # HH24 + "m1": ["30"], # MI + "s1": ["45"], # SS + "ms1": ["000"], # MS + "us1": ["000000"], # US + "ff1": ["0"], # FF1 + "ff2": ["00"], # FF2 + "ff3": ["000"], # FF3 + "ff4": ["0000"], # FF4 + "ff5": ["00000"], # FF5 + "ff6": ["000000"], # FF6 + "ssss1": ["52245"], # SSSS + "ssss2": ["52245"], # SSSSS + # MERIDIEM + "am1": ["PM"], # AM + "am2": ["pm"], # am + "am3": ["P.M."], # A.M. + "am4": ["p.m."], # a.m. + # YEAR FORMATS + "y1": ["2,023"], # Y,YYY + "y2": ["2023"], # YYYY + "y3": ["023"], # YYY + "y4": ["23"], # YY + "y5": ["3"], # Y + "iy1": ["2023"], # IYYY + "iy2": ["023"], # IYY + "iy3": ["23"], # IY + "iy4": ["3"], # I + # ERA + "era1": ["AD"], # AD + "era2": ["A.D."], # A.D. + # MONTH NAMES + "mon1": ["JULY "], # MONTH (blank-padded) + "mon2": ["July "], # Month + "mon3": ["july "], # month + "mon4": ["JUL"], # MON + "mon5": ["Jul"], # Mon + "mon6": ["jul"], # mon + "mon7": ["07"], # MM + # DAY NAMES + "day1": ["SATURDAY "], # DAY (blank-padded) + "day2": ["Saturday "], # Day + "day3": ["saturday "], # day + "day4": ["SAT"], # DY + "day5": ["Sat"], # Dy + "day6": ["sat"], # dy + # DAY / WEEK / YEAR METRICS + "doy1": ["196"], # DDD + "doy2": ["195"], # IDDD + "dom1": ["15"], # DD + "dow1": ["7"], # D (Sunday=1) + "dow2": ["6"], # ID (Monday=1) + "wom1": ["3"], # W + "woy1": ["28"], # WW + "woy2": ["28"], # IW + # OTHER DATE COMPONENTS + "c1": ["21"], # CC + "j1": ["2460141"], # J (Julian day number) + "q1": ["3"], # Q + "rm1": ["VII "], # RM + "rm2": ["vii "], # rm + # TIME ZONE (timestamp without time zone β†’ empty) + "tz1": [""], # TZ + "tz2": [""], # tz + "tz3": ["+00"], # TZH + "tz4": ["00"], # TZM + "tz5": ["+00"], # OF + } + ), + "string_format_specifiers", + ) + + case DatabaseDialect.SNOWFLAKE: + return PyDoughPandasTest( + string_format_specifiers_snowflake, + "TPCH", + lambda: pd.DataFrame( + { + "d1": ["2023"], # YYYY + "d2": ["23"], # YY + "d3": ["07"], # MM + "d4": ["Jul"], # Mon + "d5": ["July"], # MMMM + "d6": ["15"], # DD + "d7": ["Sat"], # DY + "d8": ["Saturday"], # DYDY + "d9": ["14"], # HH24 + "d10": ["02"], # HH12 + "d11": ["30"], # MI + "d12": ["45"], # SS + "d13": ["PM"], # AM / PM + "d14": [".000000000"], # .FF + "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) + } + ), + "string_format_specifiers", + ) + case _: + pytest.skip("Skipping test: Unsupported dialect for test replacement") + return test diff --git a/tests/test_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json new file mode 100644 index 000000000..5ae1d3fed --- /dev/null +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -0,0 +1,4663 @@ +[ + { + "name": "Broker", + "version": "V2", + "collections": [ + { + "name": "customers", + "type": "simple table", + "table path": "sbCustomer", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "sbCustId", + "data type": "string", + "description": "The unique identifying string for the customer", + "sample values": ["C001", "C005", "C014"], + "synonyms": ["customer key"] + }, + { + "name": "name", + "type": "table column", + "column name": "sbCustName", + "data type": "string", + "description": "The name of the customer", + "sample values": ["Ava Wilson", "Bob Johnson", "David Kim", "Emily Davis"], + "synonyms": ["customer name", "first and last name"] + }, + { + "name": "email", + "type": "table column", + "column name": "sbCustEmail", + "data type": "string", + "description": "The email of the customer", + "sample values": ["alex.rodriguez@email.com", "ava.wilson@email.com", "arah.nguyen@email.com", "samantha.lee@email.com"], + "synonyms": ["email address", "customer email"] + }, + { + "name": "phone", + "type": "table column", + "column name": "sbCustPhone", + "data type": "string", + "description": "The phone number of the customer", + "sample values": ["555-123-4567", "555-623-7419", "555-135-7902"], + "synonyms": ["phone number", "customer phone"] + }, + { + "name": "address1", + "type": "table column", + "column name": "sbCustAddress1", + "data type": "string", + "description": "The address of the customer", + "sample values": ["123 Main St", "951 Pine Rd", "246 Elm St", "258 Elm Ave"], + "synonyms": ["first address line", "street address"] + }, + { + "name": "address2", + "type": "table column", + "column name": "sbCustAddress2", + "data type": "string", + "description": "The second address of the customer, if one exists", + "synonyms": ["second address line"] + }, + { + "name": "city", + "type": "table column", + "column name": "sbCustCity", + "data type": "string", + "description": "The city the customer lives in", + "sample values": ["Anytown", "Yourtown", "Someville", "Mytown"], + "synonyms": ["customer address city"] + }, + { + "name": "state", + "type": "table column", + "column name": "sbCustState", + "data type": "string", + "description": "The state the customer lives in, by its capitalized two-letter abbreviation", + "sample values": ["CA", "NY", "TX", "FL", "NJ"], + "synonyms": ["customer address state"] + }, + { + "name": "country", + "type": "table column", + "column name": "sbCustCountry", + "data type": "string", + "description": "The country the customer lives in", + "sample values": ["USA"], + "synonyms": ["customer address country"] + }, + { + "name": "postal_code", + "type": "table column", + "column name": "sbCustPostalCode", + "data type": "string", + "description": "The postal/zip code of the customer's address", + "sample values": ["90001", "10002", "08801"], + "synonyms": ["zip code", "customer address postal code"] + }, + { + "name": "join_date", + "type": "table column", + "column name": "sbCustJoinDate", + "data type": "datetime", + "description": "The date the customer joined the brokerage", + "synonyms": ["signup date", "customer join date", "account creation date"] + }, + { + "name": "status", + "type": "table column", + "column name": "sbCustStatus", + "data type": "string", + "description": "The state of the customer's account, which is either 'active', 'inactive', or 'suspended'", + "sample values": ["active", "inactive", "suspended"], + "synonyms": ["customer account status", "activity state"] + } + ], + "description": "The customers who have accounts with the the brokerage", + "synonyms": ["users", "clients", "members", "subscribers"] + }, + { + "name": "tickers", + "type": "simple table", + "table path": "sbTicker", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "sbTickerId", + "data type": "string", + "description": "The unique identifying string for each ticker", + "sample values": ["T001", "T003", "T007", "T0018"], + "synonyms": ["ticker key"] + }, + { + "name": "symbol", + "type": "table column", + "column name": "sbTickerSymbol", + "data type": "string", + "description": "The symbol used to abbreviate the ticker name in a recognizable manner, e.g. APPL for Apple, or GOOG for Google", + "sample values": ["APPL", "AMZN", "BRK.B", "FB", "GOOG", "NFLX", "MSFT"], + "synonyms": ["ticker symbol", "ticker abbreviation"] + }, + { + "name": "name", + "type": "table column", + "column name": "sbTickerName", + "data type": "string", + "description": "The full name of the ticker, e.g. the company name", + "sample values": ["Berkshire Hathaway Inc.", "Alphabet Inc.", "Apple Inc.", "Microsoft Corporation"], + "synonyms": ["company name", "business name"] + }, + { + "name": "ticker_type", + "type": "table column", + "column name": "sbTickerType", + "data type": "string", + "description": "The category of ticker, which is either 'stock', 'etf', or 'mutual fund'", + "sample values": ["stock", "etf", "mutual fund"], + "synonyms": ["category", "classification"] + }, + { + "name": "exchange", + "type": "table column", + "column name": "sbTickerExchange", + "data type": "string", + "description": "The exchange that the ticker is listed on, which is either 'NASDAQ', 'NYSE', 'NYSE Arca', or 'Vanguard'", + "sample values": ["NASDAQ", "NYSE", "NYSE Arca", "Vanguard"], + "synonyms": [] + }, + { + "name": "currency", + "type": "table column", + "column name": "sbTickerCurrency", + "data type": "string", + "description": "The currency that the ticker is traded in, which is always 'USD'", + "sample values": ["USD"] + }, + { + "name": "db2x", + "type": "table column", + "column name": "sbTickerDb2x", + "data type": "string", + "description": "The two-letter exchange code corresponding to the ticker's exchange, which is either 'NQ' for NASDAQ, 'NY' for NYSE, 'NX' for 'NYSE Arca', or 'VA' for Vanguard", + "sample values": ["NQ", "NY", "NX", "VG"], + "synonyms": ["exchange code"] + }, + { + "name": "is_active", + "type": "table column", + "column name": "sbTickerIsActive", + "data type": "bool", + "description": "Whether the ticker is still active", + "synonyms": ["ticker in use"] + } + ], + "description": "All of the tickers that the brokerage trades", + "synonyms": ["stocks", "etfs", "mutual funds"] + }, + { + "name": "daily_prices", + "type": "simple table", + "table path": "sbDailyPrice", + "unique properties": [["ticker_id", "date"]], + "properties": [ + { + "name": "ticker_id", + "type": "table column", + "column name": "sbDpTickerId", + "data type": "string", + "description": "The ticker id from the ticker whose price is being record", + "sample values": ["T002", "T003", "T005", "T007", "T011"], + "synonyms": ["ticker key"] + }, + { + "name": "date", + "type": "table column", + "column name": "sbDpDate", + "data type": "datetime", + "description": "The date of the price record", + "synonyms": ["record datetime", "price update date"] + }, + { + "name": "_open", + "type": "table column", + "column name": "sbDpOpen", + "data type": "numeric", + "description": "The opening price of the ticker on the day of the record", + "sample values": [150, 3200, 2500, 280], + "synonyms": ["opening price"] + }, + { + "name": "high", + "type": "table column", + "column name": "sbDpHigh", + "data type": "numeric", + "description": "The highest price of the ticker during the day of the record", + "sample values": [152.5, 282.75, 3225, 185, 2525], + "synonyms": ["high price", "high-point", "maximum price during day"] + }, + { + "name": "low", + "type": "table column", + "column name": "sbDpLow", + "data type": "numeric", + "description": "The lowest price of the ticker during the day of the record", + "sample values": [148.75, 279.5, 3180, 178.5, 2475], + "synonyms": ["low price", "low-point", "minimum price during day"] + }, + { + "name": "close", + "type": "table column", + "column name": "sbDpClose", + "data type": "numeric", + "description": "The close price of the ticker on the day of the record", + "sample values": [151.25, 281, 3210, 184.25, 2510], + "synonyms": ["closing price"] + }, + { + "name": "volume", + "type": "table column", + "column name": "sbDpVolume", + "data type": "numeric", + "description": "The total number of shares of the ticker traded during the day", + "sample values": [75000000, 4000000, 1500000, 35000000], + "synonyms": ["daily trading volume"] + }, + { + "name": "epoch_ms", + "type": "table column", + "column name": "sbDpEpochMs", + "data type": "numeric", + "description": "The number of milliseconds since the epoch (January 1, 1970) that the record was created", + "sample values": [1680336000000, 1680336000000, 1680336000000], + "synonyms": ["created timestamp in epoch milliseconds"] + }, + { + "name": "source", + "type": "table column", + "column name": "sbDpSource", + "data type": "string", + "description": "The exchange where the price record originated from, which is either 'NASDAQ', 'NYSE' or 'Vanguard'", + "sample values": ["NYSE", "NASDAQ", "Vanguard"], + "synonyms": ["price record origin"] + } + ], + "description": "The daily updates on tickers including their price information within a single day", + "synonyms": ["historical stock prices", "daily ticker price data"] + }, + { + "name": "transactions", + "type": "simple table", + "table path": "sbTransaction", + "unique properties": ["transaction_id", "kpx"], + "properties": [ + { + "name": "transaction_id", + "type": "table column", + "column name": "sbTxId", + "data type": "string", + "description": "The unique identifying string for each transaction", + "sample values": ["TX035", "TX001", "TX008", "TX033"], + "synonyms": ["transaction key"] + }, + { + "name": "customer_id", + "type": "table column", + "column name": "sbTxCustId", + "data type": "string", + "description": "The id of the customer who made the transaction", + "sample values": ["C003", "C005", "C007", "C001", "C008"], + "synonyms": ["customer key"] + }, + { + "name": "ticker_id", + "type": "table column", + "column name": "sbTxTickerId", + "data type": "string", + "description": "The id of the ticker being bought/sold in the transaction", + "sample values": ["T001", "T007", "T008"], + "synonyms": ["ticker key"] + }, + { + "name": "date_time", + "type": "table column", + "column name": "sbTxDateTime", + "data type": "datetime", + "description": "The timestamp that the transaction was made at", + "synonyms": ["transaction timestamp", "buy/sell datetime"] + }, + { + "name": "transaction_type", + "type": "table column", + "column name": "sbTxType", + "data type": "string", + "description": "The type of transaction, which is either 'buy' or 'sell'", + "sample values": ["buy", "sell"], + "synonyms": ["category", "classification"] + }, + { + "name": "shares", + "type": "table column", + "column name": "sbTxShares", + "data type": "numeric", + "description": "The number of shares being bought/sold in the transaction", + "sample values": [150, 120, 110], + "synonyms": ["volume traded", "transaction size"] + }, + { + "name": "price", + "type": "table column", + "column name": "sbTxPrice", + "data type": "numeric", + "description": "The price that the ticker was bought/sold at in the transaction", + "sample values": [180, 200, 220, 150, 130], + "synonyms": ["buy price", "sell price", "cost", "per-share value"] + }, + { + "name": "amount", + "type": "table column", + "column name": "sbTxAmount", + "data type": "numeric", + "description": "The total monetary value of the transaction (cost for buy, revenue for sell), which is the price multiplied by the number of shares", + "sample values": [27000, 24000, 24200, 15000, 13000], + "synonyms": ["total cost", "total revenue", "transaction value"] + }, + { + "name": "currency", + "type": "table column", + "column name": "sbTxCcy", + "data type": "string", + "description": "The currency that the transaction was made in, which is always 'USD'", + "sample values": ["USD"] + }, + { + "name": "tax", + "type": "table column", + "column name": "sbTxTax", + "data type": "numeric", + "description": "The tax applied by the brokerage onto the transaction", + "sample values": [135, 120, 121, 75, 65], + "synonyms": ["levy", "duty", "tariff"] + }, + { + "name": "commission", + "type": "table column", + "column name": "sbTxCommission", + "data type": "numeric", + "description": "The commission taken by the brokerage for the transaction", + "sample values": [20, 15, 10], + "synonyms": ["brokerage fee", "transaction fee"] + }, + { + "name": "kpx", + "type": "table column", + "column name": "sbTxKpx", + "data type": "string", + "description": "The internal code used for the transaction, which corresponds to the transaction id", + "sample values": ["KP056", "KP053", "KP011"], + "synonyms": [] + }, + { + "name": "settlement_date_str", + "type": "table column", + "column name": "sbTxSettlementDateStr", + "data type": "string", + "description": "The date the transaction was settled, which is a string in the form YYYYMMDD HH:MM:SS, or null if not settled yet", + "sample values": ["20230401 09:30:00", "20230401 10:15:00", "20230401 11:00:00"], + "synonyms": ["settlement timestamp", "datetime of transaction finalization"] + }, + { + "name": "status", + "type": "table column", + "column name": "sbTxStatus", + "data type": "string", + "description": "The status of the transaction, which is either 'success', 'fail', or 'pending'", + "sample values": ["success", "fail", "pending"], + "synonyms": ["transaction state"] + } + ], + "description": "All transactions made through the brokerage", + "synonyms": ["exchanges", "trades", "buy/sell orders"] + } + ], + "relationships": [ + { + "name": "transactions_made", + "type": "simple join", + "parent collection": "customers", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "customer_id" + ] + }, + "description": "All of the transactions made by the customer, including both buys and sells", + "synonyms": ["exchanges made", "trades made", "stock purchases and sales"] + }, + { + "name": "customer", + "type": "reverse", + "original parent": "customers", + "original property": "transactions_made", + "singular": true, + "always matches": true, + "description": "The customer who made the transaction", + "synonyms": ["user", "client", "stock buyer/seller"] + }, + { + "name": "transactions_of", + "type": "simple join", + "parent collection": "tickers", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "ticker_id" + ] + }, + "description": "The transactions made of a ticker, including both buys and sells of the ticker", + "synonyms": ["purchases", "sales", "exchanges", "trades of ticker"] + }, + { + "name": "ticker", + "type": "reverse", + "original parent": "tickers", + "original property": "transactions_of", + "singular": true, + "always matches": true, + "description": "The ticker that the transaction was made of", + "synonyms": ["stock", "etf", "fund", "company"] + }, + { + "name": "ticker", + "type": "simple join", + "parent collection": "daily_prices", + "child collection": "tickers", + "singular": true, + "always matches": true, + "keys": { + "ticker_id": [ + "_id" + ] + }, + "description": "The ticker that the daily price record corresponds to", + "synonyms": ["stock", "etf", "fund", "company"] + }, + { + "name": "daily_prices", + "type": "reverse", + "original parent": "daily_prices", + "original property": "ticker", + "singular": false, + "always matches": false, + "description": "The daily price records for the ticker", + "synonyms": ["historical prices", "price updates"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "Dealership", + "version": "V2", + "collections": [ + { + "name": "cars", + "type": "simple table", + "table path": "cars", + "unique properties": ["_id", "vin_number"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each car", + "sample values": [1, 3, 5, 6, 18], + "synonyms": ["car key", "car id"] + }, + { + "name": "make", + "type": "table column", + "column name": "make", + "data type": "string", + "description": "The make of the car, e.g. Ford, Toyota, etc.", + "sample values": ["Toyota", "Honda", "Ford", "Tesla", "Nissan"], + "synonyms": ["car brand", "car manufacturer"] + }, + { + "name": "model", + "type": "table column", + "column name": "model", + "data type": "string", + "description": "The model name of the car, e..g Civic, Model 3, A4, RX350, Equinox, etc.", + "sample values": ["Camry", "Accord", "Mustang", "Civic", "Altima", "Tiguan"], + "synonyms": ["car model", "car type"] + }, + { + "name": "year", + "type": "table column", + "column name": "year", + "data type": "numeric", + "description": "Year the car was manufactured", + "sample values": [2021, 2022, 2023], + "synonyms": ["year of production", "manufacturing year"] + }, + { + "name": "color", + "type": "table column", + "column name": "color", + "data type": "string", + "description": "Color of the car", + "sample values": ["Silver", "platinum/grey", "blue", "Titan Silver", "black", "ebony black", "baby blue", "Black", "Jade", "Fiery red"], + "synonyms": ["paint color"] + }, + { + "name": "vin_number", + "type": "table column", + "column name": "vin_number", + "data type": "string", + "description": "Vehicle identification number, a unique code used to identify individual motor vehicles", + "sample values": ["1C4HJXDG3NW123456", "1C6SRFFT3NN123456", "3VV2B7AX1NM123456"], + "synonyms": ["VIN", "vehicle ID"] + }, + { + "name": "engine_type", + "type": "table column", + "column name": "engine_type", + "data type": "string", + "description": "Type of engine (e.g., V6, V8, Electric)", + "sample values": [ + "Boxer 4", + "Electric", + "Flat 6", + "Inline 4", + "Inline 6", + "V6", + "V8" + ], + "synonyms": ["motor", "engine model"] + }, + { + "name": "transmission", + "type": "table column", + "column name": "transmission", + "data type": "string", + "description": "Type of transmission, which is always either 'Automatic', 'Manual', or 'CVT'", + "sample values": ["Automatic", "Manual", "CVT"], + "synonyms": ["gearbox", "transmission type"] + }, + { + "name": "cost", + "type": "table column", + "column name": "cost", + "data type": "numeric", + "description": "Cost of the car", + "sample values": [38000.0, 45000.0, 22000.0, 32000.0], + "synonyms": ["value"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the car was added to the system", + "synonyms": ["created timestamp", "system entry date"] + } + ], + "description": "All cars recorded in the dealership system", + "synonyms": ["vehicles", "automobiles"] + }, + { + "name": "salespeople", + "type": "simple table", + "table path": "salespersons", + "unique properties": ["_id", "email"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each salesperson in the dealership", + "sample values": [1, 5, 10, 13], + "synonyms": ["salesperson key", "salesperson id", "salesperson number"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the salesperson", + "sample values": ["John", "Jane", "David", "Sarah"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the salesperson", + "sample values": ["Doe", "Smith", "Taylor", "Thomas"], + "synonyms": ["surname"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "Work email of the salesperson", + "sample values": ["john.doe@autonation.com", "michael.johnson@autonation.com", "jennifer.davis@directauto.com"], + "synonyms": ["email address", "work email"] + }, + { + "name": "phone", + "type": "table column", + "column name": "phone", + "data type": "string", + "description": "Contact phone number of the salesperson, where tte first 3 digits are the area code. Format: (123)-456-7890", + "sample values": ["(555)-123-4567", "(444)-333-4444", "(001)-415-5678", "(555)-789-0123"], + "synonyms": ["phone number", "contact information"] + }, + { + "name": "hire_date", + "type": "table column", + "column name": "hire_date", + "data type": "datetime", + "description": "The date the salesperson was hired", + "synonyms": ["employment date", "start date"] + }, + { + "name": "termination_date", + "type": "table column", + "column name": "termination_date", + "data type": "datetime", + "description": "The date the salesperson left the dealership, if applicable (null if still working there)", + "synonyms": ["firing date", "exit date", "quitting date", "end date"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the salesperson record was created", + "synonyms": ["created timestamp", "system entry date"] + } + ], + "description": "The salespeople working at the dealership, current and former", + "synonyms": ["dealership employees", "sales staff", "sales associates"] + }, + { + "name": "customers", + "type": "simple table", + "table path": "customers", + "unique properties": ["_id", "email"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each customer", + "sample values": [1, 5, 9, 12], + "synonyms": ["customer key", "customer id"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the customer", + "sample values": ["William", "Ava", "Sophia", "Mia"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the customer", + "sample values": ["Davis", "Miller", "Jackson", "Lee"], + "synonyms": ["surname"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "The email address of the customer", + "sample values": ["william.davis@example.com", "charlotte.anderson@example.com", "sophia.lee@microsoft.com", "christopher.brown@ai.com", "abigail.harris@company.io"], + "synonyms": ["contact email", "email address"] + }, + { + "name": "phone", + "type": "table column", + "column name": "phone", + "data type": "string", + "description": "The phone number of the customer listed with the dealership", + "sample values": ["555-888-9999", "555-666-5555", "555-456-7890", "555-444-3333"], + "synonyms": ["contact information", "phone number"] + }, + { + "name": "address", + "type": "table column", + "column name": "address", + "data type": "string", + "description": "The home address of the customer given to the dealership", + "sample values": ["123 Main St", "456 Oak Ave", "987 Birch Dr", "951 Oak Ln"], + "synonyms": ["street address", "home address", "street name and street number"] + }, + { + "name": "city", + "type": "table column", + "column name": "city", + "data type": "string", + "description": "The city of the customer's home address", + "sample values": ["New York", "Los Angeles", "Chicago", "Dallas"] + }, + { + "name": "state", + "type": "table column", + "column name": "state", + "data type": "string", + "description": "The state of the customer's home address, by its capitalized two-letter abbreviation", + "sample values": ["NY", "CA", "TX", "IL"] + }, + { + "name": "zip_code", + "type": "table column", + "column name": "zip_code", + "data type": "string", + "description": "The zip-code of the customer's home address", + "sample values": ["10001", "60007", "95101", "94101"], + "synonyms": [] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the customer record was created", + "synonyms": ["created timestamp", "system entry date"] + } + ], + "description": "All the customers who are registered with the dealership", + "synonyms": ["clients", "users", "buyers", "consumers"] + }, + { + "name": "payments_made", + "type": "simple table", + "table path": "payments_made", + "unique properties": ["_id", "invoice_number"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each payment made", + "sample values": [1, 11, 16, 17], + "synonyms": ["payment key", "payment id"] + }, + { + "name": "vendor_name", + "type": "table column", + "column name": "vendor_name", + "data type": "string", + "description": "Name of the vendor to whom the payment was made", + "sample values": ["Chevrolet Auto", "Marketing Agency", "Car Manufacturer Inc"], + "synonyms": ["payment recipient", "vendor"] + }, + { + "name": "payment_date", + "type": "table column", + "column name": "payment_date", + "data type": "datetime", + "description": "Date that the payment was made" + }, + { + "name": "payment_amount", + "type": "table column", + "column name": "payment_amount", + "data type": "numeric", + "description": "The amount that was paid in the payment in USD", + "sample values": [150000.0, 1500.0, 22000.0], + "synonyms": ["payment sum", "dollar value"] + }, + { + "name": "payment_method", + "type": "table column", + "column name": "payment_method", + "data type": "string", + "description": "Method of payment, which is either 'bank_transfer', 'credit_card', 'check', or 'credit_card'", + "sample values": ["bank_transfer", "credit_card", "check", "credit_card"], + "synonyms": ["transfer medium", "payment type"] + }, + { + "name": "invoice_number", + "type": "table column", + "column name": "invoice_number", + "data type": "string", + "description": "Invoice number associated with the payment", + "sample values": ["INV-001", "INV-017", "INV-008"], + "synonyms": ["invoice id", "invoice key", "invoice serial"] + }, + { + "name": "invoice_date", + "type": "table column", + "column name": "invoice_date", + "data type": "datetime", + "description": "Date of the invoice", + "synonyms": ["date of payment"] + }, + { + "name": "due_date", + "type": "table column", + "column name": "due_date", + "data type": "datetime", + "description": "Due date of the invoice", + "synonyms": ["deadline", "expected payment date"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the payment made record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of payments made by the dealership to vendors", + "synonyms": ["vendor payments", "vendor transactions", "vendor expenditures"] + }, + { + "name": "payments_received", + "type": "simple table", + "table path": "payments_received", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each payment received record", + "sample values": [1, 2, 10, 19, 23], + "synonyms": ["payment key", "payment id"] + }, + { + "name": "sale_id", + "type": "table column", + "column name": "sale_id", + "data type": "numeric", + "description": "The id of the sale that the payment is associated with", + "sample values": [1, 5, 9, 20, 21], + "synonyms": ["sale key", "sale id"] + }, + { + "name": "payment_date", + "type": "table column", + "column name": "payment_date", + "data type": "datetime", + "description": "Date when the payment was received. Can take place after the sale date, or in installments.", + "synonyms": ["transaction date", "installment date"] + }, + { + "name": "payment_amount", + "type": "table column", + "column name": "payment_amount", + "data type": "numeric", + "description": "Amount of the payment received. Can be less than the sale price if the payment is made in installments.", + "sample values": [115000.0, 5000.0, 44000.0, 26000.0], + "synonyms": ["cash received", "payment sum"] + }, + { + "name": "payment_method", + "type": "table column", + "column name": "payment_method", + "data type": "string", + "description": "Method used to make the payment, which can be 'check', 'financing', 'credit_card', 'debit_card', or 'cash'", + "sample values": ["check", "financing", "credit_card", "debit_card", "cash"], + "synonyms": ["transfer method", "payment type"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the payment received record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of payments received by the dealership from customers as part of a sale", + "synonyms": ["car purchase payments", "customer payments", "customer transactions", "car purchase installments"] + }, + { + "name": "sales", + "type": "simple table", + "table path": "sales", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each car sale", + "sample values": [5, 11, 12, 18, 22], + "synonyms": ["sale key", "sale id"] + }, + { + "name": "car_id", + "type": "table column", + "column name": "car_id", + "data type": "numeric", + "description": "The id of the car being purchased in the sale", + "sample values": [1, 3, 5, 6, 18], + "synonyms": ["car key", "car id"] + }, + { + "name": "salesperson_id", + "type": "table column", + "column name": "salesperson_id", + "data type": "numeric", + "description": "The id of the salesperson who brokered the sale", + "sample values": [1, 5, 10, 13], + "synonyms": ["salesperson key", "salesperson id"] + }, + { + "name": "customer_id", + "type": "table column", + "column name": "customer_id", + "data type": "numeric", + "description": "The id of the customer who purchased the car in the sale", + "sample values": [1, 5, 9, 12], + "synonyms": ["customer key", "customer id"] + }, + { + "name": "sale_price", + "type": "table column", + "column name": "sale_price", + "data type": "numeric", + "description": "Price at which the car was sold", + "sample values": [43500.0, 30500.0, 38000.0, 49000.0, 26500.0], + "synonyms": ["purchase cost", "sale amount", "dollar value"] + }, + { + "name": "sale_date", + "type": "table column", + "column name": "sale_date", + "data type": "datetime", + "description": "Date when the car was sold", + "synonyms": ["purchase date", "transaction date"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the sale record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of cars being purchased from the dealership from a customer via one of the salespeople", + "synonyms": ["car purchases", "sale records", "vehicle sale transactions"] + }, + { + "name": "inventory_snapshots", + "type": "simple table", + "table path": "inventory_snapshots", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each inventory snapshot entry", + "sample values": [1, 4, 13, 19, 23], + "synonyms": ["inventory snapshot key", "snapshot id"] + }, + { + "name": "snapshot_date", + "type": "table column", + "column name": "snapshot_date", + "data type": "datetime", + "description": "Date of the inventory snapshot", + "synonyms": ["date of snapshot", "inventory date"] + }, + { + "name": "car_id", + "type": "table column", + "column name": "car_id", + "data type": "numeric", + "description": "The key of the car that the inventory snapshot is for", + "sample values": [2, 10, 1, 4, 9], + "synonyms": ["car key", "car id"] + }, + { + "name": "is_in_inventory", + "type": "table column", + "column name": "is_in_inventory", + "data type": "bool", + "description": "Whether that specific car was in the dealership's inventory at the time of the snapshot", + "synonyms": ["car in inventory", "car availability"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the inventory snapshot record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of whether specific individual cars were in the dealership's inventory as of specific dates", + "synonyms": ["inventory records", "stock records", "car availability manifest"] + } + ], + "relationships": [ + { + "name": "sale_records", + "type": "simple join", + "parent collection": "cars", + "child collection": "sales", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "car_id" + ] + }, + "description": "All sales made where the car was sold", + "synonyms": ["purchases of vehicle", "car sales", "vehicle transactions"] + }, + { + "name": "car", + "type": "reverse", + "original parent": "cars", + "original property": "sale_records", + "singular": true, + "always matches": true, + "description": "The car being purchased in the sale", + "synonyms": ["vehicle", "automobile"] + }, + { + "name": "inventory_snapshots", + "type": "simple join", + "parent collection": "cars", + "child collection": "inventory_snapshots", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "car_id" + ] + }, + "description": "The inventory snapshots for the car, which show whether it was in the dealership's inventory at specific dates", + "synonyms": ["availability records", "inventory history"] + }, + { + "name": "car", + "type": "reverse", + "original parent": "cars", + "original property": "inventory_snapshots", + "singular": true, + "always matches": true, + "description": "The car that the inventory snapshot belongs to", + "synonyms": ["vehicle", "automobile"] + }, + { + "name": "sales_made", + "type": "simple join", + "parent collection": "salespeople", + "child collection": "sales", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "salesperson_id" + ] + }, + "description": "All the sales brokered by the salesperson", + "synonyms": ["sales records", "transactions made", "deals closed"] + }, + { + "name": "salesperson", + "type": "reverse", + "original parent": "salespeople", + "original property": "sales_made", + "singular": true, + "always matches": true, + "description": "The salesperson who brokered the car purchase deal", + "synonyms": ["broker", "sales associate", "sales staff", "dealer"] + }, + { + "name": "car_purchases", + "type": "simple join", + "parent collection": "customers", + "child collection": "sales", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "customer_id" + ] + }, + "description": "All car purchases made by the customer", + "synonyms": ["vehicle purchase records", "car transactions", "automobile purchases"] + }, + { + "name": "customer", + "type": "reverse", + "original parent": "customers", + "original property": "car_purchases", + "singular": true, + "always matches": true, + "description": "The customer who purchased the car", + "synonyms": ["client", "buyer", "purchaser", "consumer", "user"] + }, + { + "name": "payment", + "type": "simple join", + "parent collection": "sales", + "child collection": "payments_received", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "sale_id" + ] + }, + "description": "The payment installments made for the sale, which can be one or multiple installments for a single sale", + "synonyms": ["sale purchase installments", "payment records"] + }, + { + "name": "sale_record", + "type": "reverse", + "original parent": "sales", + "original property": "payment", + "singular": true, + "always matches": true, + "description": "The sale that the payment is a part of", + "synonyms": ["purchase record", "vehicle sale", "car purchase"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "DermTreatment", + "version": "V2", + "collections": [ + { + "name": "doctors", + "type": "simple table", + "table path": "doctors", + "unique properties": ["doc_id"], + "properties": [ + { + "name": "doc_id", + "type": "table column", + "column name": "doc_id", + "data type": "numeric", + "description": "Unique identifier for each doctor in the system", + "sample values": [1, 2, 4, 8, 10], + "synonyms": ["doctor key", "doctor id"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the doctor", + "sample values": ["John", "Michael", "Daniel", "Olivia"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the doctor", + "sample values": ["Smith", "Brown", "Wilson", "Garcia"], + "synonyms": ["surname"] + }, + { + "name": "specialty", + "type": "table column", + "column name": "specialty", + "data type": "string", + "description": "The specialty of the doctor, which can be one of the following: dermatology, immunology, general, or oncology", + "sample values": ["dermatology", "immunology", "general", "oncology"], + "synonyms": ["focus", "area", "specialization", "expertise", "type of doctor"] + }, + { + "name": "year_reg", + "type": "table column", + "column name": "year_reg", + "data type": "numeric", + "description": "Year the doctor was registered and obtained license", + "sample values": [1998, 2006, 2012, 2015, 2018], + "synonyms": ["registration year", "year received license"] + }, + { + "name": "med_school_name", + "type": "table column", + "column name": "med_school_name", + "data type": "string", + "description": "The name of the medical school where the doctor graduated", + "sample values": ["University of Pennsylvania", "Johns Hopkins University", "Columbia University"], + "synonyms": ["alma matter", "medical school", "graduated from"] + }, + { + "name": "city", + "type": "table column", + "column name": "loc_city", + "data type": "string", + "description": "The city where the doctor is located", + "sample values": ["San Francisco", "Durham", "Ann Arbour", "New York"], + "synonyms": ["city of practice", "city of work", "location city", "city of residence"] + }, + { + "name": "state", + "type": "table column", + "column name": "loc_state", + "data type": "string", + "description": "The state where the doctor is located, by its capitalized two-letter abbreviation", + "sample values": ["CA", "NC", "NY", "MI"], + "synonyms": ["state of practice", "state of work", "location state", "state of residence"] + }, + { + "name": "zip_code", + "type": "table column", + "column name": "loc_zip", + "data type": "string", + "description": "The zip code where the doctor is located", + "sample values": ["21201", "02115", "94304", "10027"], + "synonyms": ["zip code of practice", "zip code of work", "location zip code", "zip code of residence"] + }, + { + "name": "board_certification_number", + "type": "table column", + "column name": "bd_cert_num", + "data type": "string", + "description": "The board certification number of the doctor", + "sample values": ["YZA890", "ABC123", "GHI012", "JKL345"], + "synonyms": ["board certification number", "certification number"] + } + ], + "description": "All the doctors registered in the system", + "synonyms": ["practitioners", "physicians", "medical professionals"] + }, + { + "name": "patients", + "type": "simple table", + "table path": "patients", + "unique properties": ["patient_id", "email", "phone"], + "properties": [ + { + "name": "patient_id", + "type": "table column", + "column name": "patient_id", + "data type": "numeric", + "description": "The unique identifier for each patient in the system", + "sample values": [1, 3, 5, 7, 9], + "synonyms": ["patient key", "patient id"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the patient", + "sample values": ["Alice", "Bob", "Carol", "David", "Eve"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the patient", + "sample values": ["Smith", "Richter", "Martinez", "Taylor"], + "synonyms": ["surname"] + }, + { + "name": "date_of_birth", + "type": "table column", + "column name": "date_of_birth", + "data type": "datetime", + "description": "The date the patient was born", + "synonyms": ["birthday"] + }, + { + "name": "date_of_registration", + "type": "table column", + "column name": "date_of_registration", + "data type": "datetime", + "description": "The date the patient was registered in the system", + "synonyms": ["registration date", "system entry date"] + }, + { + "name": "gender", + "type": "table column", + "column name": "gender", + "data type": "string", + "description": "The gender of the patient, which can either 'Male', 'Female', or 'Others'", + "sample values": ["Male", "Female", "Others"], + "synonyms": ["sex"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "The email of the patient used for contact information", + "sample values": ["alice@email.com", "eve@email.com", "frank@email.com", "john@qwik.com'"], + "synonyms": ["email address", "contact email"] + }, + { + "name": "phone", + "type": "table column", + "column name": "phone", + "data type": "string", + "description": "The phone number of the patient used for contact information", + "sample values": ["555-123-4567", "555-987-6543", "555-123-4567"], + "synonyms": ["contact phone", "phone number"] + }, + { + "name": "street_address", + "type": "table column", + "column name": "addr_city", + "data type": "string", + "description": "The street address of the patient's home, including street name and number", + "sample values": ["987 Birch Dr", "753 Walnut Ave", "951 Spruce Blvd"], + "synonyms": ["street name and number", "home address"] + }, + { + "name": "city", + "type": "table column", + "column name": "addr_city", + "data type": "string", + "description": "The city of the patient's address", + "sample values": ["Anytown", "Somecity", "Somewhere", "Somewhere"], + "synonyms": ["home city", "town", "city of residence"] + }, + { + "name": "state", + "type": "table column", + "column name": "addr_state", + "data type": "string", + "description": "The state of the patient's address, by its capitalized two-letter abbreviation", + "sample values": ["CA", "TX", "FL", "OH"], + "synonyms": ["home state", "state of residence"] + }, + { + "name": "zip_code", + "type": "table column", + "column name": "addr_zip", + "data type": "string", + "description": "The zip code of the patient's address", + "sample values": ["12345", "54321", "86420"], + "synonyms": ["home zip code", "postal code", "zip code of residence"] + }, + { + "name": "insurance_type", + "type": "table column", + "column name": "ins_type", + "data type": "string", + "description": "The type of insurance the patient has, which can be one of the following: private, medicare, medicaid, or uninsured", + "sample values": ["private", "medicare", "medicaid", "uninsured"], + "synonyms": [] + }, + { + "name": "insurance_policy_number", + "type": "table column", + "column name": "ins_policy_num", + "data type": "string", + "description": "The policy number of the patient's insurance (null if uninsured)", + "sample values": ["ABC123456", "XYZ789012", "JKL567890", "PQR135790"], + "synonyms": ["policy number"] + }, + { + "name": "height", + "type": "table column", + "column name": "height_cm", + "data type": "numeric", + "description": "The height of the patient in centimeters", + "sample values": [165, 180, 160, 178], + "synonyms": ["centimeter height"] + }, + { + "name": "weight", + "type": "table column", + "column name": "weight_kg", + "data type": "numeric", + "description": "The weight of the patient in kilograms", + "sample values": [60, 78, 90, 60], + "synonyms": ["kilogram weight"] + } + ], + "description": "The personal & registration information about every patient registered in the system", + "synonyms": ["patient records", "patient information", "patient data", "clients", "trial subjects", "participants"] + }, + { + "name": "drugs", + "type": "simple table", + "table path": "drugs", + "unique properties": ["drug_id", "national_drug_code"], + "properties": [ + { + "name": "drug_id", + "type": "table column", + "column name": "drug_id", + "data type": "numeric", + "description": "The unique identifier for each drug in the system", + "sample values": [1, 2, 4, 8], + "synonyms": ["drug key", "drug id"] + }, + { + "name": "drug_name", + "type": "table column", + "column name": "drug_name", + "data type": "string", + "description": "The brand name of the drug", + "sample values": ["Drugalin", "Topizol", "Biologic-X", "Topicalin"], + "synonyms": ["brand name", "pharmaceutical name", "medication name"] + }, + { + "name": "manufacturer", + "type": "table column", + "column name": "manufacturer", + "data type": "string", + "description": "The name of the company who produces the drug", + "sample values": ["Pharma Inc", "Acme Pharma", "Derma Rx", "BioMed Ltd"], + "synonyms": ["producer", "drug manufacturer", "pharmaceutical company", "drug company"] + }, + { + "name": "drug_type", + "type": "table column", + "column name": "drug_type", + "data type": "string", + "description": "The category of drug, which can be one of the following: 'biologic', 'small molecule', or 'topical'", + "sample values": ["biologic", "small molecule", "topical"], + "synonyms": ["category", "classification", "type of drug"] + }, + { + "name": "mechanism_of_activation", + "type": "table column", + "column name": "moa", + "data type": "string", + "description": "The mechanism of activation of the drug", + "sample values": ["TNF-alpha inhibitor", "PDE4 inhibitor", "IL-12/23 inhibitor"], + "synonyms": ["moa"] + }, + { + "name": "fda_approval_date", + "type": "table column", + "column name": "fda_appr_dt", + "data type": "datetime", + "description": "The date the drug was approved by the FDA (null if not approved because it is still under trial)", + "synonyms": ["approval date"] + }, + { + "name": "administration_route", + "type": "table column", + "column name": "admin_route", + "data type": "string", + "description": "The means used to administer the drug, which can be one of the following: 'oral', 'injection' or 'topical'", + "sample values": ["oral", "injection", "topical"], + "synonyms": ["method of procedure", "administration method", "delivery means"] + }, + { + "name": "recommended_dosage_amount", + "type": "table column", + "column name": "dos_amt", + "data type": "numeric", + "description": "The recommended amount of the drug to be taken per dose, where the unit is specified in the dosage_units property", + "sample values": [40, 30, 15, 5], + "synonyms": ["dose size", "quantity per dose", "amount taken per administration"] + }, + { + "name": "dosage_units", + "type": "table column", + "column name": "dos_unit", + "data type": "string", + "description": "The unit used by recommended_dosage_amount, which is either `mg` (for milligrams) or `g` (for grams)", + "sample values": ["mg", "g"], + "synonyms": ["units of measurement", "dosage unit", "dose quantity scale factor"] + }, + { + "name": "dose_frequency_hours", + "type": "table column", + "column name": "dos_freq_hrs", + "data type": "numeric", + "description": "The recommended number of hours between dosages", + "sample values": [336, 24, 12, 672], + "synonyms": ["gap between doses", "administration hour intervals", "time between doses"] + }, + { + "name": "national_drug_code", + "type": "table column", + "column name": "ndc", + "data type": "string", + "description": "The national drug code of the drug, which is a unique identifier assigned to each drug by the FDA", + "sample values": ["12345-678-90", "13579-246-80", "95146-753-19"], + "synonyms": [] + } + ], + "description": "The drugs listed in the system, which are used for treatment of patients", + "synonyms": ["medications", "pharmaceuticals"] + }, + { + "name": "diagnoses", + "type": "simple table", + "table path": "diagnoses", + "unique properties": ["_id", "code", "name"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "DIAG_ID", + "data type": "numeric", + "description": "The unique identifier for each diagnosis in the system", + "sample values": [1, 3, 5, 7, 9], + "synonyms": ["diagnosis key", "diagnosis id"] + }, + { + "name": "code", + "type": "table column", + "column name": "diag_code", + "data type": "string", + "description": "The code of the diagnosis, which is a unique identifier assigned to each diagnosis by the ICD-10 system", + "sample values": ["L40.0", "L40.59", "F40.8", "L40.50"], + "synonyms": ["diagnosis code", "ICD-10 code"] + }, + { + "name": "name", + "type": "table column", + "column name": "diag_name", + "data type": "string", + "description": "Name of the diagnosis, in medical terms", + "sample values": ["Psoriasis vulgaris", "Generalized pustular psoriasis", "Psoriasis, unspecified", "Other psoriatic arthropathy", "Psoriatic arthritis mutilans"], + "synonyms": ["title"] + }, + { + "name": "description", + "type": "table column", + "column name": "diag_desc", + "data type": "string", + "description": "An elaboration of the diagnosis, in more layman's terms and/or with some symptoms included", + "sample values": ["Plaque psoriasis, the most common form", "Psoriasis not further specified", "Includes flexural, erythrodermic, and other rare types", "Small, teardrop-shaped lesions", "Widespread pustules on top of red skin"], + "synonyms": ["details", "symptoms", "explanation"] + } + ], + "description": "Records of each diagnosis in the system, which are identified when treating patients", + "synonyms": ["medical conditions", "diagnostic codes"] + }, + { + "name": "treatments", + "type": "simple table", + "table path": "treatments", + "unique properties": ["treatment_id"], + "properties": [ + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "Unique identifier for each treatment record in the system", + "sample values": [1, 4, 7, 16, 26], + "synonyms": ["treatment id", "treatment key"] + }, + { + "name": "patient_id", + "type": "table column", + "column name": "patient_id", + "data type": "numeric", + "description": "The id of the patient who is receiving the treatment", + "sample values": [1, 3, 5, 7, 9], + "synonyms": ["patient key", "patient id"] + }, + { + "name": "doc_id", + "type": "table column", + "column name": "doc_id", + "data type": "numeric", + "description": "The id of the doctor who is administering the treatment", + "sample values": [1, 2, 4, 8], + "synonyms": ["doctor key", "doctor id"] + }, + { + "name": "drug_id", + "type": "table column", + "column name": "drug_id", + "data type": "numeric", + "description": "The id of the drug being used in the treatment", + "sample values": [1, 2, 3, 5], + "synonyms": ["drug key", "drug id"] + }, + { + "name": "diagnosis_id", + "type": "table column", + "column name": "diag_id", + "data type": "numeric", + "description": "The id of the diagnosis the patient is being treated for", + "sample values": [2, 4, 5, 6, 8], + "synonyms": ["diagnosis key", "diagnosis id"] + }, + { + "name": "start_date", + "type": "table column", + "column name": "start_dt", + "data type": "datetime", + "description": "The date the treatment began", + "synonyms": ["treatment start date", "treatment initiation date"] + }, + { + "name": "end_date", + "type": "table column", + "column name": "end_dt", + "data type": "datetime", + "description": "The date the treatment ended (null if ongoing)", + "synonyms": ["treatment end date", "treatment completion date"] + }, + { + "name": "is_placebo", + "type": "table column", + "column name": "is_placebo", + "data type": "bool", + "description": "True if the treatment is a placebo, false otherwise", + "synonyms": ["placebo treatment", "dummy treatment"] + }, + { + "name": "total_drug_amount", + "type": "table column", + "column name": "tot_drug_amt", + "data type": "numeric", + "description": "The total quantity of the drug used in the treatment, where the unit is specified in the drug_unit property", + "sample values": [240, 180, 720, 360], + "synonyms": ["amount of drug used", "total drug quantity", "total dosage"] + }, + { + "name": "drug_unit", + "type": "table column", + "column name": "drug_unit", + "data type": "string", + "description": "The unit used by total_drug_amount, which is either `mg` (for milligrams) or `g` (for grams)", + "sample values": ["mg", "g"], + "synonyms": ["dosage unit", "unit of measurement", "drug quantity scale factor"] + } + ], + "description": "The records of each treatment administered to patients in the system, which can be either a drug or a placebo", + "synonyms": ["treatment records", "medical treatments", "therapies"] + }, + { + "name": "outcomes", + "type": "simple table", + "table path": "outcomes", + "unique properties": ["outcome_id"], + "properties": [ + { + "name": "outcome_id", + "type": "table column", + "column name": "outcome_id", + "data type": "numeric", + "description": "The unique identifier for each treatment outcome in the system", + "sample values": [1, 5, 16, 20, 21], + "synonyms": ["outcome key", "outcome id"] + }, + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "The id for the treatment that the outcome is related to", + "sample values": [3, 5, 9, 25, 26], + "synonyms": ["treatment key", "treatment id"] + }, + { + "name": "assessment_date", + "type": "table column", + "column name": "assess_dt", + "data type": "datetime", + "description": "The date when the outcome assessment was made", + "synonyms": ["date of assessment", "evaluation date"] + }, + { + "name": "day7_lesion_count", + "type": "table column", + "column name": "day7_lesion_cnt", + "data type": "numeric", + "description": "The number of lesions counted on the patient's skin at day 7 after treatment started", + "sample values": [20, 25, 18, 30, 22], + "synonyms": ["lesions observed on day 7"] + }, + { + "name": "day30_lesion_count", + "type": "table column", + "column name": "day30_lesion_cnt", + "data type": "numeric", + "description": "The number of lesions counted on the patient's skin at day 30 after treatment started (null if not enough time has passed)", + "sample values": [15, 18, 12, 25, 16], + "synonyms": ["lesions observed on day 30"] + }, + { + "name": "day100_lesion_count", + "type": "table column", + "column name": "day100_lesion_cnt", + "data type": "numeric", + "description": "The number of lesions counted on the patient's skin at day 100 after treatment started (null if not enough time has passed)", + "sample values": [5, 8, 3, 12, 6], + "synonyms": ["lesions observed on day 100"] + }, + { + "name": "day7_pasi_score", + "type": "table column", + "column name": "day7_pasi_score", + "data type": "numeric", + "description": "The PASI score calculated at day 7 after treatment started, (Psoriasis Area and Severity Index) which is a measure of the severity of psoriasis from 0 to 72", + "sample values": [12.5, 15.0, 10.8, 18.2, 13.1], + "synonyms": ["PASI on day 7"] + }, + { + "name": "day30_pasi_score", + "type": "table column", + "column name": "day30_pasi_score", + "data type": "numeric", + "description": "The PASI score calculated at day 30 after treatment started, (Psoriasis Area and Severity Index) which is a measure of the severity of psoriasis from 0 to 72 (null if not enough time has passed)", + "sample values": [8.2, 10.1, 6.4, 18.2, 13.1], + "synonyms": ["PASI on day 30"] + }, + { + "name": "day100_pasi_score", + "type": "table column", + "column name": "day100_pasi_score", + "data type": "numeric", + "description": "The PASI score calculated at day 100 after treatment started, (Psoriasis Area and Severity Index) which is a measure of the severity of psoriasis from 0 to 72 (null if not enough time has passed)", + "sample values": [2.1, 3.5, 1.2, 5.8, 2.6], + "synonyms": ["PASI on day 100"] + }, + { + "name": "day7_tewl", + "type": "table column", + "column name": "day7_tewl", + "data type": "numeric", + "description": "TEWL score (Transepidermal Water Loss) calculated at day 7 after treatment started, which is a measure of skin hydration", + "sample values": [18.2, 20.1, 16.5, 22.4], + "synonyms": ["TEWL on day 7"] + }, + { + "name": "day30_tewl", + "type": "table column", + "column name": "day30_tewl", + "data type": "numeric", + "description": "TEWL score (Transepidermal Water Loss) calculated at day 30 after treatment started, which is a measure of skin hydration, in n g/m^2/h (null if not enough time has passed)", + "sample values": [15.6, 17.2, 14.0, 19.1], + "synonyms": ["TEWL on day 30"] + }, + { + "name": "day100_tewl", + "type": "table column", + "column name": "day100_tewl", + "data type": "numeric", + "description": "TEWL score (Transepidermal Water Loss) calculated at day 100 after treatment started, which is a measure of skin hydration, in n g/m^2/h (null if not enough time has passed)", + "sample values": [12.1, 13.5, 10.8, 15.2], + "synonyms": ["TEWL on day 100"] + }, + { + "name": "day7_itch_vas", + "type": "table column", + "column name": "day7_itch_vas", + "data type": "numeric", + "description": "The itch visual analog scale (VAS) score at day 7 after treatment started, which is a measure of itch severity from 0 to 100", + "sample values": [60, 70, 55, 80, 65], + "synonyms": ["VAS on day 7"] + }, + { + "name": "day30_itch_vas", + "type": "table column", + "column name": "day30_itch_vas", + "data type": "numeric", + "description": "The itch visual analog scale (VAS) score at day 30 after treatment started, which is a measure of itch severity from 0 to 100 (null if not enough time has passed)", + "sample values": [40, 50, 35, 60, 45], + "synonyms": ["VAS on day 30"] + }, + { + "name": "day100_itch_vas", + "type": "table column", + "column name": "day100_itch_vas", + "data type": "numeric", + "description": "The itch visual analog scale (VAS) score at day 100 after treatment started, which is a measure of itch severity from 0 to 100 (null if not enough time has passed)", + "sample values": [20, 30, 15, 40, 25], + "synonyms": ["VAS on day 100"] + }, + { + "name": "day7_hfg", + "type": "table column", + "column name": "day7_hfg", + "data type": "numeric", + "description": "Hair growth factor (HGF) score at day 7 after treatment started, on a scale from 0 to 5", + "sample values": [1.5, 1.0, 2.0, 0.5, 1.2], + "synonyms": ["HFG on day 7"] + }, + { + "name": "day30_hfg", + "type": "table column", + "column name": "day30_hfg", + "data type": "numeric", + "description": "Hair growth factor (HGF) score at day 30 after treatment started, on a scale from 0 to 5 (null if not enough time has passed)", + "sample values": [2.5, 2.0, 3.0, 1.5, 2.2], + "synonyms": ["HFG on day 30"] + }, + { + "name": "day100_hfg", + "type": "table column", + "column name": "day100_hfg", + "data type": "numeric", + "description": "Hair growth factor (HGF) score at day 100 after treatment started, on a scale from 0 to 5 (null if not enough time has passed)", + "sample values": [4.0, 3.5, 4.5, 3.0, 3.8], + "synonyms": ["HFG on day 100"] + } + ], + "description": "The recorded outcomes of treatments, which can include the same treatment at different points in time if not enough time has elapsed to record the complete outcome for a treatment", + "synonyms": ["results", "treatment evaluations", "assessments"] + }, + { + "name": "concomitant_meds", + "type": "simple table", + "table path": "concomitant_meds", + "unique properties": ["_id", ["treatment_id", "medicine_name"]], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "The unique identifier for each concomitant medication record in the system", + "sample values": [1, 5, 12, 14, 15], + "synonyms": ["concomitant drug key", "concomitant drug id"] + }, + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "The id of the treatment that the concomitant medication record is related to", + "sample values": [1, 4, 8, 11, 13, 14], + "synonyms": [] + }, + { + "name": "medicine_name", + "type": "table column", + "column name": "med_name", + "data type": "string", + "description": "The name of the medicine being taken by the patient as a concomitant drug", + "sample values": ["Acetaminophen", "Ibuprofen", "Loratadine", "Multivitamin", "Calcium supplement", "Vitamin D", "Hydrocortisone cream"], + "synonyms": ["concomitant drug name"] + }, + { + "name": "start_date", + "type": "table column", + "column name": "start_dt", + "data type": "string", + "description": "Date the concomitant drug treatment was started", + "synonyms": ["concomitant drug start date", "first date"] + }, + { + "name": "end_date", + "type": "table column", + "column name": "end_dt", + "data type": "string", + "description": "Date the concomitant drug treatment finished (null if ongoing)", + "synonyms": ["last date", "concomitant drug end date"] + }, + { + "name": "dose_amount", + "type": "table column", + "column name": "dose_amt", + "data type": "numeric", + "description": "The amount of the medicine taken per dose, where the unit is specified in the dose_unit property", + "sample values": [500, 200, 10, 1, 50], + "synonyms": ["amount of dose", "quantity per dose", "dose size"] + }, + { + "name": "dose_unit", + "type": "table column", + "column name": "dose_unit", + "data type": "string", + "description": "The unit used by dose_amount", + "sample values": ["mg", "g", "tablet", "IU"], + "synonyms": [] + }, + { + "name": "dose_frequency", + "type": "table column", + "column name": "freq_hrs", + "data type": "numeric", + "description": "The frequency of the dose in hours (null if one-time use)", + "sample values": [6, 24, 8, 12], + "synonyms": ["gap between doses", "administration hour intervals", "time between doses"] + } + ], + "description": "Records of medications that are taken by patients in addition to the treatment they are receiving during their treatment", + "synonyms": ["additional drugs", "ancillary medications", "concomitant drugs", "accompanying medications", "concurrent drugs"] + }, + { + "name": "adverse_events", + "type": "simple table", + "table path": "adverse_events", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "The unique identifier for each adverse event record in the system", + "sample values": [1, 3, 5, 7, 8], + "synonyms": ["adverse event key", "adverse event id"] + }, + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "The id for the treatment that the adverse event occurred during", + "sample values": [2, 5, 9, 11, 14], + "synonyms": ["treatment key", "treatment id"] + }, + { + "name": "reported_date", + "type": "table column", + "column name": "reported_dt", + "data type": "datetime", + "description": "The date the adverse event was reported", + "synonyms": ["incident date", "date of reaction"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "Descriptor of the adverse event, which can be a single word or a phrase", + "sample values": ["Mild injection site reaction", "Headache, nausea", "Severe allergic reaction, hospitalization required", "Diarrhea"], + "synonyms": [] + } + ], + "description": "All records of adverse events that have been reported in the system related to a treatment", + "synonyms": ["incidents during treatment", "adverse reactions", "side effects"] + } + ], + "relationships": [ + { + "name": "doctor", + "type": "simple join", + "parent collection": "treatments", + "child collection": "doctors", + "singular": true, + "always matches": true, + "keys": { + "doc_id": [ + "doc_id" + ] + }, + "description": "The doctor who administered the treatment", + "synonyms": ["medical professional", "treatment administrator", "prescribing doctor"] + }, + { + "name": "prescribed_treatments", + "type": "reverse", + "original parent": "treatments", + "original property": "doctor", + "singular": false, + "always matches": false, + "description": "The treatments prescribed/administered by the doctor", + "synonyms": ["regimens", "treatment plans", "medical prescriptions"] + }, + { + "name": "patient", + "type": "simple join", + "parent collection": "treatments", + "child collection": "patients", + "singular": true, + "always matches": true, + "keys": { + "patient_id": [ + "patient_id" + ] + }, + "description": "The patient who the treatment was administered to", + "synonyms": ["trial subject", "participant", "client", "drug recipient"] + }, + { + "name": "treatments_received", + "type": "reverse", + "original parent": "treatments", + "original property": "patient", + "singular": false, + "always matches": false, + "description": "The drug treatment regimens the patient has been a part of", + "synonyms": ["Drug regimens", "medical treatments", "therapies", "treatment history"] + }, + { + "name": "drug", + "type": "simple join", + "parent collection": "treatments", + "child collection": "drugs", + "singular": true, + "always matches": true, + "keys": { + "drug_id": [ + "drug_id" + ] + }, + "description": "The drug being used as part of the treatment", + "synonyms": ["medication", "pharmaceutical", "drug product", "therapy"] + }, + { + "name": "treatments_used_in", + "type": "reverse", + "original parent": "treatments", + "original property": "drug", + "singular": false, + "always matches": false, + "description": "The treatments the drug was used in", + "synonyms": ["therapies", "uses", "regimens", "prescriptions"] + }, + { + "name": "diagnosis", + "type": "simple join", + "parent collection": "treatments", + "child collection": "diagnoses", + "singular": true, + "always matches": true, + "keys": { + "diagnosis_id": [ + "_id" + ] + }, + "description": "The diagnosis associated with the treatment which the drug is treating", + "synonyms": ["medical condition", "associated condition", "cause of treatment"] + }, + { + "name": "treatments_for", + "type": "reverse", + "original parent": "treatments", + "original property": "diagnosis", + "singular": false, + "always matches": false, + "description": "The drug treatment regimens targeted at a patient with this diagnosis", + "synonyms": [] + }, + { + "name": "outcome_records", + "type": "simple join", + "parent collection": "treatments", + "child collection": "outcomes", + "singular": false, + "always matches": false, + "keys": { + "treatment_id": [ + "treatment_id" + ] + }, + "description": "The reported outcomes of the treatment, which can include the same treatment at different points in time if not enough time has elapsed to record the complete outcome for a treatment", + "synonyms": ["quality reports", "evaluations", "assessments"] + }, + { + "name": "treatment", + "type": "reverse", + "original parent": "treatments", + "original property": "outcome_records", + "singular": true, + "always matches": true, + "description": "The treatment that the outcome record is reporting on", + "synonyms": ["regimen", "prescription", "medical trial"] + }, + { + "name": "concomitant_meds", + "type": "simple join", + "parent collection": "treatments", + "child collection": "concomitant_meds", + "singular": false, + "always matches": false, + "keys": { + "treatment_id": [ + "treatment_id" + ] + }, + "description": "The ancillary medications that were taken by a patient in addition to the treatment they are receiving during their treatment", + "synonyms": ["additional drugs", "ancillary medications", "concomitant drugs", "accompanying medications", "concurrent drugs"] + }, + { + "name": "treatment", + "type": "reverse", + "original parent": "treatments", + "original property": "concomitant_meds", + "singular": true, + "always matches": true, + "description": "The treatment that the administration of the concomitant medication was related to", + "synonyms": ["medical trial", "regimen", "main prescription"] + }, + { + "name": "adverse_events", + "type": "simple join", + "parent collection": "treatments", + "child collection": "adverse_events", + "singular": false, + "always matches": false, + "keys": { + "treatment_id": [ + "treatment_id" + ] + }, + "description": "Any incident events recorded in association with the treatment", + "synonyms": ["side effects", "medical incidents"] + }, + { + "name": "treatment", + "type": "reverse", + "original parent": "treatments", + "original property": "adverse_events", + "singular": true, + "always matches": true, + "description": "The treatment that the adverse event occurred during", + "synonyms": ["regimen", "medical trial", "prescription"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "Ewallet", + "version": "V2", + "collections": [ + { + "name": "users", + "type": "simple table", + "table path": "users", + "unique properties": ["uid", "username"], + "properties": [ + { + "name": "uid", + "type": "table column", + "column name": "uid", + "data type": "numeric", + "description": "The unique identifier for each user in the system", + "sample values": [1, 3, 5, 10, 11], + "synonyms": ["user id", "user key"] + }, + { + "name": "username", + "type": "table column", + "column name": "username", + "data type": "string", + "description": "The username for the user", + "sample values": ["john_doe", "michael_brown", "bizuser", "huang2143"], + "synonyms": ["name", "account profile"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "The email for the user", + "sample values": ["john.doe@email.com", "lisa.jones@email.com", "customerserv@shopsmart.biz", "huang2143@example.com", "contact@business.co"], + "synonyms": ["email address", "contact email"] + }, + { + "name": "phone_number", + "type": "table column", + "column name": "phone_number", + "data type": "string", + "description": "The phone number for the user (null if not provided), which always starts with a `+` and the country code and does not have dashes", + "sample values": ["+1234567890", "+9876543210", "+8091017161", "+8612345678901", "+6123456789"], + "synonyms": ["phone", "mobile number", "contact number"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the user account was created", + "synonyms": ["account creation date", "registration datetime"] + }, + { + "name": "last_login_at", + "type": "table column", + "column name": "last_login_at", + "data type": "datetime", + "description": "The last time the user logged into their account (null if never logged in)", + "synonyms": ["most recent login datetime", "latest access timestmap"] + }, + { + "name": "user_type", + "type": "table column", + "column name": "user_type", + "data type": "string", + "description": "The type of user, which can be either `individual` or `business`", + "sample values": ["individual", "business"], + "synonyms": ["category", "classification"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the user account, which can be either `active`, `inactive`, `deleted` or `suspended`", + "sample values": ["active", "inactive", "suspended", "deleted"], + "synonyms": ["account state", "activity", "user status"] + }, + { + "name": "country", + "type": "table column", + "column name": "country", + "data type": "string", + "description": "The two-letter country code for the country of the user", + "sample values": ["US", "CA", "FR", "GB", "AU"], + "synonyms": ["nation"] + }, + { + "name": "address_billing", + "type": "table column", + "column name": "address_billing", + "data type": "string", + "description": "The billing address for the user, including street address, city, sometimes province/country, and postal code", + "sample values": ["123 Main St, Anytown US 12345", "456 Oak Rd, Toronto ON M1M2M2", "12 Rue Baptiste, Paris 75001", "12 Mardon Rd, Wellington 6012"], + "synonyms": ["billing location", "billing street address"] + }, + { + "name": "address_delivery", + "type": "table column", + "column name": "address_delivery", + "data type": "string", + "description": "The delivery address for the user, including street address, city, sometimes province/country, and postal code, or null if not provided", + "sample values": ["123 Main St, Anytown US 12345", "25 London Road, Manchester M12 4XY", "19 Smith St, Brunswick VIC 3056"], + "synonyms": [] + }, + { + "name": "kyc_status", + "type": "table column", + "column name": "kyc_status", + "data type": "string", + "description": "The KYC status, which can be either `approved`, `pending`, or `rejected`", + "sample values": ["approved", "pending", "rejected"], + "synonyms": ["approval status", "verification status"] + }, + { + "name": "kyc_verified_at", + "type": "table column", + "column name": "kyc_verified_at", + "data type": "datetime", + "description": "The date when the kyc status became verified (null if not provided)", + "synonyms": ["date of approval", "date of verification"] + } + ], + "description": "Every user in the system, which can be either an individual or a business", + "synonyms": ["accounts", "user profiles", "user accounts", "clients", "consumers"] + }, + { + "name": "merchants", + "type": "simple table", + "table path": "merchants", + "unique properties": ["mid", "name"], + "properties": [ + { + "name": "mid", + "type": "table column", + "column name": "mid", + "data type": "numeric", + "description": "Unique identifier for each merchant in the system", + "sample values": [1, 5, 10, 12, 15], + "synonyms": ["merchant key", "merchant id"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the merchant", + "sample values": ["TechMart", "FitLifeGear", "UrbanDining", "KidzPlayhouse", "GameRush"], + "synonyms": ["merchant name", "business name", "company name"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "The detailed description of what the merchant does or sells", + "sample values": ["Leading electronics retailer", "SaaS productivity tools for developers", "Cosmetics and beauty supplies", "Books and reading accessories"], + "synonyms": ["business industry description", "merchant product types", "market segment description", "company description"] + }, + { + "name": "website_url", + "type": "table column", + "column name": "website_url", + "data type": "string", + "description": "The URL to the merchant's website", + "sample values": ["https://fitlifegear.com", "https://hometechsolutions.net", "https://bookworms.co.uk", "https://www.zenhomegoods.com'"], + "synonyms": ["website link", "web address"] + }, + { + "name": "logo_url", + "type": "table column", + "column name": "logo_url", + "data type": "string", + "description": "The URL to the merchant's logo image", + "sample values": ["https://www.techmart.com/logo.png", "https://www.fashiontrend.com/logo.png", "https://gamerush.co/gr-logo.png", "https://kidzplayhouse.com/logo.png"], + "synonyms": ["image link", "logo image address"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the merchant was registered in the system", + "synonyms": ["merchant registration date", "merchant creation date"] + }, + { + "name": "country", + "type": "table column", + "column name": "country", + "data type": "string", + "description": "The two-letter capitalized country code for the country of the merchant", + "sample values": ["US", "CA", "IT", "FR", "UK"], + "synonyms": ["nation"] + }, + { + "name": "state", + "type": "table column", + "column name": "state", + "data type": "string", + "description": "The state for the merchant within the country, or null if not applicable", + "sample values": ["California", "Ontario", "Catalonia", "New South Wales", "British Columbia"], + "synonyms": ["province"] + }, + { + "name": "city", + "type": "table column", + "column name": "city", + "data type": "string", + "description": "The city for the merchant's location within the country", + "sample values": ["Los Angeles", "Berlin", "Rome", "Vancouver", "Sydney"] + }, + { + "name": "postal_code", + "type": "table column", + "column name": "postal_code", + "data type": "string", + "description": "The postal/zip code of the merchant's location within the city", + "sample values": ["90011", "M5V2J2", "1010", "94105"], + "synonyms": ["zip code"] + }, + { + "name": "address", + "type": "table column", + "column name": "address", + "data type": "string", + "description": "The full address of the merchant, including street address, city, sometimes province, and postal code", + "sample values": ["645 Wilshire Blvd, Los Angeles CA 90011", "159 Franklin St, Melbourne VIC 3004", "350 Mission St, San Francisco CA 94105", "35 Rue du Faubourg Saint-Antoine, 75011 Paris", "Passeig de Gracia 35, Barcelona 08003"], + "synonyms": ["street address", "full location"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the merchant account, which can be either `active`, `inactive` or `suspended`", + "sample values": ["active", "inactive", "suspended"], + "synonyms": ["account state", "activity", "merchant status"] + }, + { + "name": "category", + "type": "table column", + "column name": "category", + "data type": "string", + "description": "The blanket category/industry/market segment that the merchant is in", + "sample values": ["retail (hardware)", "Food & Dining", "Travel & Hospitality", "Retail", "Business Services"], + "synonyms": ["industry", "high-level market segment"] + }, + { + "name": "sub_category", + "type": "table column", + "column name": "sub_category", + "data type": "string", + "description": "The more specific category/industry/market segment that the merchant is in within the category", + "sample values": ["Electronics", "Sporting GOods", "Restaurants", "Accommodation", "Toys & Games", "Books", "Pets", "Groceries"], + "synonyms": ["sub-industry", "specific market segment"] + }, + { + "name": "merchant_category_code", + "type": "table column", + "column name": "mcc", + "data type": "numeric", + "description": "The category code for the merchant, which is a 4-digit number that identifies the type of business", + "sample values": [5734, 5977, 7011, 5719, 5732], + "synonyms": [] + }, + { + "name": "contact_name", + "type": "table column", + "column name": "contact_name", + "data type": "string", + "description": "The full name of the individual who is the primary contact for the merchant", + "sample values": ["John Jacobs", "Daniel Lee", "Marco Rossi", "Sophia Turner"], + "synonyms": ["contact person", "contact individual"] + }, + { + "name": "contact_email", + "type": "table column", + "column name": "contact_email", + "data type": "string", + "description": "The email of the contact person for the merchant", + "sample values": ["jjacobs@techmart.com", "dlee@greengourmet.com", "ebrown@hometechsolutions.net", "sturner@bookworms.co.uk", "mschmidt@codesuite.io", "agarcia@handycraft.store"], + "synonyms": ["contact email", "contact person email"] + }, + { + "name": "contact_phone", + "type": "table column", + "column name": "contact_phone", + "data type": "string", + "description": "The phone number of the contact person, which always starts with a `+` and the country code and does not have dashes", + "sample values": ["+15551234567", "+49301234567", "+441612345678", "+61298765432", "+442078912345"], + "synonyms": ["contact phone number", "contact person phone"] + } + ], + "description": "The merchant accounts registered in the system", + "synonyms": ["companies", "businesses", "vendors", "retailers", "stores"] + }, + { + "name": "coupons", + "type": "simple table", + "table path": "coupons", + "unique properties": ["cid"], + "properties": [ + { + "name": "cid", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "The unique identifier for each coupon in the system", + "sample values": [1, 4, 5, 7, 10], + "synonyms": ["coupon key", "coupon id"] + }, + { + "name": "merchant_id", + "type": "table column", + "column name": "merchant_id", + "data type": "numeric", + "description": "The id of the merchant who issues the coupon", + "sample values": [2, 5, 7, 8, 9], + "synonyms": ["merchant key", "merchant id", "issuing business id"] + }, + { + "name": "code", + "type": "table column", + "column name": "code", + "data type": "string", + "description": "The code used to enter the coupon", + "sample values": ["TECH20", "DINEDISCOUNT", "HOME15", "GLOWUP", "GAMERALERT"], + "synonyms": ["coupon code", "discount code", "promo code"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "A verbal description of what hte coupon is for", + "sample values": ["20% off tech and electronics", "Buy 2 get 1 free on cosmetics'", "Get 25% off accessories", "$10 off $75+ purchase"], + "synonyms": [] + }, + { + "name": "start_date", + "type": "table column", + "column name": "start_date", + "data type": "datetime", + "description": "The date when the coupon first became valid", + "synonyms": ["available since", "valid from"] + }, + { + "name": "end_date", + "type": "table column", + "column name": "end_date", + "data type": "datetime", + "description": "The date when the coupon is no longer valid", + "synonyms": ["available until", "valid until", "expiration date"] + }, + { + "name": "discount_type", + "type": "table column", + "column name": "discount_type", + "data type": "string", + "description": "The category of the coupon, which can be either `percentage` or `fixed_amount`", + "sample values": ["percentage", "fixed_amount"], + "synonyms": ["classification", "category"] + }, + { + "name": "discount_value", + "type": "table column", + "column name": "discount_value", + "data type": "numeric", + "description": "The value of the discount, which is the percentage off if the discount type is `percentage`, or the number of dollars off if `fixed_amount`", + "sample values": [20.0, 30.0, 10.0, 15.0, 25.0], + "synonyms": ["dollars off", "percentage off", "amount", "size"] + }, + { + "name": "min_purchase_amount", + "type": "table column", + "column name": "min_purchase_amount", + "data type": "numeric", + "description": "The minimum amount of money that must be spent on a purchase in USD to be eligible for the coupon (null if not applicable)", + "sample values": [100.0, 50.0, 1000.0, 150.0], + "synonyms": ["minimum spend", "minimum purchase", "minimum order price"] + }, + { + "name": "max_discount_amount", + "type": "table column", + "column name": "max_discount_amount", + "data type": "numeric", + "description": "The maximum amount of money that can be saved using the coupon in USD (null if not applicable)", + "sample values": [50.0, 300.0, 10.0, 15.0], + "synonyms": ["promotion limit", "discount cap", "maximum savings"] + }, + { + "name": "redemption_limit", + "type": "table column", + "column name": "redemption_limit", + "data type": "numeric", + "description": "The maximum number of times the coupon can be redeemed before expiring/becoming invalid (null if not applicable)", + "sample values": [500, 1000, 200, 300, 750], + "synonyms": ["maximum number of uses", "redemption cap", "usage limit"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the coupon, which can be either `active`, `inactive`, or `expired`", + "sample values": ["active", "inactive", "expired"], + "synonyms": ["availability", "usability", "activity state"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "Timestamp when the coupon record was created in the system", + "synonyms": ["creation datetime"] + }, + { + "name": "updated_at", + "type": "table column", + "column name": "updated_at", + "data type": "datetime", + "description": "Timestamp when the coupon record was last updated in the system (null if never updated after creation)", + "synonyms": ["update datetime"] + } + ], + "description": "The records of coupons that have been issued by merchants in the system", + "synonyms": ["discounts", "promotions", "special offers"] + }, + { + "name": "transactions", + "type": "simple table", + "table path": "wallet_transactions_daily", + "unique properties": ["txid", "transaction_ref"], + "properties": [ + { + "name": "txid", + "type": "table column", + "column name": "txid", + "data type": "numeric", + "description": "The unique identifier for each transaction in the system (the original transaction & coupon applied are different rows with different values of this key)", + "sample values": [1, 3, 17, 21, 26], + "synonyms": ["transaction key", "transaction id"] + }, + { + "name": "sender_id", + "type": "table column", + "column name": "sender_id", + "data type": "numeric", + "description": "The id of the key of the individual who sent the transaction, which is either the id of a user or a merchant, depending on sender_type", + "sample values": [1, 3, 8, 4, 10], + "synonyms": [] + }, + { + "name": "sender_type", + "type": "table column", + "column name": "sender_type", + "data type": "numeric", + "description": "Which type of individual sent the transaction: 0 for user (meaning sender_id is a uid from users) or 1 for merchant (meaning sender_id is a mid from merchants)", + "sample values": [0, 1], + "synonyms": ["sent by merchant"] + }, + { + "name": "receiver_id", + "type": "table column", + "column name": "receiver_id", + "data type": "numeric", + "description": "The id of the key of the individual who received the transaction, which is either the id of a user or a merchant, depending on receiver_type", + "sample values": [1, 9, 10, 2, 5], + "synonyms": [] + }, + { + "name": "receiver_type", + "type": "table column", + "column name": "receiver_type", + "data type": "numeric", + "description": "Which type of individual received the transaction: 0 for user (meaning receiver_id is a uid from users) or 1 for merchant (meaning receiver_id is a mid from merchants)", + "sample values": [0, 1], + "synonyms": ["received by merchant"] + }, + { + "name": "amount", + "type": "table column", + "column name": "amount", + "data type": "numeric", + "description": "The dollar amount of the transaction, which is the total amount for a record without a coupon applied, or the amount saved/rebated when the coupon is applied", + "sample values": [99.99, 20.0, 16.0, 125.50, 10.0], + "synonyms": [] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the transaction, which can be either `success`, `failed`, `refunded`, or `pending`", + "sample values": ["success", "failed", "pending", "refunded"], + "synonyms": ["outcome", "result", "transaction status"] + }, + { + "name": "transaction_type", + "type": "table column", + "column name": "type", + "data type": "string", + "description": "The means the transaction was made, which can be either `credit` or `debit", + "sample values": ["credit", "debit"], + "synonyms": ["payment method", "credit or debit"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "The category of transaction, which either says what was purchased or 'Coupon discount' if the transaction is a coupon discount being applied to a previous transaction in the system", + "sample values": ["Online purchase", "Coupon discount", "Product purchase", "Order #438721", "Villa rental deposit", "Refund on order #1234"], + "synonyms": ["description of purchase", "purchase subject"] + }, + { + "name": "coupon_id", + "type": "table column", + "column name": "coupon_id", + "data type": "numeric", + "description": "The id of the coupon being used in the transaction, or null if the transaction is not a coupon discount", + "sample values": [1, 3, 9, 10], + "synonyms": ["coupon key", "coupon id"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the transfer was created in the system", + "synonyms": ["creation datetime"] + }, + { + "name": "completed_at", + "type": "table column", + "column name": "completed_at", + "data type": "datetime", + "description": "The timestamp when the transfer was completed (null if not completed yet)", + "synonyms": ["completion datetime"] + }, + { + "name": "transaction_ref", + "type": "table column", + "column name": "transaction_ref", + "data type": "string", + "description": "Randomly generated uuid4 for users' reference", + "sample values": ["ad154bf7-8185-4230-a8d8-3ef59b4e0012", "kd454bf7-428d-eig2-a8d8-3ef59b4e0012", "a7659c81-0cd0-4635-af6c-cf68d2c15ab2'"], + "synonyms": ["transaction uuid", "reference number"] + }, + { + "name": "gateway_name", + "type": "table column", + "column name": "gateway_name", + "data type": "string", + "description": "The portal through which the transaction was made, which can be either 'Stripe', 'PayPal', 'Checkout.com', 'Braintree' or 'Adyen'", + "sample values": ["Stripe", "PayPal", "Checkout.com", "Braintree", "Adyen"], + "synonyms": ["payment gateway", "payment processor", "payment portal"] + }, + { + "name": "gateway_ref", + "type": "table column", + "column name": "gateway_ref", + "data type": "string", + "description": "A reference number generated by the payment gateway for the transaction, which is used to track the transaction in the payment processor's system", + "sample values": ["tx_123abc456def", "rfnd_xkt521", "sub_pjj908", "stripe_ref_11_1", "paypal_ref_12_1"], + "synonyms": ["gateway reference number", "payment processor reference"] + }, + { + "name": "device_id", + "type": "table column", + "column name": "device_id", + "data type": "string", + "description": "The unique identifier for the device used to make the transaction", + "sample values": ["mobile_8fh2k1", "web_8902wknz", "web_zld22f", "device_11_1", "mobile_1av8p0"], + "synonyms": ["device key", "device identifier", "device number"] + }, + { + "name": "ip_address", + "type": "table column", + "column name": "ip_address", + "data type": "string", + "description": "The IP address of the device used to make the transaction", + "sample values": ["199.59.148.201", "199.59.148.201", "70.121.39.25", "8.26.53.165"], + "synonyms": ["IP"] + }, + { + "name": "user_agent", + "type": "table column", + "column name": "user_agent", + "data type": "string", + "description": "The user agent used to make the transaction, which is a string that identifies the browser, operating system, and device type of the device used to make the transaction", + "sample values": ["Mozilla/5.0 (iPhone; CPU iPhone OS 16_3_1 like Mac OS X) ...", "Mozilla/5.0 (Linux; Android 13; SM-S901B) ...", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ..."], + "synonyms": ["device information", "browser information", "device details"] + } + ], + "description": "Every transaction that has occurred in the system, where the source can be either a user or a merchant and the destination can be either a user or a merchant. If a coupon is used, there will be two identical transaction records, one for the original transaction (where the coupon id is null) and one for the coupon discount applied (where the coupon id is provided)", + "synonyms": ["transfers", "payments", "purchases"] + }, + { + "name": "user_balances", + "type": "simple table", + "table path": "wallet_user_balance_daily", + "unique properties": [["user_id", "updated_at"]], + "properties": [ + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id of the user whose account balance is being recorded", + "sample values": [1, 4, 9, 10, 5], + "synonyms": ["user id", "user key"] + }, + { + "name": "balance", + "type": "table column", + "column name": "balance", + "data type": "numeric", + "description": "The balance of the user's account in USD on the date of the record", + "sample values": [525.80, -725.55, -55.99, -559.98, 0.00, 2733.92], + "synonyms": ["amount in account", "user balance", "account value"] + }, + { + "name": "updated_at", + "type": "table column", + "column name": "updated_at", + "data type": "datetime", + "description": "The timestamp when the user's balance was recorded", + "synonyms": ["update datetime", "balance record date"] + } + ], + "description": "The records of users' account balances in the system, which can include negative balances and multiple records for the same user made at different points in time", + "synonyms": ["user balance histories", "user balance records", "user account balances"] + }, + { + "name": "merchant_balances", + "type": "simple table", + "table path": "wallet_merchant_balance_daily", + "unique properties": [["merchant_id", "updated_at"]], + "properties": [ + { + "name": "merchant_id", + "type": "table column", + "column name": "merchant_id", + "data type": "numeric", + "description": "The id of the merchant whose account balance is being recorded", + "sample values": [2, 4, 5, 9, 1], + "synonyms": ["merchant key", "merchant id"] + }, + { + "name": "balance", + "type": "table column", + "column name": "balance", + "data type": "numeric", + "description": "The balance of the user's account in USD on the date of the record", + "sample values": [3897.99, 29.95, 0.00, 89.99], + "synonyms": ["amount in account", "merchant balance", "account value"] + }, + { + "name": "updated_at", + "type": "table column", + "column name": "updated_at", + "data type": "datetime", + "description": "The timestamp when the merchant's balance was recorded", + "synonyms": ["update datetime", "balance record date"] + } + ], + "description": "The records of merchants' account balances in the system, which can include negative balances and multiple records for the same merchant made at different points in time", + "synonyms": ["merchant balance histories", "merchant balance records", "merchant account balances"] + }, + { + "name": "notifications", + "type": "simple table", + "table path": "notifications", + "unique properties": ["notif_id"], + "properties": [ + { + "name": "notif_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "The unique identifier for each notification in the system", + "sample values": [1, 5, 10, 14, 16], + "synonyms": ["notification key", "notification id"] + }, + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id for the user who received the notification", + "sample values": [3, 5, 9, 10], + "synonyms": ["user key", "user id"] + }, + { + "name": "message", + "type": "table column", + "column name": "message", + "data type": "string", + "description": "The message contained in the notification sent to the user", + "sample values": ["Your order #123abc has been shipped!", "Your CodeSuite subscription will renew on 7/1", "Here''s $10 to start your glow up!'", "Reminder: Your FitLife membership expires in 7 days", "An order from UrbanDining was unsuccessful", "Weekend Flash Sale: 25% off all activewear!"], + "synonyms": ["contents", "text", "description"] + }, + { + "name": "notification_type", + "type": "table column", + "column name": "type", + "data type": "string", + "description": "The type of notification message, which can be either `transaction`, `promotion`, or `general`", + "sample values": ["transaction", "promotion", "general"], + "synonyms": ["message category", "alert classification"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the notification, which can be either `read`, `unread`, or `archived`", + "sample values": ["read", "unread", "archived"], + "synonyms": ["has been read"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the notification was created", + "synonyms": ["creation datetime", "notification creation date"] + }, + { + "name": "read_at", + "type": "table column", + "column name": "read_at", + "data type": "datetime", + "description": "The timestamp when the notification was read (null if not read yet)", + "synonyms": ["datetime read"] + }, + { + "name": "device_type", + "type": "table column", + "column name": "device_type", + "data type": "string", + "description": "The type of device/medium the notification was sent through, which can be either `mobile_app`, `email`, `sms`, or `web_app`", + "sample values": ["mobile_app", "email", "sms", "web_app"], + "synonyms": [] + }, + { + "name": "device_id", + "type": "table column", + "column name": "device_id", + "data type": "string", + "description": "The id of the device the notification was sent to, or null if the device type does not have device ids", + "sample values": ["mobile_8fh2k1", "web_d8180kaf", "mobile_8fh2k1"], + "synonyms": [] + }, + { + "name": "action_url", + "type": "table column", + "column name": "action_url", + "data type": "string", + "description": "The URL included in hte notification that the user can click on to take action; can be external https or deeplink url within the app", + "sample values": ["app://orders/123abc", "https://zenhomesurvey.com/order/c51e10d1", "https://kidzplayhouse.com/new-arrivals", "https://techmart.com/promo/TECH20"], + "synonyms": ["link", "notification hyperlink"] + } + ], + "description": "All notifications sent to users in the system, such as alerts, reminders, and promotional messages", + "synonyms": ["alerts", "messages"] + }, + { + "name": "user_sessions", + "type": "simple table", + "table path": "user_sessions", + "unique properties": [["user_id", "session_start"], ["user_id", "session_end"]], + "properties": [ + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id of the user who the session belongs to", + "sample values": [1, 2, 3, 8, 10], + "synonyms": ["user id", "user key"] + }, + { + "name": "session_start", + "type": "table column", + "column name": "session_start_ts", + "data type": "datetime", + "description": "The timestamp when the user session started", + "synonyms": ["beginning timestamp", "session initialization datetime"] + }, + { + "name": "session_end", + "type": "table column", + "column name": "session_end_ts", + "data type": "datetime", + "description": "The timestamp when the user session ended", + "synonyms": ["ending timestamp", "session termination datetime"] + }, + { + "name": "device_type", + "type": "table column", + "column name": "device_type", + "data type": "string", + "description": "The type of device the session was made with, which can be either `web_app` or `mobile_app`", + "sample values": ["web_app", "mobile_app"], + "synonyms": ["session device", "web or mobile"] + }, + { + "name": "device_id", + "type": "table column", + "column name": "device_id", + "data type": "string", + "description": "The id of the device the session was made with", + "sample values": ["web_d8180kaf", "mobile_g3mjfz", "web_zz91p44l", "web_8902wknz"], + "synonyms": [] + } + ], + "description": "The records of user sessions in the system, which can include multiple sessions for the same user made at different points in time, each session with a start/end timestamp", + "synonyms": ["system logs", "user activity logs", "user session records"] + }, + { + "name": "user_setting_snapshots", + "type": "simple table", + "table path": "user_setting_snapshot", + "unique properties": [["user_id", "snapshot_date"]], + "properties": [ + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id for the user whose settings are being recorded", + "sample values": [1, 2, 3, 5, 9], + "synonyms": ["user key", "user id"] + }, + { + "name": "snapshot_date", + "type": "table column", + "column name": "snapshot_date", + "data type": "datetime", + "description": "The date when the setting snapshot was taken", + "synonyms": ["date of setting update", "recorded date"] + }, + { + "name": "daily_transaction_limit", + "type": "table column", + "column name": "tx_limit_daily", + "data type": "numeric", + "description": "The cap in settings of how much the user account allows to be spent in a single day", + "sample values": [1000.0, 500.0, 50.0, 250.0], + "synonyms": ["daily spending cap"] + }, + { + "name": "monthly_transaction_limit", + "type": "table column", + "column name": "tx_limit_monthly", + "data type": "numeric", + "description": "The cap in settings of how much the user account allows to be spent in a single month", + "sample values": [5000.0, 500.0, 2000.0, 1000.0], + "synonyms": ["monthly spending cap"] + }, + { + "name": "membership_status", + "type": "table column", + "column name": "membership_status", + "data type": "numeric", + "description": "The member's status level within the system: 0 for bronze, 1 for silver, 2 for gold, 3 for platinum, 4 for VIP", + "sample values": [0, 1, 2, 3, 4], + "synonyms": ["rank", "membership level", "membership tier"] + }, + { + "name": "password_hash", + "type": "table column", + "column name": "password_hash", + "data type": "string", + "description": "The hashed password of the user, which is used to verify the user's identity when they log in", + "sample values": ["bcryptHash($2yz9!&ka1)", "bcryptHash($2yz9!&ka1)", "bcryptHash(C0d3Rul3z!99)"], + "synonyms": [] + }, + { + "name": "api_key", + "type": "table column", + "column name": "api_key", + "data type": "string", + "description": "The user's API key, which is used to authenticate the user when they make API requests (null if not provided)", + "sample values": ["9d61c49b-8977-4914-a36b-80d1445e38fa", "6c03c175-9ac9-4854-b064-a3fff2c62e31"], + "synonyms": ["api token", "application programming interface key"] + }, + { + "name": "verified_devices", + "type": "table column", + "column name": "verified_devices", + "data type": "string", + "description": "A comma-separated list of the ids of the devices that have been verified for the user (null if not provided)", + "sample values": ["mobile_8fh2k1", "mobile_yjp08q, mobile_1av8p0", "web_k29qjd, mobile_x28qlj", "web_d8180kaf, mobile_q3mz8n"], + "synonyms": ["device list", "device ids"] + }, + { + "name": "verified_ips", + "type": "table column", + "column name": "verified_ips", + "data type": "string", + "description": "A comma-sparated list of the IP addresses that have been verified for the user (null if not provided)", + "sample values": ["8.26.53.165, 68.85.32.201", "203.96.81.36", "192.168.0.1", "198.51.100.233, 70.121.39.25"], + "synonyms": ["IP addresses", "IP list"] + }, + { + "name": "mfa_enabled", + "type": "table column", + "column name": "mfa_enabled", + "data type": "bool", + "description": "Whether the user has enabled multi-factor authentication (MFA) for their account", + "synonyms": ["has mfa"] + }, + { + "name": "marketing_opt_in", + "type": "table column", + "column name": "marketing_opt_in", + "data type": "bool", + "description": "Whether the user has opted in to receive marketing communications", + "synonyms": ["allowed marketing"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the record was added to the system", + "synonyms": ["system entry date"] + } + ], + "description": "The records of user settings in the system, which can include multiple updates for the same user made at different points in time", + "synonyms": ["user settings history", "user settings records"] + } + ], + "relationships": [ + { + "name": "transactions_sent", + "type": "simple join", + "parent collection": "users", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "sender_id" + ] + }, + "description": "All transactions made where the user is the sender", + "synonyms": ["transactions from user"] + }, + { + "name": "sending_user", + "type": "reverse", + "original parent": "users", + "original property": "transactions_sent", + "singular": true, + "always matches": false, + "description": "The user who sent the transaction, if it was sent by a user (not found if it was sent by a merchant)", + "synonyms": ["source user", "originating user"] + }, + { + "name": "transactions_received", + "type": "simple join", + "parent collection": "users", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "receiver_id" + ] + }, + "description": "The transactions where the user was the recipient", + "synonyms": ["transactions to user"] + }, + { + "name": "receiving_user", + "type": "reverse", + "original parent": "users", + "original property": "transactions_received", + "singular": true, + "always matches": false, + "description": "The user who received the transaction, if it was received by a user (not found if it was received by a merchant)", + "synonyms": ["destination user", "receiving user account"] + }, + { + "name": "balances", + "type": "simple join", + "parent collection": "users", + "child collection": "user_balances", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The historical account balance for the user, which can include multiple updates over time", + "synonyms": ["historical account balance", "user balance history"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "balances", + "singular": true, + "always matches": true, + "description": "The user who the account balance belongs to", + "synonyms": ["customer"] + }, + { + "name": "notifications", + "type": "simple join", + "parent collection": "users", + "child collection": "notifications", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The notifications that have been sent to the user", + "synonyms": ["user notifications", "user alerts"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "notifications", + "singular": true, + "always matches": true, + "description": "The user who received the notification", + "synonyms": ["customer", "client", "user account"] + }, + { + "name": "sessions", + "type": "simple join", + "parent collection": "users", + "child collection": "user_sessions", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The login sessions by the user", + "synonyms": ["user login sessions", "session history"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "sessions", + "singular": true, + "description": "The user who the login session information belongs to", + "synonyms": ["customer", "client", "user account"] + }, + { + "name": "setting_snapshots", + "type": "simple join", + "parent collection": "users", + "child collection": "user_setting_snapshots", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The setting snapshot history for the user, which can include multiple updates over time", + "synonyms": ["setting history", "user setting snapshots"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "setting_snapshots", + "singular": true, + "description": "The user who the setting snapshot belongs to", + "synonyms": ["customer", "client", "user account"] + }, + { + "name": "transactions_sent", + "type": "simple join", + "parent collection": "merchants", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "sender_id" + ] + }, + "description": "The transactions sent by the merchant", + "synonyms": ["merchant transactions sent", "merchant outgoing transactions"] + }, + { + "name": "sending_merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "transactions_sent", + "singular": true, + "always matches": false, + "description": "The merchant who sent the transaction, if it was sent by a merchant (not found if it was sent by a user)", + "synonyms": ["merchant source", "merchant origin"] + }, + { + "name": "transactions_received", + "type": "simple join", + "parent collection": "merchants", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "receiver_id" + ] + }, + "description": "The transactions received by the merchant", + "synonyms": ["merchant transactions received", "merchant incoming transactions"] + }, + { + "name": "receiving_merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "transactions_received", + "singular": true, + "always matches": false, + "description": "The merchant who received the transaction, if it was received by a merchant (not found if it was received by a user)", + "synonyms": ["merchant destination", "merchant recipient"] + }, + { + "name": "balances", + "type": "simple join", + "parent collection": "merchants", + "child collection": "merchant_balances", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "merchant_id" + ] + }, + "description": "The historical account balance for the merchant, which can include multiple updates over time", + "synonyms": ["historical account balance", "merchant balance history"] + }, + { + "name": "merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "balances", + "singular": true, + "always matches": true, + "description": "The merchant who the account balance information belongs to", + "synonyms": ["business", "company", "merchant account"] + }, + { + "name": "coupons", + "type": "simple join", + "parent collection": "merchants", + "child collection": "coupons", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "merchant_id" + ] + }, + "description": "The coupons issued by the merchant", + "synonyms": ["merchant coupons", "merchant discount codes"] + }, + { + "name": "merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "coupons", + "singular": true, + "always matches": true, + "description": "The merchant who issued the coupon", + "synonyms": ["issuing company", "business"] + }, + { + "name": "transaction_used_in", + "type": "simple join", + "parent collection": "coupons", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "cid": [ + "coupon_id" + ] + }, + "description": "The transactions that the coupon was used in", + "synonyms": ["uses", "transactions with coupon"] + }, + { + "name": "coupon", + "type": "reverse", + "original parent": "coupons", + "original property": "transaction_used_in", + "singular": true, + "always matches": false, + "description": "The coupon that was used in the transaction, if one exists", + "synonyms": ["coupon used", "discount used"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "Academic", + "version": "V2", + "collections": [ + { + "name": "authors", + "type": "simple table", + "table path": "author", + "unique properties": [ + "author_id" + ], + "properties": [ + { + "name": "author_id", + "type": "table column", + "column name": "aid", + "data type": "numeric", + "description": "Unique identifier for each author", + "sample values": [1, 3, 5], + "synonyms": ["author id", "author identification"] + }, + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The hostname used for the author's website", + "sample values": ["www.larry.com", "www.noam.com"], + "synonyms": ["author url", "author website"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name and lastname of the author", + "sample values": ["Larry Summers", "Noam Shazeer"], + "synonyms": ["full name"] + }, + { + "name": "organization_id", + "type": "table column", + "column name": "oid", + "data type": "numeric", + "description": "The id of the organization the author is related to", + "sample values": [1, 2, 5], + "synonyms": ["oid", "org_id"] + } + ], + "description": "Contains details about the authors, including their id, name, homepage, and organization id.", + "synonyms": [] + }, + { + "name": "citations", + "type": "simple table", + "table path": "cite", + "unique properties": [ + ["cited", + "citing"] + ], + "properties": [ + { + "name": "cited", + "type": "table column", + "column name": "cited", + "data type": "numeric", + "description": "The id of the publication being referenced or cited.", + "sample values": [1, 2, 4], + "synonyms": [] + }, + { + "name": "citing", + "type": "table column", + "column name": "citing", + "data type": "numeric", + "description": "The id of the publication that is doing the referencing (the source paper that contains the citation).", + "sample values": [1, 2, 3], + "synonyms": [] + } + ], + "description": "Records of citation relationships between publications.", + "synonyms": [] + }, + { + "name": "conferences", + "type": "simple table", + "table path": "conference", + "unique properties": [ + "conference_id" + ], + "properties": [ + { + "name": "conference_id", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "Unique identifier for the conference.", + "sample values": [1, 2, 3], + "synonyms": ["conference id"] + }, + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The URL or homepage of the conference.", + "sample values": ["www.isa.com", "www.icml.com"], + "synonyms": ["conference website"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The full name or abbreviation of the conference.", + "sample values": ["ISA", "ICML"], + "synonyms": [] + } + ], + "description": "Contains details about academic conferences.", + "synonyms": ["meeting", "symposium"] + }, + { + "name": "domains", + "type": "simple table", + "table path": "domain", + "unique properties": [ + "domain_id" + ], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "Unique identifier for the academic domain or field.", + "sample values": [1, 3, 5], + "synonyms": [] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the academic domain", + "sample values": ["Data Science", "Computer Science"], + "synonyms": ["field name", "subject"] + } + ], + "description": "Records of different academic domains or areas of study", + "synonyms": ["field", "subject"] + }, + { + "name": "domains_authors", + "type": "simple table", + "table path": "domain_author", + "unique properties": [ + ["author_id", + "domain_id"] + ], + "properties": [ + { + "name": "author_id", + "type": "table column", + "column name": "aid", + "data type": "numeric", + "description": "The id of the author related to this domain", + "sample values": [1, 3, 5], + "synonyms": [] + }, + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain related to the author", + "sample values": [1, 3, 5], + "synonyms": [] + } + ], + "description": "The records of each author being associated with domains", + "synonyms": [] + }, + { + "name": "domains_conferences", + "type": "simple table", + "table path": "domain_conference", + "unique properties": [ + ["conference_id", + "domain_id"] + ], + "properties": [ + { + "name": "conference_id", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "The id for the conference related to this domain", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id for the domain related to the conference.", + "sample values": [2, 4, 5], + "synonyms": [] + } + ], + "description": "Describes the domains related to the different conferences", + "synonyms": ["conference subject"] + }, + { + "name": "domains_journals", + "type": "simple table", + "table path": "domain_journal", + "unique properties": [ + ["domain_id", + "journal_id"] + ], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain realated to this journal", + "sample values": [1,2,5], + "synonyms": [] + }, + { + "name": "journal_id", + "type": "table column", + "column name": "jid", + "data type": "numeric", + "description": "The id of the jornal that published about this domain", + "sample values": [2, 3, 4], + "synonyms": [] + } + ], + "description": "Records of domains being used by a journal", + "synonyms": ["journal domain", "journal field"] + }, + { + "name": "domains_keywords", + "type": "simple table", + "table path": "domain_keyword", + "unique properties": [ + ["domain_id", + "keyword_id"] + ], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain which is related to this keyword", + "sample values": [1, 2], + "synonyms": [] + }, + { + "name": "keyword_id", + "type": "table column", + "column name": "kid", + "data type": "numeric", + "description": "The id of the keyword used or connected to this domain or field", + "sample values": [2, 3], + "synonyms": [] + } + ], + "description": "Contains records of keywords that is related to a domain", + "synonyms": ["keyword domain"] + }, + { + "name": "domains_publications", + "type": "simple table", + "table path": "domain_publication", + "unique properties": [["domain_id", "publication_id"]], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain related to this publication", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The id of the publication about this domain", + "sample values": [2, 4, 5], + "synonyms": [] + } + ], + "description": "Records of the publication and its related domain or field", + "synonyms": ["publication field"] + }, + { + "name": "journals", + "type": "simple table", + "table path": "journal", + "unique properties": [ + "journal_id" + ], + "properties": [ + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The url of the journal", + "sample values": ["www.aijournal.com", "www.ml.com"], + "synonyms": ["website", "url"] + }, + { + "name": "journal_id", + "type": "table column", + "column name": "jid", + "data type": "numeric", + "description": "The id of the journal", + "sample values": [1, 2, 3], + "synonyms": ["journal id", "identification"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the journal", + "sample values": ["Nature", "Journal of Machine Learning Research"], + "synonyms": [] + } + ], + "description": "Contains details about the journals", + "synonyms": ["magazines", "newspapers"] + }, + { + "name": "keywords", + "type": "simple table", + "table path": "keyword", + "unique properties": [ + "keyword_id" + ], + "properties": [ + { + "name": "keyword", + "type": "table column", + "column name": "keyword", + "data type": "string", + "description": "The keyword itself", + "sample values": ["Neuroscience", "AI"], + "synonyms": [] + }, + { + "name": "keyword_id", + "type": "table column", + "column name": "kid", + "data type": "numeric", + "description": "The identificator of the keyword", + "sample values": [1, 2, 4], + "synonyms": ["keyword id"] + } + ], + "description": "Collection of keywords used in publications and domains", + "synonyms": [] + }, + { + "name": "organizations", + "type": "simple table", + "table path": "organization", + "unique properties": [ + "organization_id" + ], + "properties": [ + { + "name": "continent", + "type": "table column", + "column name": "continent", + "data type": "string", + "description": "The continent where the organization resides", + "sample values": ["North America", "Asia"], + "synonyms": ["location"] + }, + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The url of the organization's website", + "sample values": ["www.organization2.com", "www.epfl.com"], + "synonyms": ["website link"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the organization", + "sample values": ["Γ‰cole Polytechnique FΓ©dΓ©rale de Lausanne 4", "Organization 2"], + "synonyms": ["oranization name"] + }, + { + "name": "organization_id", + "type": "table column", + "column name": "oid", + "data type": "numeric", + "description": "The identifier for the organization", + "sample values": [1, 3, 5], + "synonyms": ["id", "oid"] + } + ], + "description": "Records of the existing organizations, including continent, name, homepage and id", + "synonyms": ["institutions"] + }, + { + "name": "publications", + "type": "simple table", + "table path": "publication", + "unique properties": [ + "publication_id" + ], + "properties": [ + { + "name": "abstract", + "type": "table column", + "column name": "abstract", + "data type": "string", + "description": "Summary of the publication", + "sample values": ["Abstract 1", "Abstract 2"], + "synonyms": ["summary"] + }, + { + "name": "conference_id", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "The id of the conference related to this publication", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "citation_num", + "type": "table column", + "column name": "citation_num", + "data type": "numeric", + "description": "The number of times this publication was cited", + "sample values": [4, 2, 0], + "synonyms": [] + }, + { + "name": "journal_id", + "type": "table column", + "column name": "jid", + "data type": "numeric", + "description": "The id of the journal that publish this publication", + "sample values": [1, 2, 4], + "synonyms": [] + }, + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The unique idetifier for the publication", + "sample values": [1, 2, 5], + "synonyms": [] + }, + { + "name": "reference_num", + "type": "table column", + "column name": "reference_num", + "data type": "numeric", + "description": "The total number of external references made by this publication.", + "sample values": [0, 1, 4], + "synonyms": [] + }, + { + "name": "title", + "type": "table column", + "column name": "title", + "data type": "string", + "description": "The title of the paper or article.", + "sample values": ["Attention is all you need", "Optimizing GPU Throughput"], + "synonyms": [] + }, + { + "name": "year", + "type": "table column", + "column name": "year", + "data type": "numeric", + "description": "The year when the publication was published", + "sample values": [2021, 2020], + "synonyms": [] + } + ], + "description": "Stores core information about academic papers, articles, or other publications.", + "synonyms": [] + }, + { + "name": "publications_keywords", + "type": "simple table", + "table path": "publication_keyword", + "unique properties": [["publication_id", "keyword_id"]], + "properties": [ + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The id of the publication related to the keyword", + "sample values": [1, 2], + "synonyms": [] + }, + { + "name": "keyword_id", + "type": "table column", + "column name": "kid", + "data type": "numeric", + "description": "The id of the keyword used in the publication", + "sample values": [2, 3], + "synonyms": [] + } + ], + "description": "Records of keyword used in publication", + "synonyms": [] + }, + { + "name": "writes", + "type": "simple table", + "table path": "writes", + "unique properties": [["author_id", "publication_id"]], + "properties": [ + { + "name": "author_id", + "type": "table column", + "column name": "aid", + "data type": "numeric", + "description": "The author or co-author of the publication", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The publication related to the author", + "sample values": [1, 2, 3], + "synonyms": [] + } + ], + "description": "Records of authors and its publications", + "synonyms": [] + } + ], + "relationships": [ + { + "type": "simple join", + "name": "authors", + "parent collection": "organizations", + "child collection": "authors", + "singular": false, + "always matches": false, + "keys": { + "organization_id": [ + "organization_id" + ] + }, + "description": "All authors that belongs to this organization", + "synonyms": [] + }, + { + "type": "reverse", + "name": "organization", + "original parent": "organizations", + "original property": "authors", + "singular": true, + "always matches": false, + "description": "The oranization that the author belongs to", + "synonyms": [] + }, + { + "type": "simple join", + "name": "references", + "parent collection": "publications", + "child collection": "citations", + "singular": true, + "always matches": false, + "keys": { + "publication_id": [ + "citing" + ] + }, + "description": "All the citations this publication contains", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication_citing", + "original parent": "publications", + "original property": "references", + "singular": true, + "always matches": true, + "description": "The publication citing", + "synonyms": [] + }, + { + "type": "simple join", + "name": "cited_by", + "parent collection": "publications", + "child collection": "citations", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "cited" + ] + }, + "description": "All citations of the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication_cited", + "original parent": "publications", + "original property": "cited_by", + "singular": true, + "always matches": true, + "description": "The publication cited", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_authors", + "parent collection": "domains", + "child collection": "domains_authors", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The id of the authors related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_authors", + "singular": true, + "always matches": true, + "description": "The domain related to the author id", + "synonyms": [] + }, + { + "type": "simple join", + "name": "author_domains", + "parent collection": "authors", + "child collection": "domains_authors", + "singular": false, + "always matches": false, + "keys": { + "author_id": [ + "author_id" + ] + }, + "description": "The domains id for this author", + "synonyms": [] + }, + { + "type": "reverse", + "name": "author", + "original parent": "authors", + "original property": "author_domains", + "singular": true, + "always matches": true, + "description": "The author related to this domain_author", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_conferences", + "parent collection": "domains", + "child collection": "domains_conferences", + "singular": false, + "always matches": true, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_conferences related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_conferences", + "singular": true, + "always matches": true, + "description": "The domain related to the domain_conference", + "synonyms": [] + }, + { + "type": "simple join", + "name": "conference_domains", + "parent collection": "conferences", + "child collection": "domains_conferences", + "singular": false, + "always matches": false, + "keys": { + "conference_id": [ + "conference_id" + ] + }, + "description": "The domain_conference related to the conference", + "synonyms": [] + }, + { + "type": "reverse", + "name": "conference", + "original parent": "conferences", + "original property": "conference_domains", + "singular": true, + "always matches": true, + "description": "The conference related to the domain_conference", + "synonyms": [] + }, + { + "type": "simple join", + "name": "journal_domains", + "parent collection": "journals", + "child collection": "domains_journals", + "singular": false, + "always matches": false, + "keys": { + "journal_id": [ + "journal_id" + ] + }, + "description": "The domains_journal related to the journal", + "synonyms": [] + }, + { + "type": "reverse", + "name": "journal", + "original parent": "journals", + "original property": "journal_domains", + "singular": true, + "always matches": true, + "description": "The journal related to the domain_journal", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_journals", + "parent collection": "domains", + "child collection": "domains_journals", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_journal related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_journals", + "singular": true, + "always matches": true, + "description": "The domain linked with the domain_journal", + "synonyms": [] + }, + { + "type": "simple join", + "name": "keyword_domains", + "parent collection": "keywords", + "child collection": "domains_keywords", + "singular": false, + "always matches": false, + "keys": { + "keyword_id": [ + "keyword_id" + ] + }, + "description": "The domain_keywords related to the keyword", + "synonyms": [] + }, + { + "type": "reverse", + "name": "keyword", + "original parent": "keywords", + "original property": "keyword_domains", + "singular": true, + "always matches": true, + "description": "The keyword related to the domain_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_keywords", + "parent collection": "domains", + "child collection": "domains_keywords", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_keywords related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_keywords", + "singular": true, + "always matches": true, + "description": "The keyword linked to the domain_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "publication_domains", + "parent collection": "publications", + "child collection": "domains_publications", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "publication_id" + ] + }, + "description": "The domain_publications related to the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication", + "original parent": "publications", + "original property": "publication_domains", + "singular": true, + "always matches": true, + "description": "The publication related to the domain_publication", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_publications", + "parent collection": "domains", + "child collection": "domains_publications", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_publications related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_publications", + "singular": true, + "always matches": true, + "description": "The domain related to the domain_publication", + "synonyms": [] + }, + { + "type": "simple join", + "name": "archives", + "parent collection": "journals", + "child collection": "publications", + "singular": false, + "always matches": false, + "keys": { + "journal_id": [ + "journal_id" + ] + }, + "description": "The publications related to the journal", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publisher", + "original parent": "journals", + "original property": "archives", + "singular": true, + "always matches": true, + "description": "The journal the published the publication", + "synonyms": [] + }, + { + "type": "simple join", + "name": "proceedings", + "parent collection": "conferences", + "child collection": "publications", + "singular": false, + "always matches": false, + "keys": { + "conference_id": [ + "conference_id" + ] + }, + "description": "The publications presented in the conference", + "synonyms": [] + }, + { + "type": "reverse", + "name": "conference", + "original parent": "conferences", + "original property": "proceedings", + "singular": true, + "always matches": false, + "description": "The conference where the publication was presented", + "synonyms": [] + }, + { + "type": "simple join", + "name": "keyword_publications", + "parent collection": "keywords", + "child collection": "publications_keywords", + "singular": false, + "always matches": false, + "keys": { + "keyword_id": [ + "keyword_id" + ] + }, + "description": "All publication_keywords related to the keyword", + "synonyms": [] + }, + { + "type": "reverse", + "name": "keyword", + "original parent": "keywords", + "original property": "keyword_publications", + "singular": true, + "always matches": true, + "description": "The keyword linked to the publication_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "publication_keywords", + "parent collection": "publications", + "child collection": "publications_keywords", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "publication_id" + ] + }, + "description": "All publication_keywords related to the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication", + "original parent": "publications", + "original property": "publication_keywords", + "singular": true, + "always matches": true, + "description": "The publication linked to the publication_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "publication_authors", + "parent collection": "publications", + "child collection": "writes", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "publication_id" + ] + }, + "description": "All authors id related to the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication", + "original parent": "publications", + "original property": "publication_authors", + "singular": true, + "always matches": true, + "description": "The publication linked to the writes", + "synonyms": [] + }, + { + "type": "simple join", + "name": "author_publications", + "parent collection": "authors", + "child collection": "writes", + "singular": false, + "always matches": false, + "keys": { + "author_id": [ + "author_id" + ] + }, + "description": "The publications' id of the write related to the author", + "synonyms": [] + }, + { + "type": "reverse", + "name": "author", + "original parent": "authors", + "original property": "author_publications", + "singular": true, + "always matches": true, + "description": "The author related to the written", + "synonyms": [] + } + ] + }, + { + "name": "Restaurants", + "version": "V2", + "collections": [ + { + "name": "cities", + "type": "simple table", + "table path": "geographic", + "unique properties": [ + "city_name" + ], + "properties": [ + { + "name": "city_name", + "type": "table column", + "column name": "city_name", + "data type": "string", + "description": "The name of the city", + "sample values": ["Los Angeles", "Miami"], + "synonyms": ["city"] + }, + { + "name": "county", + "type": "table column", + "column name": "county", + "data type": "string", + "description": "The name of the county", + "sample values": ["Miami-Dade", "Cook", "New York"], + "synonyms": ["division"] + }, + { + "name": "region", + "type": "table column", + "column name": "region", + "data type": "string", + "description": "The name of the region", + "sample values": ["California", "New York"], + "synonyms": ["territory"] + } + ], + "description": "Contains records of cities locations including its name, county and region", + "synonyms": ["locations", "places"] + }, + { + "name": "locations", + "type": "simple table", + "table path": "location", + "unique properties": [ + ["restaurant_id", "house_number", "street_name","city_name"] + ], + "properties": [ + { + "name": "restaurant_id", + "type": "table column", + "column name": "restaurant_id", + "data type": "numeric", + "description": "Unique identifier for each restaurant", + "sample values": [1, 2, 3], + "synonyms": ["restaurant_id", "diner_id"] + }, + { + "name": "house_number", + "type": "table column", + "column name": "house_number", + "data type": "numeric", + "description": "The number assigned to the building where the restaurant is located", + "sample values": [123, 789, 12], + "synonyms": ["street_number"] + }, + { + "name": "street_name", + "type": "table column", + "column name": "street_name", + "data type": "string", + "description": "The name of the street where the restaurant is located", + "sample values": ["Main St", "Oak St", "Pine Ave"], + "synonyms": ["avenue"] + }, + { + "name": "city_name", + "type": "table column", + "column name": "city_name", + "data type": "string", + "description": "The name of the city where the restaurant is located", + "sample values": ["New York", "Los Angeles", "Miami"], + "synonyms": [] + } + ], + "description": "Contains the location of each restaurant", + "synonyms": ["address"] + }, + { + "name": "restaurants", + "type": "simple table", + "table path": "restaurant", + "unique properties": [ + "id_" + ], + "properties": [ + { + "name": "id_", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each restaurant", + "sample values": [1, 2, 3], + "synonyms": ["identifier"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the restaurant", + "sample values": ["The Pasta House", "The Burger Joint", "The Seafood Shack"], + "synonyms": ["restaurant"] + }, + { + "name": "food_type", + "type": "table column", + "column name": "food_type", + "data type": "string", + "description": "The type of food served at the restaurant", + "sample values": ["Seafood", "American", "Japanese"], + "synonyms": ["specialty", "menu type"] + }, + { + "name": "city_name", + "type": "table column", + "column name": "city_name", + "data type": "string", + "description": "The city where the restaurant is located", + "sample values": ["San Francisco", "New York", "Miami"], + "synonyms": ["locality", "town"] + }, + { + "name": "rating", + "type": "table column", + "column name": "rating", + "data type": "numeric", + "description": "The rating of the restaurant on a scale of 0 to 5", + "sample values": [4.2, 3.9, 4.5], + "synonyms": ["score", "review"] + } + ], + "description": "Contains the information of the restaurants", + "synonyms": ["diner"] + } + ], + "relationships": [ + { + "type": "simple join", + "name": "restaurant_locations", + "parent collection": "cities", + "child collection": "locations", + "singular": false, + "always matches": false, + "keys": { + "city_name": [ + "city_name" + ] + }, + "description": "All restaurant locations within the city", + "synonyms": ["restaurant locations"] + }, + { + "type": "reverse", + "name": "city", + "original parent": "cities", + "original property": "restaurant_locations", + "singular": true, + "always matches": false, + "description": "The geographic information for the city that the location belongs to", + "synonyms": ["geography", "town"] + }, + { + "type": "simple join", + "name": "location", + "parent collection": "restaurants", + "child collection": "locations", + "singular": true, + "always matches": true, + "keys": { + "id_": [ + "restaurant_id" + ] + }, + "description": "The location of this restaurant", + "synonyms": ["place", "diner"] + }, + { + "type": "reverse", + "name": "restaurant", + "original parent": "restaurants", + "original property": "location", + "singular": true, + "always matches": true, + "description": "The restaurant related to this location", + "synonyms": ["franchise", "chain"] + }, + { + "type": "simple join", + "name": "restaurants", + "parent collection": "cities", + "child collection": "restaurants", + "singular": false, + "always matches": false, + "keys": { + "city_name": [ + "city_name" + ] + }, + "description": "The restaurants located in this geographic territory", + "synonyms": ["diners"] + }, + { + "type": "reverse", + "name": "city", + "original parent": "cities", + "original property": "restaurants", + "singular": true, + "always matches": true, + "description": "The geographic territory related to this restaurant", + "synonyms": ["location", "territory"] + } + ] + } +] diff --git a/tests/test_pipeline_oracle.py b/tests/test_pipeline_oracle.py new file mode 100644 index 000000000..abc910c20 --- /dev/null +++ b/tests/test_pipeline_oracle.py @@ -0,0 +1,282 @@ +""" +Integration tests for the PyDough workflow on the TPC-H queries using Oracle. +""" + +from collections.abc import Callable + +import pandas as pd +import pytest + +from pydough import init_pydough_context, to_df +from pydough.configs import PyDoughConfigs +from pydough.database_connectors import DatabaseContext +from pydough.metadata import GraphMetadata +from pydough.unqualified import ( + UnqualifiedNode, +) +from tests.test_pipeline_defog_custom import get_day_of_week, get_start_of_week +from tests.test_pydough_functions.simple_pydough_functions import ( + simple_week_sampler_tpch, +) +from tests.test_pydough_functions.tpch_outputs import ( + tpch_q16_output, +) +from tests.test_pydough_functions.tpch_test_functions import ( + impl_tpch_q16, +) +from tests.testing_utilities import ( + PyDoughPandasTest, + PyDoughSQLComparisonTest, + graph_fetcher, + harmonize_types, +) + +from .conftest import tpch_custom_test_data_dialect_replacements +from .test_pipeline_custom_datasets import custom_datasets_test_data # noqa +from .test_pipeline_defog import defog_pipeline_test_data # noqa +from .test_pipeline_defog_custom import defog_custom_pipeline_test_data # noqa +from .test_pipeline_tpch_custom import tpch_custom_pipeline_test_data # noqa + + +@pytest.fixture( + params=[ + pytest.param( + PyDoughPandasTest( + impl_tpch_q16, + "TPCH", + tpch_q16_output, + "tpch_q16_params", + ), + id="tpch_q16_params", + ), + ], +) +def tpch_oracle_params_test_data(request) -> PyDoughPandasTest: + """ + Test data for e2e tests for the TPC-H query 16. Returns an instance of + PyDoughPandasTest containing information about the test. + """ + return request.param + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch( + tpch_pipeline_test_data: PyDoughPandasTest, + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], # Fix this +): + """ + Test executing the TPC-H queries from the original code generation on Oracle. + """ + tpch_pipeline_test_data.run_e2e_test( + get_sample_graph, + oracle_conn_db_context("tpch"), + coerce_types=True, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch_16_params( + tpch_oracle_params_test_data: PyDoughPandasTest, + get_sample_graph: graph_fetcher, + oracle_params_tpch_db_context: DatabaseContext, +): + """ + Test executing the TPC-H 16 from the original code generation, + with oracle as the executing database. + Using the `user`, `password`, `database`, and `host` + as keyword arguments to the DatabaseContext. + """ + tpch_oracle_params_test_data.run_e2e_test( + get_sample_graph, oracle_params_tpch_db_context, coerce_types=True + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_custom_functions( + custom_functions_test_data: PyDoughPandasTest, + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the custom functions test data using TPCH with Oracle + """ + custom_functions_test_data.run_e2e_test( + get_sample_graph, oracle_conn_db_context("tpch"), coerce_types=True + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch_simple_week( + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], + week_handling_config: PyDoughConfigs, +): + """ + Test executing simple_week_sampler using the TPCH schemas with different + week configurations, comparing against expected results. + """ + graph: GraphMetadata = get_sample_graph("TPCH") + root: UnqualifiedNode = init_pydough_context(graph)(simple_week_sampler_tpch)() + result: pd.DataFrame = to_df( + root, + metadata=graph, + database=oracle_conn_db_context("tpch"), + config=week_handling_config, + ) + + # Generate expected DataFrame based on week_handling_config + start_of_week = week_handling_config.start_of_week + start_week_as_zero = week_handling_config.start_week_as_zero + + x_dt = pd.Timestamp(2025, 3, 10, 11, 0, 0) + y_dt = pd.Timestamp(2025, 3, 14, 11, 0, 0) + y_dt2 = pd.Timestamp(2025, 3, 15, 11, 0, 0) + y_dt3 = pd.Timestamp(2025, 3, 16, 11, 0, 0) + y_dt4 = pd.Timestamp(2025, 3, 17, 11, 0, 0) + y_dt5 = pd.Timestamp(2025, 3, 18, 11, 0, 0) + y_dt6 = pd.Timestamp(2025, 3, 19, 11, 0, 0) + y_dt7 = pd.Timestamp(2025, 3, 20, 11, 0, 0) + y_dt8 = pd.Timestamp(2025, 3, 21, 11, 0, 0) + + # Calculate weeks difference + x_sow = get_start_of_week(x_dt, start_of_week) + y_sow = get_start_of_week(y_dt, start_of_week) + weeks_diff = (y_sow - x_sow).days // 7 + + # Create lists to store calculated values + dates = [y_dt, y_dt2, y_dt3, y_dt4, y_dt5, y_dt6, y_dt7, y_dt8] + sows = [] + daynames = [] + dayofweeks = [] + + # Calculate values for each date in a loop + for dt in dates: + # Calculate start of week + sow = get_start_of_week(dt, start_of_week).strftime("%Y-%m-%d") + sows.append(sow) + + # Get day name + dayname = dt.day_name() + daynames.append(dayname) + + # Calculate day of week + dayofweek = get_day_of_week(dt, start_of_week, start_week_as_zero) + dayofweeks.append(dayofweek) + + # Create dictionary for DataFrame + data_dict = {"weeks_diff": [weeks_diff]} + + # Add start of week columns + for i in range(len(dates)): + data_dict[f"sow{i + 1}"] = [sows[i]] + + # Add day name columns + for i in range(len(dates)): + data_dict[f"dayname{i + 1}"] = [daynames[i]] + + # Add day of week columns + for i in range(len(dates)): + data_dict[f"dayofweek{i + 1}"] = [dayofweeks[i]] + + # Create DataFrame with expected results + expected_df = pd.DataFrame(data_dict) + + for col_name in result.columns: + result[col_name], expected_df[col_name] = harmonize_types( + result[col_name], expected_df[col_name] + ) + pd.testing.assert_frame_equal( + result, expected_df, check_dtype=False, check_exact=False, atol=1e-8 + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch_custom( + tpch_custom_pipeline_test_data: PyDoughPandasTest, # noqa: F811 + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the TPC-H custom queries from the original code generation on + Oracle. + """ + tpch_custom_pipeline_test_data = tpch_custom_test_data_dialect_replacements( + oracle_conn_db_context("tpch").dialect, tpch_custom_pipeline_test_data + ) + + tpch_custom_pipeline_test_data.run_e2e_test( + get_sample_graph, + oracle_conn_db_context("tpch"), + coerce_types=True, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_defog_custom( + defog_custom_pipeline_test_data: PyDoughPandasTest, # noqa: F811 + get_oracle_defog_graphs: graph_fetcher, + defog_config: PyDoughConfigs, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the defog analytical queries with Oracle database. + """ + defog_custom_pipeline_test_data.run_e2e_test( + get_oracle_defog_graphs, + oracle_conn_db_context(defog_custom_pipeline_test_data.graph_name.lower()), + config=defog_config, + coerce_types=True, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_defog( + defog_pipeline_test_data: PyDoughSQLComparisonTest, # noqa: F811 + get_oracle_defog_graphs: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], + defog_config: PyDoughConfigs, + sqlite_defog_connection: DatabaseContext, +) -> None: + """ + Test executing the defog analytical questions on the sqlite database, + comparing against the result of running the reference SQL query text on the + same database connector. Run on the defog.ai queries. + NOTE: passing SQLite connection as reference database so that refsol + is executed using SQLite. + This is needed because refsol uses SQLite SQL syntax to obtain + the correct results. + """ + defog_pipeline_test_data.run_e2e_test( + get_oracle_defog_graphs, + oracle_conn_db_context(defog_pipeline_test_data.graph_name.lower()), + defog_config, + reference_database=sqlite_defog_connection, + coerce_types=True, + rtol=1e4, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_custom_datasets( + custom_datasets_test_data: PyDoughPandasTest, # noqa: F811 + get_custom_datasets_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the the custom queries with the custom datasets against the + refsol DataFrame. + """ + custom_datasets_test_data.run_e2e_test( + get_custom_datasets_graph, + oracle_conn_db_context(custom_datasets_test_data.graph_name.lower()), + coerce_types=True, + ) From af42e170ed5ee088ff44990b730a64f244df8e6a Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Thu, 5 Feb 2026 12:30:32 -0600 Subject: [PATCH 07/48] refsol oracle files added --- tests/conftest.py | 27 + .../simple_pydough_functions.py | 39 ++ .../test_sql_refsols/agg_partition_oracle.sql | 10 + .../agg_simplification_1_oracle.sql | 237 ++++++++ .../agg_simplification_2_oracle.sql | 16 + .../aggregation_analytics_1_oracle.sql | 45 ++ .../aggregation_analytics_2_oracle.sql | 34 ++ .../aggregation_analytics_3_oracle.sql | 35 ++ .../aggregation_functions_oracle.sql | 70 +++ ...rnative_quarter_cum_ir_analysis_oracle.sql | 78 +++ ...arithmetic_and_binary_operators_oracle.sql | 16 + .../avg_acctbal_wo_debt_oracle.sql | 25 + .../avg_gap_prev_urgent_same_clerk_oracle.sql | 14 + .../avg_order_diff_per_customer_oracle.sql | 24 + .../bad_child_reuse_1_oracle.sql | 27 + .../bad_child_reuse_2_oracle.sql | 27 + .../bad_child_reuse_3_oracle.sql | 27 + .../bad_child_reuse_4_oracle.sql | 26 + .../bad_child_reuse_5_oracle.sql | 33 ++ .../casting_functions_oracle.sql | 6 + ...mparisons_and_logical_operators_oracle.sql | 24 + .../conditional_functions_oracle.sql | 18 + .../country_x_year_analysis_oracle.sql | 63 ++ .../country_x_year_combos_oracle.sql | 26 + .../cumulative_stock_analysis_oracle.sql | 32 + .../customer_largest_order_deltas_oracle.sql | 53 ++ .../customer_most_recent_orders_oracle.sql | 25 + tests/test_sql_refsols/datediff_oracle.sql | 16 + .../datetime_current_oracle.sql | 10 + .../datetime_functions_oracle.sql | 57 ++ .../datetime_relative_oracle.sql | 31 + .../datetime_sampler_oracle.sql | 164 ++++++ .../deep_best_analysis_oracle.sql | 109 ++++ .../defog_academic_gen10_oracle.sql | 5 + .../defog_academic_gen11_oracle.sql | 13 + .../defog_academic_gen12_oracle.sql | 3 + .../defog_academic_gen13_oracle.sql | 23 + .../defog_academic_gen14_oracle.sql | 8 + .../defog_academic_gen15_oracle.sql | 18 + .../defog_academic_gen16_oracle.sql | 19 + .../defog_academic_gen17_oracle.sql | 11 + .../defog_academic_gen18_oracle.sql | 17 + .../defog_academic_gen19_oracle.sql | 11 + .../defog_academic_gen1_oracle.sql | 18 + .../defog_academic_gen20_oracle.sql | 5 + .../defog_academic_gen21_oracle.sql | 12 + .../defog_academic_gen22_oracle.sql | 16 + .../defog_academic_gen23_oracle.sql | 6 + .../defog_academic_gen24_oracle.sql | 19 + .../defog_academic_gen25_oracle.sql | 9 + .../defog_academic_gen2_oracle.sql | 16 + .../defog_academic_gen3_oracle.sql | 6 + .../defog_academic_gen4_oracle.sql | 16 + .../defog_academic_gen5_oracle.sql | 6 + .../defog_academic_gen6_oracle.sql | 6 + .../defog_academic_gen7_oracle.sql | 18 + .../defog_academic_gen8_oracle.sql | 6 + .../defog_academic_gen9_oracle.sql | 7 + .../defog_broker_adv10_oracle.sql | 24 + .../defog_broker_adv11_oracle.sql | 10 + .../defog_broker_adv12_oracle.sql | 8 + .../defog_broker_adv13_oracle.sql | 8 + .../defog_broker_adv14_oracle.sql | 19 + .../defog_broker_adv15_oracle.sql | 10 + .../defog_broker_adv16_oracle.sql | 23 + .../defog_broker_adv1_oracle.sql | 17 + .../defog_broker_adv2_oracle.sql | 20 + .../defog_broker_adv3_oracle.sql | 19 + .../defog_broker_adv4_oracle.sql | 21 + .../defog_broker_adv5_oracle.sql | 59 ++ .../defog_broker_adv6_oracle.sql | 17 + .../defog_broker_adv7_oracle.sql | 78 +++ .../defog_broker_adv8_oracle.sql | 10 + .../defog_broker_adv9_oracle.sql | 20 + .../defog_broker_basic10_oracle.sql | 6 + .../defog_broker_basic1_oracle.sql | 20 + .../defog_broker_basic2_oracle.sql | 14 + .../defog_broker_basic3_oracle.sql | 19 + .../defog_broker_basic4_oracle.sql | 34 ++ .../defog_broker_basic5_oracle.sql | 5 + .../defog_broker_basic6_oracle.sql | 6 + .../defog_broker_basic7_oracle.sql | 9 + .../defog_broker_basic8_oracle.sql | 9 + .../defog_broker_basic9_oracle.sql | 6 + .../defog_broker_gen1_oracle.sql | 8 + .../defog_broker_gen2_oracle.sql | 6 + .../defog_broker_gen3_oracle.sql | 18 + .../defog_broker_gen4_oracle.sql | 21 + .../defog_broker_gen5_oracle.sql | 12 + .../defog_dealership_adv10_oracle.sql | 18 + .../defog_dealership_adv11_oracle.sql | 19 + .../defog_dealership_adv12_oracle.sql | 14 + .../defog_dealership_adv14_oracle.sql | 5 + .../defog_dealership_adv15_oracle.sql | 18 + .../defog_dealership_adv16_oracle.sql | 19 + .../defog_dealership_adv1_oracle.sql | 21 + .../defog_dealership_adv2_oracle.sql | 21 + .../defog_dealership_adv3_oracle.sql | 21 + .../defog_dealership_adv4_oracle.sql | 9 + .../defog_dealership_adv5_oracle.sql | 20 + .../defog_dealership_adv6_oracle.sql | 20 + .../defog_dealership_adv7_oracle.sql | 20 + .../defog_dealership_adv9_oracle.sql | 5 + .../defog_dealership_basic10_oracle.sql | 22 + .../defog_dealership_basic1_oracle.sql | 8 + .../defog_dealership_basic2_oracle.sql | 5 + .../defog_dealership_basic3_oracle.sql | 8 + .../defog_dealership_basic4_oracle.sql | 7 + .../defog_dealership_basic5_oracle.sql | 22 + .../defog_dealership_basic6_oracle.sql | 12 + .../defog_dealership_basic7_oracle.sql | 10 + .../defog_dealership_basic8_oracle.sql | 20 + .../defog_dealership_basic9_oracle.sql | 9 + .../defog_dealership_gen1_oracle.sql | 11 + .../defog_dealership_gen2_oracle.sql | 10 + .../defog_dealership_gen3_oracle.sql | 13 + .../defog_dealership_gen4_oracle.sql | 33 ++ .../defog_dealership_gen5_oracle.sql | 20 + .../defog_dermtreatment_adv10_oracle.sql | 21 + .../defog_dermtreatment_adv11_oracle.sql | 5 + .../defog_dermtreatment_adv12_oracle.sql | 7 + .../defog_dermtreatment_adv13_oracle.sql | 5 + .../defog_dermtreatment_adv14_oracle.sql | 5 + .../defog_dermtreatment_adv15_oracle.sql | 20 + .../defog_dermtreatment_adv16_oracle.sql | 9 + .../defog_dermtreatment_adv1_oracle.sql | 7 + .../defog_dermtreatment_adv2_oracle.sql | 7 + .../defog_dermtreatment_adv3_oracle.sql | 10 + .../defog_dermtreatment_adv4_oracle.sql | 10 + .../defog_dermtreatment_adv5_oracle.sql | 31 + .../defog_dermtreatment_adv6_oracle.sql | 16 + .../defog_dermtreatment_adv7_oracle.sql | 9 + .../defog_dermtreatment_adv8_oracle.sql | 27 + .../defog_dermtreatment_adv9_oracle.sql | 78 +++ .../defog_dermtreatment_basic10_oracle.sql | 6 + .../defog_dermtreatment_basic1_oracle.sql | 31 + .../defog_dermtreatment_basic2_oracle.sql | 63 ++ .../defog_dermtreatment_basic3_oracle.sql | 21 + .../defog_dermtreatment_basic4_oracle.sql | 30 + .../defog_dermtreatment_basic5_oracle.sql | 7 + .../defog_dermtreatment_basic6_oracle.sql | 9 + .../defog_dermtreatment_basic7_oracle.sql | 10 + .../defog_dermtreatment_basic8_oracle.sql | 9 + .../defog_dermtreatment_basic9_oracle.sql | 7 + .../defog_dermtreatment_gen1_oracle.sql | 13 + .../defog_dermtreatment_gen2_oracle.sql | 26 + .../defog_dermtreatment_gen3_oracle.sql | 5 + .../defog_dermtreatment_gen4_oracle.sql | 19 + .../defog_dermtreatment_gen5_oracle.sql | 11 + .../defog_ewallet_adv10_oracle.sql | 9 + .../defog_ewallet_adv11_oracle.sql | 18 + .../defog_ewallet_adv12_oracle.sql | 10 + .../defog_ewallet_adv13_oracle.sql | 6 + .../defog_ewallet_adv14_oracle.sql | 5 + .../defog_ewallet_adv15_oracle.sql | 21 + .../defog_ewallet_adv16_oracle.sql | 12 + .../defog_ewallet_adv1_oracle.sql | 9 + .../defog_ewallet_adv2_oracle.sql | 19 + .../defog_ewallet_adv3_oracle.sql | 10 + .../defog_ewallet_adv4_oracle.sql | 12 + .../defog_ewallet_adv5_oracle.sql | 5 + .../defog_ewallet_adv6_oracle.sql | 13 + .../defog_ewallet_adv7_oracle.sql | 13 + .../defog_ewallet_adv8_oracle.sql | 13 + .../defog_ewallet_adv9_oracle.sql | 10 + .../defog_ewallet_basic10_oracle.sql | 21 + .../defog_ewallet_basic1_oracle.sql | 12 + .../defog_ewallet_basic2_oracle.sql | 6 + .../defog_ewallet_basic3_oracle.sql | 6 + .../defog_ewallet_basic4_oracle.sql | 5 + .../defog_ewallet_basic5_oracle.sql | 6 + .../defog_ewallet_basic6_oracle.sql | 9 + .../defog_ewallet_basic7_oracle.sql | 9 + .../defog_ewallet_basic8_oracle.sql | 12 + .../defog_ewallet_basic9_oracle.sql | 14 + .../defog_ewallet_gen1_oracle.sql | 26 + .../defog_ewallet_gen2_oracle.sql | 23 + .../defog_ewallet_gen3_oracle.sql | 8 + .../defog_ewallet_gen4_oracle.sql | 36 ++ .../defog_ewallet_gen5_oracle.sql | 11 + .../defog_restaurants_gen10_oracle.sql | 7 + .../defog_restaurants_gen11_oracle.sql | 15 + .../defog_restaurants_gen12_oracle.sql | 3 + .../defog_restaurants_gen13_oracle.sql | 5 + .../defog_restaurants_gen14_oracle.sql | 5 + .../defog_restaurants_gen15_oracle.sql | 5 + .../defog_restaurants_gen16_oracle.sql | 17 + .../defog_restaurants_gen17_oracle.sql | 8 + .../defog_restaurants_gen18_oracle.sql | 43 ++ .../defog_restaurants_gen19_oracle.sql | 21 + .../defog_restaurants_gen1_oracle.sql | 6 + .../defog_restaurants_gen20_oracle.sql | 19 + .../defog_restaurants_gen21_oracle.sql | 6 + .../defog_restaurants_gen22_oracle.sql | 6 + .../defog_restaurants_gen23_oracle.sql | 9 + .../defog_restaurants_gen24_oracle.sql | 5 + .../defog_restaurants_gen25_oracle.sql | 5 + .../defog_restaurants_gen2_oracle.sql | 6 + .../defog_restaurants_gen3_oracle.sql | 9 + .../defog_restaurants_gen4_oracle.sql | 11 + .../defog_restaurants_gen5_oracle.sql | 9 + .../defog_restaurants_gen6_oracle.sql | 8 + .../defog_restaurants_gen7_oracle.sql | 5 + .../defog_restaurants_gen8_oracle.sql | 33 ++ .../defog_restaurants_gen9_oracle.sql | 7 + .../test_sql_refsols/double_cross_oracle.sql | 68 +++ .../double_partition_oracle.sql | 15 + .../dumb_aggregation_oracle.sql | 46 ++ .../epoch_culture_events_info_oracle.sql | 32 + .../epoch_event_gap_per_era_oracle.sql | 27 + .../epoch_events_per_season_oracle.sql | 13 + .../epoch_first_event_per_era_oracle.sql | 19 + .../epoch_intra_season_searches_oracle.sql | 86 +++ ...t_popular_search_engine_per_tod_oracle.sql | 29 + ...h_most_popular_topic_per_region_oracle.sql | 28 + .../epoch_num_predawn_cold_war_oracle.sql | 19 + ...ent_search_other_users_per_user_oracle.sql | 29 + ...lapping_event_searches_per_user_oracle.sql | 35 ++ .../epoch_pct_searches_per_tod_oracle.sql | 20 + .../epoch_search_results_by_tod_oracle.sql | 22 + .../epoch_summer_events_per_type_oracle.sql | 15 + .../epoch_unique_users_per_engine_oracle.sql | 23 + ...ch_users_most_cold_war_searches_oracle.sql | 30 + .../extract_colors_oracle.sql | 283 +++++++++ .../first_order_in_year_oracle.sql | 19 + .../first_order_per_customer_oracle.sql | 20 + .../floor_and_ceil_2_oracle.sql | 9 + .../floor_and_ceil_oracle.sql | 11 + .../get_part_single_oracle.sql | 49 ++ .../global_acctbal_breakdown_oracle.sql | 51 ++ .../highest_priority_per_year_oracle.sql | 34 ++ .../hour_minute_day_oracle.sql | 13 + .../keywords_alias_reserved_word_oracle.sql | 12 + ...ds_cast_alias_and_missing_alias_oracle.sql | 12 + .../keywords_column_alias_reserved_oracle.sql | 14 + ...keywords_expr_call_quoted_names_oracle.sql | 22 + .../keywords_locals_globals_eval_oracle.sql | 9 + .../keywords_python_sql_reserved_oracle.sql | 12 + .../keywords_quoted_table_name_oracle.sql | 12 + .../keywords_single_quote_use_oracle.sql | 5 + .../many_net_filter_10_oracle.sql | 10 + .../many_net_filter_11_oracle.sql | 13 + .../many_net_filter_1_oracle.sql | 8 + .../many_net_filter_2_oracle.sql | 8 + .../many_net_filter_3_oracle.sql | 7 + .../many_net_filter_4_oracle.sql | 18 + .../many_net_filter_5_oracle.sql | 10 + .../many_net_filter_6_oracle.sql | 10 + .../many_net_filter_7_oracle.sql | 17 + .../many_net_filter_8_oracle.sql | 10 + .../many_net_filter_9_oracle.sql | 10 + .../month_year_sliding_windows_oracle.sql | 52 ++ .../n_orders_first_day_oracle.sql | 10 + .../nation_acctbal_breakdown_oracle.sql | 62 ++ .../nation_best_order_oracle.sql | 36 ++ .../numerical_functions_oracle.sql | 11 + .../odate_and_rdate_avggap_oracle.sql | 13 + .../order_info_per_priority_oracle.sql | 19 + .../order_quarter_test_oracle.sql | 18 + .../orders_versus_first_orders_oracle.sql | 37 ++ .../part_cross_part_a_oracle.sql | 35 ++ .../part_cross_part_b_oracle.sql | 46 ++ .../part_cross_part_c_oracle.sql | 44 ++ .../part_reduced_size_oracle.sql | 25 + .../parts_quantity_increase_95_96_oracle.sql | 41 ++ ...percentile_customers_per_region_oracle.sql | 16 + .../percentile_nations_oracle.sql | 5 + .../prev_next_regions_oracle.sql | 9 + .../quantile_function_test_1_oracle.sql | 14 + .../quantile_function_test_2_oracle.sql | 81 +++ .../quantile_function_test_3_oracle.sql | 81 +++ .../quantile_function_test_4_oracle.sql | 80 +++ .../quantile_test_1_oracle.sql | 14 + .../quantile_test_2_oracle.sql | 81 +++ .../quarter_cum_ir_analysis_oracle.sql | 83 +++ .../quarter_function_test_oracle.sql | 58 ++ tests/test_sql_refsols/rank_a_oracle.sql | 4 + tests/test_sql_refsols/rank_b_oracle.sql | 4 + tests/test_sql_refsols/rank_c_oracle.sql | 4 + .../rank_nations_by_region_oracle.sql | 6 + ...nations_per_region_by_customers_oracle.sql | 19 + ...rts_per_supplier_region_by_size_oracle.sql | 17 + .../rank_with_filters_a_oracle.sql | 12 + .../rank_with_filters_b_oracle.sql | 12 + .../rank_with_filters_c_oracle.sql | 22 + .../region_acctbal_breakdown_oracle.sql | 70 +++ ...ion_orders_from_nations_richest_oracle.sql | 35 ++ ...onal_first_order_best_line_part_oracle.sql | 40 ++ .../regional_suppliers_percentile_oracle.sql | 22 + ...richest_customer_key_per_region_oracle.sql | 13 + .../richest_customer_per_region_oracle.sql | 21 + .../simple_cross_11_oracle.sql | 14 + .../simple_cross_12_oracle.sql | 17 + .../simple_cross_13_oracle.sql | 10 + .../simple_cross_15_oracle.sql | 35 ++ .../simple_cross_16_oracle.sql | 38 ++ .../simple_cross_1_oracle.sql | 13 + .../simple_cross_2_oracle.sql | 14 + .../simple_cross_3_oracle.sql | 36 ++ .../simple_cross_5_oracle.sql | 79 +++ .../simple_cross_6_oracle.sql | 17 + .../simple_cross_7_oracle.sql | 32 + .../simple_cross_8_oracle.sql | 43 ++ .../simple_cross_9_oracle.sql | 25 + .../test_sql_refsols/simple_filter_oracle.sql | 7 + .../simple_filter_top_five_oracle.sql | 8 + .../simple_int_float_string_cast_oracle.sql | 25 + .../simple_range_1_oracle.sql | 13 + .../simple_range_2_oracle.sql | 15 + .../simple_range_3_oracle.sql | 10 + .../simple_range_4_oracle.sql | 15 + .../simple_range_5_oracle.sql | 4 + tests/test_sql_refsols/simple_scan_oracle.sql | 3 + .../simple_scan_top_five_oracle.sql | 6 + .../simple_smallest_or_largest_oracle.sql | 29 + .../simple_var_std_oracle.sql | 15 + .../simple_var_std_with_nulls_oracle.sql | 16 + .../simplification_1_oracle.sql | 26 + .../simplification_2_oracle.sql | 50 ++ .../simplification_3_oracle.sql | 95 +++ .../simplification_4_oracle.sql | 119 ++++ tests/test_sql_refsols/singular1_oracle.sql | 14 + tests/test_sql_refsols/singular2_oracle.sql | 16 + tests/test_sql_refsols/singular3_oracle.sql | 29 + tests/test_sql_refsols/singular4_oracle.sql | 26 + tests/test_sql_refsols/singular5_oracle.sql | 49 ++ tests/test_sql_refsols/singular6_oracle.sql | 31 + tests/test_sql_refsols/singular7_oracle.sql | 49 ++ tests/test_sql_refsols/smoke_b_oracle.sql | 50 ++ tests/test_sql_refsols/smoke_d_oracle.sql | 29 + ...saction_week_sampler_friday_one_oracle.sql | 28 + ...action_week_sampler_friday_zero_oracle.sql | 26 + ...saction_week_sampler_monday_one_oracle.sql | 28 + ...action_week_sampler_monday_zero_oracle.sql | 26 + ...ction_week_sampler_saturday_one_oracle.sql | 28 + ...tion_week_sampler_saturday_zero_oracle.sql | 26 + ...saction_week_sampler_sunday_one_oracle.sql | 24 + ...action_week_sampler_sunday_zero_oracle.sql | 24 + ...ction_week_sampler_thursday_one_oracle.sql | 28 + ...tion_week_sampler_thursday_zero_oracle.sql | 26 + ...action_week_sampler_tuesday_one_oracle.sql | 28 + ...ction_week_sampler_tuesday_zero_oracle.sql | 26 + ...tion_week_sampler_wednesday_one_oracle.sql | 28 + ...ion_week_sampler_wednesday_zero_oracle.sql | 26 + .../string_format_specifiers_oracle.sql | 18 + .../string_functions_oracle.sql | 30 + .../supplier_best_part_oracle.sql | 37 ++ .../supplier_pct_national_qty_oracle.sql | 46 ++ .../suppliers_bal_diffs_oracle.sql | 12 + .../synthea_most_common_conditions_oracle.sql | 13 + ...battery_failure_rates_anomalies_oracle.sql | 29 + ...graph_country_cartesian_oddball_oracle.sql | 12 + ...ph_country_combination_analysis_oracle.sql | 45 ++ ..._country_incident_rate_analysis_oracle.sql | 72 +++ ...or_percentages_sun_set_by_error_oracle.sql | 22 + ...rate_sun_set_by_factory_country_oracle.sql | 28 + ...echnograph_global_incident_rate_oracle.sql | 13 + ...technograph_hot_purchase_window_oracle.sql | 17 + ...h_incident_rate_by_release_year_oracle.sql | 41 ++ ...nograph_incident_rate_per_brand_oracle.sql | 20 + ...chnograph_monthly_incident_rate_oracle.sql | 70 +++ ...ograph_most_unreliable_products_oracle.sql | 29 + ...ve_incident_rate_goldcopperstar_oracle.sql | 83 +++ ...umulative_incident_rate_overall_oracle.sql | 64 ++ .../time_threshold_reached_oracle.sql | 24 + .../top_customers_by_orders_oracle.sql | 18 + .../top_lineitems_info_1_oracle.sql | 34 ++ .../top_lineitems_info_2_oracle.sql | 28 + tests/test_sql_refsols/tpch_q10_oracle.sql | 33 ++ tests/test_sql_refsols/tpch_q11_oracle.sql | 43 ++ tests/test_sql_refsols/tpch_q12_oracle.sql | 18 + tests/test_sql_refsols/tpch_q13_oracle.sql | 22 + tests/test_sql_refsols/tpch_q14_oracle.sql | 23 + tests/test_sql_refsols/tpch_q15_oracle.sql | 45 ++ tests/test_sql_refsols/tpch_q16_oracle.sql | 24 + tests/test_sql_refsols/tpch_q17_oracle.sql | 18 + tests/test_sql_refsols/tpch_q18_oracle.sql | 26 + tests/test_sql_refsols/tpch_q19_oracle.sql | 36 ++ tests/test_sql_refsols/tpch_q1_oracle.sql | 26 + tests/test_sql_refsols/tpch_q20_oracle.sql | 31 + tests/test_sql_refsols/tpch_q21_oracle.sql | 55 ++ tests/test_sql_refsols/tpch_q2_oracle.sql | 41 ++ tests/test_sql_refsols/tpch_q3_oracle.sql | 24 + tests/test_sql_refsols/tpch_q4_oracle.sql | 14 + tests/test_sql_refsols/tpch_q5_oracle.sql | 30 + tests/test_sql_refsols/tpch_q6_oracle.sql | 9 + tests/test_sql_refsols/tpch_q7_oracle.sql | 46 ++ tests/test_sql_refsols/tpch_q8_oracle.sql | 34 ++ tests/test_sql_refsols/tpch_q9_oracle.sql | 30 + .../triple_partition_oracle.sql | 72 +++ .../user_range_collection_1_oracle.sql | 36 ++ .../user_range_collection_2_oracle.sql | 547 ++++++++++++++++++ .../user_range_collection_3_oracle.sql | 547 ++++++++++++++++++ .../user_range_collection_4_oracle.sql | 32 + .../user_range_collection_5_oracle.sql | 36 ++ .../user_range_collection_6_oracle.sql | 33 ++ .../wdi_albania_footnotes_1978_oracle.sql | 7 + ..._low_income_country_with_series_oracle.sql | 8 + .../wealthiest_supplier_oracle.sql | 13 + tests/test_sql_refsols/week_offset_oracle.sql | 14 + .../window_filter_order_10_oracle.sql | 17 + .../window_filter_order_1_oracle.sql | 27 + .../window_filter_order_2_oracle.sql | 27 + .../window_filter_order_3_oracle.sql | 27 + .../window_filter_order_4_oracle.sql | 22 + .../window_filter_order_5_oracle.sql | 24 + .../window_filter_order_6_oracle.sql | 24 + .../window_filter_order_7_oracle.sql | 15 + .../window_filter_order_8_oracle.sql | 30 + .../window_filter_order_9_oracle.sql | 30 + .../window_functions_oracle.sql | 13 + .../window_sliding_frame_relsize_oracle.sql | 14 + .../window_sliding_frame_relsum_oracle.sql | 14 + .../year_month_nation_orders_oracle.sql | 21 + .../yoy_change_in_num_orders_oracle.sql | 17 + 415 files changed, 11060 insertions(+) create mode 100644 tests/test_sql_refsols/agg_partition_oracle.sql create mode 100644 tests/test_sql_refsols/agg_simplification_1_oracle.sql create mode 100644 tests/test_sql_refsols/agg_simplification_2_oracle.sql create mode 100644 tests/test_sql_refsols/aggregation_analytics_1_oracle.sql create mode 100644 tests/test_sql_refsols/aggregation_analytics_2_oracle.sql create mode 100644 tests/test_sql_refsols/aggregation_analytics_3_oracle.sql create mode 100644 tests/test_sql_refsols/aggregation_functions_oracle.sql create mode 100644 tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql create mode 100644 tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql create mode 100644 tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql create mode 100644 tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql create mode 100644 tests/test_sql_refsols/bad_child_reuse_1_oracle.sql create mode 100644 tests/test_sql_refsols/bad_child_reuse_2_oracle.sql create mode 100644 tests/test_sql_refsols/bad_child_reuse_3_oracle.sql create mode 100644 tests/test_sql_refsols/bad_child_reuse_4_oracle.sql create mode 100644 tests/test_sql_refsols/bad_child_reuse_5_oracle.sql create mode 100644 tests/test_sql_refsols/casting_functions_oracle.sql create mode 100644 tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql create mode 100644 tests/test_sql_refsols/conditional_functions_oracle.sql create mode 100644 tests/test_sql_refsols/country_x_year_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/country_x_year_combos_oracle.sql create mode 100644 tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql create mode 100644 tests/test_sql_refsols/customer_most_recent_orders_oracle.sql create mode 100644 tests/test_sql_refsols/datediff_oracle.sql create mode 100644 tests/test_sql_refsols/datetime_current_oracle.sql create mode 100644 tests/test_sql_refsols/datetime_functions_oracle.sql create mode 100644 tests/test_sql_refsols/datetime_relative_oracle.sql create mode 100644 tests/test_sql_refsols/datetime_sampler_oracle.sql create mode 100644 tests/test_sql_refsols/deep_best_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen11_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen12_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen13_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen14_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen15_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen16_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen17_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen18_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen19_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen20_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen21_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen22_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen23_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen24_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen25_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_academic_gen9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv11_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv12_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv13_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv14_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv15_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv16_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_adv9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_basic9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_gen1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_gen2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_gen3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_gen4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_broker_gen5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv11_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv12_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv14_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv15_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv16_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_basic9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_gen1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_gen2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_gen3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_gen4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_gen5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql create mode 100644 tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql create mode 100644 tests/test_sql_refsols/double_cross_oracle.sql create mode 100644 tests/test_sql_refsols/double_partition_oracle.sql create mode 100644 tests/test_sql_refsols/dumb_aggregation_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_culture_events_info_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_events_per_season_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql create mode 100644 tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql create mode 100644 tests/test_sql_refsols/extract_colors_oracle.sql create mode 100644 tests/test_sql_refsols/first_order_in_year_oracle.sql create mode 100644 tests/test_sql_refsols/first_order_per_customer_oracle.sql create mode 100644 tests/test_sql_refsols/floor_and_ceil_2_oracle.sql create mode 100644 tests/test_sql_refsols/floor_and_ceil_oracle.sql create mode 100644 tests/test_sql_refsols/get_part_single_oracle.sql create mode 100644 tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql create mode 100644 tests/test_sql_refsols/highest_priority_per_year_oracle.sql create mode 100644 tests/test_sql_refsols/hour_minute_day_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql create mode 100644 tests/test_sql_refsols/keywords_single_quote_use_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_10_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_11_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_1_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_2_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_3_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_4_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_5_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_6_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_7_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_8_oracle.sql create mode 100644 tests/test_sql_refsols/many_net_filter_9_oracle.sql create mode 100644 tests/test_sql_refsols/month_year_sliding_windows_oracle.sql create mode 100644 tests/test_sql_refsols/n_orders_first_day_oracle.sql create mode 100644 tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql create mode 100644 tests/test_sql_refsols/nation_best_order_oracle.sql create mode 100644 tests/test_sql_refsols/numerical_functions_oracle.sql create mode 100644 tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql create mode 100644 tests/test_sql_refsols/order_info_per_priority_oracle.sql create mode 100644 tests/test_sql_refsols/order_quarter_test_oracle.sql create mode 100644 tests/test_sql_refsols/orders_versus_first_orders_oracle.sql create mode 100644 tests/test_sql_refsols/part_cross_part_a_oracle.sql create mode 100644 tests/test_sql_refsols/part_cross_part_b_oracle.sql create mode 100644 tests/test_sql_refsols/part_cross_part_c_oracle.sql create mode 100644 tests/test_sql_refsols/part_reduced_size_oracle.sql create mode 100644 tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql create mode 100644 tests/test_sql_refsols/percentile_customers_per_region_oracle.sql create mode 100644 tests/test_sql_refsols/percentile_nations_oracle.sql create mode 100644 tests/test_sql_refsols/prev_next_regions_oracle.sql create mode 100644 tests/test_sql_refsols/quantile_function_test_1_oracle.sql create mode 100644 tests/test_sql_refsols/quantile_function_test_2_oracle.sql create mode 100644 tests/test_sql_refsols/quantile_function_test_3_oracle.sql create mode 100644 tests/test_sql_refsols/quantile_function_test_4_oracle.sql create mode 100644 tests/test_sql_refsols/quantile_test_1_oracle.sql create mode 100644 tests/test_sql_refsols/quantile_test_2_oracle.sql create mode 100644 tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/quarter_function_test_oracle.sql create mode 100644 tests/test_sql_refsols/rank_a_oracle.sql create mode 100644 tests/test_sql_refsols/rank_b_oracle.sql create mode 100644 tests/test_sql_refsols/rank_c_oracle.sql create mode 100644 tests/test_sql_refsols/rank_nations_by_region_oracle.sql create mode 100644 tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql create mode 100644 tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql create mode 100644 tests/test_sql_refsols/rank_with_filters_a_oracle.sql create mode 100644 tests/test_sql_refsols/rank_with_filters_b_oracle.sql create mode 100644 tests/test_sql_refsols/rank_with_filters_c_oracle.sql create mode 100644 tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql create mode 100644 tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql create mode 100644 tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql create mode 100644 tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql create mode 100644 tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql create mode 100644 tests/test_sql_refsols/richest_customer_per_region_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_11_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_12_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_13_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_15_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_16_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_1_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_2_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_3_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_5_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_6_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_7_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_8_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_9_oracle.sql create mode 100644 tests/test_sql_refsols/simple_filter_oracle.sql create mode 100644 tests/test_sql_refsols/simple_filter_top_five_oracle.sql create mode 100644 tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_1_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_2_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_3_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_4_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_5_oracle.sql create mode 100644 tests/test_sql_refsols/simple_scan_oracle.sql create mode 100644 tests/test_sql_refsols/simple_scan_top_five_oracle.sql create mode 100644 tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql create mode 100644 tests/test_sql_refsols/simple_var_std_oracle.sql create mode 100644 tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql create mode 100644 tests/test_sql_refsols/simplification_1_oracle.sql create mode 100644 tests/test_sql_refsols/simplification_2_oracle.sql create mode 100644 tests/test_sql_refsols/simplification_3_oracle.sql create mode 100644 tests/test_sql_refsols/simplification_4_oracle.sql create mode 100644 tests/test_sql_refsols/singular1_oracle.sql create mode 100644 tests/test_sql_refsols/singular2_oracle.sql create mode 100644 tests/test_sql_refsols/singular3_oracle.sql create mode 100644 tests/test_sql_refsols/singular4_oracle.sql create mode 100644 tests/test_sql_refsols/singular5_oracle.sql create mode 100644 tests/test_sql_refsols/singular6_oracle.sql create mode 100644 tests/test_sql_refsols/singular7_oracle.sql create mode 100644 tests/test_sql_refsols/smoke_b_oracle.sql create mode 100644 tests/test_sql_refsols/smoke_d_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql create mode 100644 tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql create mode 100644 tests/test_sql_refsols/string_format_specifiers_oracle.sql create mode 100644 tests/test_sql_refsols/string_functions_oracle.sql create mode 100644 tests/test_sql_refsols/supplier_best_part_oracle.sql create mode 100644 tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql create mode 100644 tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql create mode 100644 tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql create mode 100644 tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql create mode 100644 tests/test_sql_refsols/time_threshold_reached_oracle.sql create mode 100644 tests/test_sql_refsols/top_customers_by_orders_oracle.sql create mode 100644 tests/test_sql_refsols/top_lineitems_info_1_oracle.sql create mode 100644 tests/test_sql_refsols/top_lineitems_info_2_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q10_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q11_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q12_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q13_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q14_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q15_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q16_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q17_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q18_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q19_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q1_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q20_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q21_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q2_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q3_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q4_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q5_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q6_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q7_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q8_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q9_oracle.sql create mode 100644 tests/test_sql_refsols/triple_partition_oracle.sql create mode 100644 tests/test_sql_refsols/user_range_collection_1_oracle.sql create mode 100644 tests/test_sql_refsols/user_range_collection_2_oracle.sql create mode 100644 tests/test_sql_refsols/user_range_collection_3_oracle.sql create mode 100644 tests/test_sql_refsols/user_range_collection_4_oracle.sql create mode 100644 tests/test_sql_refsols/user_range_collection_5_oracle.sql create mode 100644 tests/test_sql_refsols/user_range_collection_6_oracle.sql create mode 100644 tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql create mode 100644 tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql create mode 100644 tests/test_sql_refsols/wealthiest_supplier_oracle.sql create mode 100644 tests/test_sql_refsols/week_offset_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_10_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_1_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_2_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_3_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_4_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_5_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_6_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_7_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_8_oracle.sql create mode 100644 tests/test_sql_refsols/window_filter_order_9_oracle.sql create mode 100644 tests/test_sql_refsols/window_functions_oracle.sql create mode 100644 tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql create mode 100644 tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql create mode 100644 tests/test_sql_refsols/year_month_nation_orders_oracle.sql create mode 100644 tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql diff --git a/tests/conftest.py b/tests/conftest.py index 41a33480e..115ac62b1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -33,6 +33,7 @@ from pydough.qdag import AstNodeBuilder from tests.test_pydough_functions.simple_pydough_functions import ( string_format_specifiers_mysql, + string_format_specifiers_oracle, string_format_specifiers_postgres, string_format_specifiers_snowflake, ) @@ -423,6 +424,7 @@ def sqlite_dialects(request) -> DatabaseDialect: pytest.param(DatabaseDialect.SNOWFLAKE, id="snowflake"), pytest.param(DatabaseDialect.MYSQL, id="mysql"), pytest.param(DatabaseDialect.POSTGRES, id="postgres"), + pytest.param(DatabaseDialect.ORACLE, id="oracle"), ] ) def empty_context_database(request) -> DatabaseContext: @@ -2344,6 +2346,31 @@ def tpch_custom_test_data_dialect_replacements( ), "string_format_specifiers", ) + case DatabaseDialect.ORACLE: + return PyDoughPandasTest( + string_format_specifiers_oracle, + "TPCH", + lambda: pd.DataFrame( + { + "d1": ["2023"], # YYYY + "d2": ["23"], # YY + "d3": ["07"], # MM + "d4": ["Jul"], # Mon + "d5": ["July"], # MMMM + "d6": ["15"], # DD + "d7": ["Sat"], # DY + "d8": ["Saturday"], # DYDY + "d9": ["14"], # HH24 + "d10": ["02"], # HH12 + "d11": ["30"], # MI + "d12": ["45"], # SS + "d13": ["PM"], # AM / PM + "d14": [".000000000"], # .FF + "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) + } + ), + "string_format_specifiers", + ) case _: pytest.skip("Skipping test: Unsupported dialect for test replacement") diff --git a/tests/test_pydough_functions/simple_pydough_functions.py b/tests/test_pydough_functions/simple_pydough_functions.py index 1f23f5c10..13e4fa007 100644 --- a/tests/test_pydough_functions/simple_pydough_functions.py +++ b/tests/test_pydough_functions/simple_pydough_functions.py @@ -2908,6 +2908,45 @@ def string_format_specifiers_snowflake(): ) +def string_format_specifiers_oracle(): + # String format specifiers for date/time with a static datetime + # Works for Oracle + # Using a specific date: 2023-07-15 14:30:45 + static_date = pd.Timestamp("2023-07-15 14:30:45") + return TPCH.CALCULATE( + # four-digit year + d1=STRING(static_date, "YYYY"), + # last two digits of the year + d2=STRING(static_date, "YY"), + # two-digit month (01–12) + d3=STRING(static_date, "MM"), + # abbreviated month name + d4=STRING(static_date, "Mon"), + # full month name + d5=STRING(static_date, "MMMM"), + # two-digit day of month (01–31) + d6=STRING(static_date, "DD"), + # abbreviated day of week + d7=STRING(static_date, "DY"), + # full day of week + d8=STRING(static_date, "DYDY"), + # hour in 24-hour format (00–23) + d9=STRING(static_date, "HH24"), + # hour in 12-hour format (01–12) + d10=STRING(static_date, "HH12"), + # minute (00–59) + d11=STRING(static_date, "MI"), + # second (00–59) + d12=STRING(static_date, "SS"), + # meridian indicator + d13=STRING(static_date, "PM"), + # fractional seconds (up to 9 digits) + d14=STRING(static_date, ".FF"), + # timezone hour and minute + d15=STRING(static_date, "TZH:TZM"), + ) + + def part_reduced_size(): # What are the top 5 line items with the highest discounts # on parts with the lowest retail prices casted to integers? diff --git a/tests/test_sql_refsols/agg_partition_oracle.sql b/tests/test_sql_refsols/agg_partition_oracle.sql new file mode 100644 index 000000000..4c7136a01 --- /dev/null +++ b/tests/test_sql_refsols/agg_partition_oracle.sql @@ -0,0 +1,10 @@ +WITH _T0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) +) +SELECT + MAX(N_ROWS) AS best_year +FROM _T0 diff --git a/tests/test_sql_refsols/agg_simplification_1_oracle.sql b/tests/test_sql_refsols/agg_simplification_1_oracle.sql new file mode 100644 index 000000000..aed5a4ea4 --- /dev/null +++ b/tests/test_sql_refsols/agg_simplification_1_oracle.sql @@ -0,0 +1,237 @@ +WITH _T1 AS ( + SELECT + sbtickerexchange AS SBTICKEREXCHANGE, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 1 + ELSE NULL + END AS EXPR_72, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(2) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 2 + ELSE NULL + END AS EXPR_73, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(-1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN -1 + ELSE NULL + END AS EXPR_74, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(-3) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN -3 + ELSE NULL + END AS EXPR_75, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(0) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 0 + ELSE NULL + END AS EXPR_76, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(0.5) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 0.5 + ELSE NULL + END AS EXPR_77, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) + ELSE NULL + END AS EXPR_79, + CASE + WHEN FLOOR(0.9 * COUNT(1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')))) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 1 + ELSE NULL + END AS EXPR_80, + CASE + WHEN FLOOR(0.8 * COUNT(2) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')))) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 2 + ELSE NULL + END AS EXPR_81, + CASE + WHEN FLOOR( + 0.7 * COUNT(-1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN -1 + ELSE NULL + END AS EXPR_82, + CASE + WHEN FLOOR( + 0.6 * COUNT(-3) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN -3 + ELSE NULL + END AS EXPR_83, + CASE + WHEN FLOOR(0.5 * COUNT(0) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')))) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 0 + ELSE NULL + END AS EXPR_84, + CASE + WHEN FLOOR( + 0.4 * COUNT(0.5) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 0.5 + ELSE NULL + END AS EXPR_85, + CASE + WHEN FLOOR( + 0.2 * COUNT(LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) DESC NULLS LAST) + THEN LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) + ELSE NULL + END AS EXPR_87 + FROM MAIN.SBTICKER +), _T0 AS ( + SELECT + LENGTH(CASE WHEN SBTICKEREXCHANGE <> 'NYSE Arca' THEN SBTICKEREXCHANGE ELSE NULL END) AS AUG_EXCHANGE, + AVG(EXPR_72) AS AVG_EXPR_72, + AVG(EXPR_73) AS AVG_EXPR_73, + AVG(EXPR_74) AS AVG_EXPR_74, + AVG(EXPR_75) AS AVG_EXPR_75, + AVG(EXPR_76) AS AVG_EXPR_76, + AVG(EXPR_77) AS AVG_EXPR_77, + AVG(EXPR_79) AS AVG_EXPR_79, + MAX(EXPR_80) AS MAX_EXPR_80, + MAX(EXPR_81) AS MAX_EXPR_81, + MAX(EXPR_82) AS MAX_EXPR_82, + MAX(EXPR_83) AS MAX_EXPR_83, + MAX(EXPR_84) AS MAX_EXPR_84, + MAX(EXPR_85) AS MAX_EXPR_85, + MAX(EXPR_87) AS MAX_EXPR_87, + COUNT(*) AS N_ROWS + FROM _T1 + GROUP BY + LENGTH(CASE WHEN SBTICKEREXCHANGE <> 'NYSE Arca' THEN SBTICKEREXCHANGE ELSE NULL END) +) +SELECT + AUG_EXCHANGE AS aug_exchange, + N_ROWS AS su1, + N_ROWS * 2 AS su2, + N_ROWS * -1 AS su3, + N_ROWS * -3 AS su4, + 0 AS su5, + N_ROWS * 0.5 AS su6, + 0 AS su7, + NVL(AUG_EXCHANGE, 0) AS su8, + N_ROWS AS co1, + N_ROWS AS co2, + N_ROWS AS co3, + N_ROWS AS co4, + N_ROWS AS co5, + N_ROWS AS co6, + 0 AS co7, + N_ROWS * CASE WHEN NOT AUG_EXCHANGE IS NULL THEN 1 ELSE 0 END AS co8, + 1 AS nd1, + 1 AS nd2, + 1 AS nd3, + 1 AS nd4, + 1 AS nd5, + 1 AS nd6, + 0 AS nd7, + CAST(NOT AUG_EXCHANGE IS NULL AS INT) AS nd8, + 1 AS av1, + 2 AS av2, + -1 AS av3, + -3 AS av4, + 0 AS av5, + 0.5 AS av6, + NULL AS av7, + AUG_EXCHANGE AS av8, + 1 AS mi1, + 2 AS mi2, + -1 AS mi3, + -3 AS mi4, + 0 AS mi5, + 0.5 AS mi6, + NULL AS mi7, + AUG_EXCHANGE AS mi8, + 1 AS ma1, + 2 AS ma2, + -1 AS ma3, + -3 AS ma4, + 0 AS ma5, + 0.5 AS ma6, + NULL AS ma7, + AUG_EXCHANGE AS ma8, + 1 AS an1, + 2 AS an2, + -1 AS an3, + -3 AS an4, + 0 AS an5, + 0.5 AS an6, + NULL AS an7, + AUG_EXCHANGE AS an8, + AVG_EXPR_72 AS me1, + AVG_EXPR_73 AS me2, + AVG_EXPR_74 AS me3, + AVG_EXPR_75 AS me4, + AVG_EXPR_76 AS me5, + AVG_EXPR_77 AS me6, + NULL AS me7, + AVG_EXPR_79 AS me8, + MAX_EXPR_80 AS qu1, + MAX_EXPR_81 AS qu2, + MAX_EXPR_82 AS qu3, + MAX_EXPR_83 AS qu4, + MAX_EXPR_84 AS qu5, + MAX_EXPR_85 AS qu6, + NULL AS qu7, + MAX_EXPR_87 AS qu8 +FROM _T0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/agg_simplification_2_oracle.sql b/tests/test_sql_refsols/agg_simplification_2_oracle.sql new file mode 100644 index 000000000..e4dccb32c --- /dev/null +++ b/tests/test_sql_refsols/agg_simplification_2_oracle.sql @@ -0,0 +1,16 @@ +SELECT + sbcuststate AS state, + COUNT(DISTINCT sbcustcity) AS a1, + COUNT(*) AS a2, + COUNT(CASE WHEN LOWER(sbcustname) LIKE 'j%' THEN sbcustname ELSE NULL END) AS a3, + NVL(SUM(CAST(sbcustpostalcode AS INT)), 0) AS a4, + MIN(sbcustphone) AS a5, + MAX(sbcustphone) AS a6, + ANY_VALUE(LOWER(sbcuststate)) AS a7, + ANY_VALUE(LOWER(sbcuststate)) AS a8, + ANY_VALUE(LOWER(sbcuststate)) AS a9 +FROM MAIN.SBCUSTOMER +GROUP BY + sbcuststate +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql new file mode 100644 index 000000000..81711b0a1 --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql @@ -0,0 +1,45 @@ +WITH _T1 AS ( + SELECT + s_name AS S_NAME, + s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER + WHERE + s_name = 'Supplier#000009450' +), _S11 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + PARTSUPP.ps_suppkey AS PS_SUPPKEY, + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) * ( + 1 - LINEITEM.l_tax + ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost + ) AS SUM_REVENUE + FROM TPCH.PARTSUPP PARTSUPP + JOIN _T1 _T4 + ON PARTSUPP.ps_suppkey = _T4.S_SUPPKEY + JOIN TPCH.PART PART + ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + AND LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +) +SELECT + PART.p_name AS part_name, + ROUND(NVL(_S11.SUM_REVENUE, 0), 2) AS revenue_generated +FROM TPCH.PARTSUPP PARTSUPP +JOIN _T1 _T1 + ON PARTSUPP.ps_suppkey = _T1.S_SUPPKEY +JOIN TPCH.PART PART + ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey +LEFT JOIN _S11 _S11 + ON PARTSUPP.ps_partkey = _S11.PS_PARTKEY AND PARTSUPP.ps_suppkey = _S11.PS_SUPPKEY +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 8 ROWS ONLY diff --git a/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql new file mode 100644 index 000000000..aea10e83a --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql @@ -0,0 +1,34 @@ +WITH _S6 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) * ( + 1 - LINEITEM.l_tax + ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost + ) AS SUM_REVENUE + FROM TPCH.PARTSUPP PARTSUPP + JOIN TPCH.SUPPLIER SUPPLIER + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey + AND SUPPLIER.s_name = 'Supplier#000000182' + JOIN TPCH.PART PART + ON PART.p_container LIKE 'SM%' AND PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + AND LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +) +SELECT + PART.p_name AS part_name, + ROUND(NVL(_S6.SUM_REVENUE, 0), 2) AS revenue_generated +FROM _S6 _S6 +JOIN TPCH.PART PART + ON PART.p_partkey = _S6.PS_PARTKEY +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 4 ROWS ONLY diff --git a/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql new file mode 100644 index 000000000..9bab90dbd --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql @@ -0,0 +1,35 @@ +WITH _S6 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY, + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) * ( + 1 - LINEITEM.l_tax + ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost + ) AS SUM_REVENUE + FROM TPCH.PARTSUPP PARTSUPP + JOIN TPCH.SUPPLIER SUPPLIER + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey + AND SUPPLIER.s_name = 'Supplier#000000182' + JOIN TPCH.PART PART + ON PART.p_container LIKE 'MED%' AND PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1994 + AND LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +) +SELECT + PART.p_name AS part_name, + ROUND(NVL(_S6.SUM_REVENUE, 0) / NVL(_S6.SUM_L_QUANTITY, 0), 2) AS revenue_ratio +FROM _S6 _S6 +JOIN TPCH.PART PART + ON PART.p_partkey = _S6.PS_PARTKEY +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/aggregation_functions_oracle.sql b/tests/test_sql_refsols/aggregation_functions_oracle.sql new file mode 100644 index 000000000..17a483609 --- /dev/null +++ b/tests/test_sql_refsols/aggregation_functions_oracle.sql @@ -0,0 +1,70 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T2 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_nationkey AS C_NATIONKEY, + _S1.N_ROWS, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_17, + CASE + WHEN FLOOR(0.2 * COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey)) < ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_18 + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +), _T1 AS ( + SELECT + ANY_VALUE(C_ACCTBAL) AS ANYTHING_C_ACCTBAL, + AVG(C_ACCTBAL) AS AVG_C_ACCTBAL, + AVG(EXPR_17) AS AVG_EXPR_17, + COUNT(C_ACCTBAL) AS COUNT_C_ACCTBAL, + MAX(C_ACCTBAL) AS MAX_C_ACCTBAL, + MAX(EXPR_18) AS MAX_EXPR_18, + MIN(C_ACCTBAL) AS MIN_C_ACCTBAL, + COUNT(DISTINCT C_ACCTBAL) AS NDISTINCT_C_ACCTBAL, + STDDEV_POP(C_ACCTBAL) AS POPULATION_STD_C_ACCTBAL, + VARIANCE_POP(C_ACCTBAL) AS POPULATION_VAR_C_ACCTBAL, + STDDEV(C_ACCTBAL) AS SAMPLE_STD_C_ACCTBAL, + VARIANCE(C_ACCTBAL) AS SAMPLE_VAR_C_ACCTBAL, + SUM(C_ACCTBAL) AS SUM_C_ACCTBAL, + SUM(N_ROWS) AS SUM_N_ROWS + FROM _T2 + GROUP BY + C_NATIONKEY +) +SELECT + NVL(SUM_C_ACCTBAL, 0) AS sum_value, + AVG_C_ACCTBAL AS avg_value, + AVG_EXPR_17 AS median_value, + MIN_C_ACCTBAL AS min_value, + MAX_C_ACCTBAL AS max_value, + MAX_EXPR_18 AS quantile_value, + ANYTHING_C_ACCTBAL AS anything_value, + COUNT_C_ACCTBAL AS count_value, + NDISTINCT_C_ACCTBAL AS count_distinct_value, + SAMPLE_VAR_C_ACCTBAL AS variance_s_value, + POPULATION_VAR_C_ACCTBAL AS variance_p_value, + SAMPLE_STD_C_ACCTBAL AS stddev_s_value, + POPULATION_STD_C_ACCTBAL AS stddev_p_value +FROM _T1 +WHERE + SUM_N_ROWS = 0 OR SUM_N_ROWS IS NULL diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql new file mode 100644 index 000000000..29da7a281 --- /dev/null +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -0,0 +1,78 @@ +WITH _S0 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _T2 AS ( + SELECT + pr_name AS PR_NAME, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'RubyCopper-Star' +), _S12 AS ( + SELECT DISTINCT + TRUNC(CAST(_S0.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + FROM _S0 _S0 + JOIN _T2 _T2 + ON _S0.CA_DT < TRUNC(DATE_ADD(CAST(_T2.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S0.CA_DT >= _T2.PR_RELEASE +), _T5 AS ( + SELECT + pr_id AS PR_ID, + pr_name AS PR_NAME + FROM MAIN.PRODUCTS + WHERE + pr_name = 'RubyCopper-Star' +), _S9 AS ( + SELECT + COUNTRIES.co_id AS CO_ID, + _T5.PR_ID + FROM _T5 _T5 + JOIN MAIN.COUNTRIES COUNTRIES + ON COUNTRIES.co_name = 'CN' +), _S13 AS ( + SELECT + TRUNC(CAST(_S2.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID + FROM _S0 _S2 + JOIN _T2 _T4 + ON _S2.CA_DT < TRUNC(DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S2.CA_DT >= _T4.PR_RELEASE + JOIN MAIN.INCIDENTS INCIDENTS + ON _S2.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN _S9 _S9 + ON INCIDENTS.in_repair_country_id = _S9.CO_ID + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = _S9.PR_ID + GROUP BY + TRUNC(CAST(_S2.CA_DT AS TIMESTAMP), 'QUARTER') +), _S21 AS ( + SELECT + TRUNC(CAST(_S14.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + COUNT(*) AS N_ROWS + FROM _S0 _S14 + JOIN _T2 _T8 + ON _S14.CA_DT < TRUNC(DATE_ADD(CAST(_T8.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S14.CA_DT >= _T8.PR_RELEASE + JOIN MAIN.DEVICES DEVICES + ON _S14.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN _T5 _T9 + ON DEVICES.de_product_id = _T9.PR_ID + GROUP BY + TRUNC(CAST(_S14.CA_DT AS TIMESTAMP), 'QUARTER') +) +SELECT + _S12.QUARTER AS quarter, + NVL(_S13.NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + NVL(_S21.N_ROWS, 0) AS n_sold, + ROUND( + SUM(NVL(_S13.NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY _S12.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S21.N_ROWS, 0)) OVER (ORDER BY _S12.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS quarter_cum +FROM _S12 _S12 +LEFT JOIN _S13 _S13 + ON _S12.QUARTER = _S13.QUARTER +LEFT JOIN _S21 _S21 + ON _S12.QUARTER = _S21.QUARTER +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql b/tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql new file mode 100644 index 000000000..704bb85e4 --- /dev/null +++ b/tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql @@ -0,0 +1,16 @@ +SELECT + ( + LINEITEM.l_extendedprice * ( + 1 - ( + POWER(LINEITEM.l_discount, 2) + ) + ) + 1.0 + ) / PART.p_retailprice AS computed_value, + LINEITEM.l_quantity + LINEITEM.l_extendedprice AS total, + LINEITEM.l_extendedprice - LINEITEM.l_quantity AS delta, + LINEITEM.l_quantity * LINEITEM.l_discount AS product, + LINEITEM.l_extendedprice / LINEITEM.l_quantity AS ratio, + POWER(LINEITEM.l_discount, 2) AS exponent +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey diff --git a/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql b/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql new file mode 100644 index 000000000..b8e5545f5 --- /dev/null +++ b/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql @@ -0,0 +1,25 @@ +WITH _S1 AS ( + SELECT + c_nationkey AS C_NATIONKEY, + SUM(GREATEST(c_acctbal, 0)) AS EXPR_0, + COUNT(GREATEST(c_acctbal, 0)) AS EXPR_1_0 + FROM TPCH.CUSTOMER + GROUP BY + c_nationkey +), _S3 AS ( + SELECT + NATION.n_regionkey AS N_REGIONKEY, + SUM(_S1.EXPR_0) AS SUM_EXPR, + SUM(_S1.EXPR_1_0) AS SUM_EXPR_1 + FROM TPCH.NATION NATION + JOIN _S1 _S1 + ON NATION.n_nationkey = _S1.C_NATIONKEY + GROUP BY + NATION.n_regionkey +) +SELECT + REGION.r_name AS region_name, + _S3.SUM_EXPR / _S3.SUM_EXPR_1 AS avg_bal_without_debt_erasure +FROM TPCH.REGION REGION +JOIN _S3 _S3 + ON REGION.r_regionkey = _S3.N_REGIONKEY diff --git a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql new file mode 100644 index 000000000..71166e85b --- /dev/null +++ b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql @@ -0,0 +1,14 @@ +WITH _T0 AS ( + SELECT + DATEDIFF( + CAST(o_orderdate AS DATETIME), + CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_clerk ORDER BY o_orderdate) AS DATETIME), + DAY + ) AS DELTA + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' +) +SELECT + AVG(DELTA) AS avg_delta +FROM _T0 diff --git a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql new file mode 100644 index 000000000..250ec02c8 --- /dev/null +++ b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql @@ -0,0 +1,24 @@ +WITH _T1 AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + ORDERS.o_custkey AS O_CUSTKEY, + DATEDIFF( + CAST(ORDERS.o_orderdate AS DATETIME), + CAST(LAG(ORDERS.o_orderdate, 1) OVER (PARTITION BY ORDERS.o_custkey ORDER BY ORDERS.o_orderdate) AS DATETIME), + DAY + ) AS DAY_DIFF + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'JAPAN' + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_orderpriority = '1-URGENT' +) +SELECT + ANY_VALUE(C_NAME) AS name, + AVG(DAY_DIFF) AS avg_diff +FROM _T1 +GROUP BY + O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql new file mode 100644 index 000000000..e90b5e642 --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql @@ -0,0 +1,27 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T1 AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + ORDER BY + CUSTOMER.c_acctbal DESC NULLS LAST, + NVL(_S1.N_ROWS, 0) NULLS FIRST + FETCH FIRST 10 ROWS ONLY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders +FROM _T1 +WHERE + N_ROWS <> 0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql new file mode 100644 index 000000000..3a87abebc --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql @@ -0,0 +1,27 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS, + COUNT(*) OVER (PARTITION BY CUSTOMER.c_nationkey) AS N_CUST + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders, + N_CUST AS n_cust +FROM _T1 +WHERE + N_ROWS <> 0 +ORDER BY + C_ACCTBAL DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql new file mode 100644 index 000000000..3a87abebc --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql @@ -0,0 +1,27 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS, + COUNT(*) OVER (PARTITION BY CUSTOMER.c_nationkey) AS N_CUST + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders, + N_CUST AS n_cust +FROM _T1 +WHERE + N_ROWS <> 0 +ORDER BY + C_ACCTBAL DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql new file mode 100644 index 000000000..b0f682f4a --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql @@ -0,0 +1,26 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS, + AVG(CAST(NVL(_S1.N_ROWS, 0) AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey) AS _W + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders +FROM _T +WHERE + N_ROWS <> 0 AND _W > NVL(N_ROWS, 0) +ORDER BY + C_ACCTBAL DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql new file mode 100644 index 000000000..657e14682 --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql @@ -0,0 +1,33 @@ +WITH _T2 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + O_CUSTKEY +), _S2 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + ORDER BY + 1 DESC NULLS LAST, + 2 DESC NULLS LAST + FETCH FIRST 10 ROWS ONLY +) +SELECT + _S2.C_CUSTKEY AS cust_key, + NVL(_S2.N_ROWS, 0) AS n_orders +FROM _S2 _S2 +JOIN _T2 _S3 + ON _S2.C_CUSTKEY = _S3.O_CUSTKEY +ORDER BY + _S2.C_ACCTBAL DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/casting_functions_oracle.sql b/tests/test_sql_refsols/casting_functions_oracle.sql new file mode 100644 index 000000000..589838d9c --- /dev/null +++ b/tests/test_sql_refsols/casting_functions_oracle.sql @@ -0,0 +1,6 @@ +SELECT + TO_CHAR(o_orderdate, 'YYYY-MM-DD') AS cast_to_string, + CAST(o_totalprice AS CLOB) AS cast_to_string2, + CAST(o_totalprice AS INT) AS cast_to_integer, + CAST(o_shippriority AS DOUBLE PRECISION) AS cast_to_float +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql new file mode 100644 index 000000000..440d9980c --- /dev/null +++ b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +) +SELECT + CUSTOMER.c_acctbal < 0 AS in_debt, + _S1.N_ROWS <= 12 OR _S1.N_ROWS IS NULL AS at_most_12_orders, + REGION.r_name = 'EUROPE' AS is_european, + NATION.n_name <> 'GERMANY' AS non_german, + CUSTOMER.c_acctbal > 0 AS non_empty_acct, + NOT _S1.N_ROWS IS NULL AND _S1.N_ROWS >= 5 AS at_least_5_orders, + REGION.r_name = 'ASIA' OR REGION.r_name = 'EUROPE' AS is_eurasian, + CUSTOMER.c_acctbal < 0 AND REGION.r_name = 'EUROPE' AS is_european_in_debt +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey diff --git a/tests/test_sql_refsols/conditional_functions_oracle.sql b/tests/test_sql_refsols/conditional_functions_oracle.sql new file mode 100644 index 000000000..39d55094b --- /dev/null +++ b/tests/test_sql_refsols/conditional_functions_oracle.sql @@ -0,0 +1,18 @@ +SELECT + CASE WHEN ANY_VALUE(CUSTOMER.c_acctbal) > 1000 THEN 'High' ELSE 'Low' END AS iff_col, + ANY_VALUE(CUSTOMER.c_name) IN ('Alice', 'Bob', 'Charlie') AS isin_col, + NVL(MIN(ORDERS.o_totalprice), 0.0) AS default_val, + NOT MIN(ORDERS.o_totalprice) IS NULL AS has_acct_bal, + MIN(ORDERS.o_totalprice) IS NULL AS no_acct_bal, + CASE + WHEN ANY_VALUE(CUSTOMER.c_acctbal) > 0 + THEN ANY_VALUE(CUSTOMER.c_acctbal) + ELSE NULL + END AS no_debt_bal +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey +WHERE + CUSTOMER.c_acctbal <= 1000 AND CUSTOMER.c_acctbal >= 100 +GROUP BY + CUSTOMER.c_custkey diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql new file mode 100644 index 000000000..d00c0f5ad --- /dev/null +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -0,0 +1,63 @@ +WITH _T1 AS ( + SELECT + co_name AS CO_NAME + FROM MAIN.COUNTRIES + WHERE + NOT co_name LIKE '%C%' +), _T4 AS ( + SELECT + pr_name AS PR_NAME, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'AmethystCopper-I' +), _S3 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _S15 AS ( + SELECT + _S7.CA_DT, + _T6.CO_NAME, + COUNT(*) AS N_ROWS + FROM _T1 _T6 + CROSS JOIN _T4 _T7 + JOIN _S3 _S7 + ON _S7.CA_DT < DATE_ADD(CAST(_T7.PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + AND _S7.CA_DT >= _T7.PR_RELEASE + JOIN MAIN.DEVICES DEVICES + ON _S7.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'AmethystCopper-I' + JOIN MAIN.COUNTRIES COUNTRIES + ON COUNTRIES.co_id = DEVICES.de_purchase_country_id + AND COUNTRIES.co_name = _T6.CO_NAME + GROUP BY + _S7.CA_DT, + _T6.CO_NAME +), _S17 AS ( + SELECT + TRUNC(CAST(_S3.CA_DT AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + _T3.CO_NAME, + SUM(_S15.N_ROWS) AS SUM_N_ROWS + FROM _T1 _T3 + CROSS JOIN _T4 _T4 + JOIN _S3 _S3 + ON _S3.CA_DT < DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + AND _S3.CA_DT >= _T4.PR_RELEASE + LEFT JOIN _S15 _S15 + ON _S15.CA_DT = _S3.CA_DT AND _S15.CO_NAME = _T3.CO_NAME + GROUP BY + TRUNC(CAST(_S3.CA_DT AS TIMESTAMP), 'YEAR'), + _T3.CO_NAME +) +SELECT + _T1.CO_NAME AS country_name, + _S17.START_OF_YEAR AS start_of_year, + NVL(_S17.SUM_N_ROWS, 0) AS n_purchases +FROM _T1 _T1 +LEFT JOIN _S17 _S17 + ON _S17.CO_NAME = _T1.CO_NAME +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/country_x_year_combos_oracle.sql b/tests/test_sql_refsols/country_x_year_combos_oracle.sql new file mode 100644 index 000000000..da1b56b19 --- /dev/null +++ b/tests/test_sql_refsols/country_x_year_combos_oracle.sql @@ -0,0 +1,26 @@ +WITH _T1 AS ( + SELECT + co_name AS CO_NAME + FROM MAIN.COUNTRIES + WHERE + NOT co_name LIKE '%C%' +), _S5 AS ( + SELECT DISTINCT + TRUNC(CAST(CALENDAR.ca_dt AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + _T3.CO_NAME + FROM _T1 _T3 + JOIN MAIN.PRODUCTS PRODUCTS + ON PRODUCTS.pr_name = 'AmethystCopper-I' + JOIN MAIN.CALENDAR CALENDAR + ON CALENDAR.ca_dt < DATE_ADD(CAST(PRODUCTS.pr_release AS TIMESTAMP), 2, 'YEAR') + AND CALENDAR.ca_dt >= PRODUCTS.pr_release +) +SELECT + _T1.CO_NAME AS country_name, + _S5.START_OF_YEAR AS start_of_year +FROM _T1 _T1 +LEFT JOIN _S5 _S5 + ON _S5.CO_NAME = _T1.CO_NAME +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql new file mode 100644 index 000000000..38685d21c --- /dev/null +++ b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql @@ -0,0 +1,32 @@ +SELECT + SBTRANSACTION.sbtxdatetime AS date_time, + COUNT(*) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS txn_within_day, + COUNT( + CASE WHEN SBTRANSACTION.sbtxtype = 'buy' THEN SBTRANSACTION.sbtxtype ELSE NULL END + ) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_buys_within_day, + ROUND( + ( + 100.0 * SUM(SBTICKER.sbtickersymbol IN ('AAPL', 'AMZN')) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) + ) / COUNT(*) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS pct_apple_txns, + SUM( + CASE + WHEN SBTRANSACTION.sbtxtype = 'buy' + THEN SBTRANSACTION.sbtxshares + ELSE 0 - SBTRANSACTION.sbtxshares + END + ) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS share_change, + ROUND( + AVG(CAST(SBTRANSACTION.sbtxamount AS DOUBLE PRECISION)) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS rolling_avg_amount +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid +WHERE + EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 4 + AND EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + AND SBTRANSACTION.sbtxstatus = 'success' +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql new file mode 100644 index 000000000..5a41ca09b --- /dev/null +++ b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql @@ -0,0 +1,53 @@ +WITH _S1 AS ( + SELECT + l_discount AS L_DISCOUNT, + l_extendedprice AS L_EXTENDEDPRICE, + l_orderkey AS L_ORDERKEY + FROM TPCH.LINEITEM + WHERE + EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_shipmode = 'AIR' +), _T5 AS ( + SELECT + ANY_VALUE(ORDERS.o_custkey) AS ANYTHING_O_CUSTKEY, + ANY_VALUE(ORDERS.o_orderdate) AS ANYTHING_O_ORDERDATE, + SUM(_S1.L_EXTENDEDPRICE * ( + 1 - _S1.L_DISCOUNT + )) AS SUM_R + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S1 _S1 + ON ORDERS.o_orderkey = _S1.L_ORDERKEY + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1994 + GROUP BY + ORDERS.o_orderkey +), _T AS ( + SELECT + ANYTHING_O_CUSTKEY, + ANYTHING_O_ORDERDATE, + SUM_R, + LAG(NVL(SUM_R, 0), 1) OVER (PARTITION BY ANYTHING_O_CUSTKEY ORDER BY ANYTHING_O_ORDERDATE) AS _W + FROM _T5 +), _T1 AS ( + SELECT + _T.ANYTHING_O_CUSTKEY, + CUSTOMER.c_name AS C_NAME, + NVL(_T.SUM_R, 0) - LAG(NVL(_T.SUM_R, 0), 1) OVER (PARTITION BY _T.ANYTHING_O_CUSTKEY ORDER BY _T.ANYTHING_O_ORDERDATE) AS REVENUE_DELTA + FROM TPCH.CUSTOMER CUSTOMER + JOIN _T _T + ON CUSTOMER.c_custkey = _T.ANYTHING_O_CUSTKEY AND NOT _T._W IS NULL + WHERE + CUSTOMER.c_mktsegment = 'AUTOMOBILE' +) +SELECT + ANY_VALUE(C_NAME) AS name, + CASE + WHEN ABS(MIN(REVENUE_DELTA)) > MAX(REVENUE_DELTA) + THEN MIN(REVENUE_DELTA) + ELSE MAX(REVENUE_DELTA) + END AS largest_diff +FROM _T1 +GROUP BY + ANYTHING_O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql new file mode 100644 index 000000000..3a0ecd689 --- /dev/null +++ b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql @@ -0,0 +1,25 @@ +WITH _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_totalprice AS O_TOTALPRICE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate DESC, o_orderkey) AS _W + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + O_CUSTKEY, + SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM _T + WHERE + _W <= 5 + GROUP BY + O_CUSTKEY +) +SELECT + CUSTOMER.c_name AS name, + NVL(_S1.SUM_O_TOTALPRICE, 0) AS total_recent_value +FROM TPCH.CUSTOMER CUSTOMER +JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/datediff_oracle.sql b/tests/test_sql_refsols/datediff_oracle.sql new file mode 100644 index 000000000..accf3de8f --- /dev/null +++ b/tests/test_sql_refsols/datediff_oracle.sql @@ -0,0 +1,16 @@ +SELECT + sbtxdatetime AS x, + TIME_STR_TO_TIME('2025-05-02 11:00:00') AS y1, + TIME_STR_TO_TIME('2023-04-03 13:16:30') AS y, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), YEAR) AS years_diff, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), MONTH) AS months_diff, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), DAY) AS days_diff, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), HOUR) AS hours_diff, + DATEDIFF(TIME_STR_TO_TIME('2023-04-03 13:16:30'), CAST(sbtxdatetime AS DATETIME), MINUTE) AS minutes_diff, + DATEDIFF(TIME_STR_TO_TIME('2023-04-03 13:16:30'), CAST(sbtxdatetime AS DATETIME), SECOND) AS seconds_diff +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 +ORDER BY + 4 NULLS FIRST +FETCH FIRST 30 ROWS ONLY diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql new file mode 100644 index 000000000..6a81334e8 --- /dev/null +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -0,0 +1,10 @@ +SELECT + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 5, 'MONTH'), 1, DAY) AS d1, + DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 24, 'HOUR') AS d2, + DATE_ADD( + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 12, 'HOUR'), 150, MINUTE), + 2, + 'SECOND' + ) AS d3 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/datetime_functions_oracle.sql b/tests/test_sql_refsols/datetime_functions_oracle.sql new file mode 100644 index 000000000..35065ebf5 --- /dev/null +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -0,0 +1,57 @@ +SELECT + CURRENT_TIMESTAMP AS ts_now_1, + TRUNC(CURRENT_TIMESTAMP, 'DAY') AS ts_now_2, + TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS ts_now_3, + DATE_ADD(CURRENT_TIMESTAMP, 1, 'HOUR') AS ts_now_4, + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS ts_now_5, + TO_DATE('1995-10-08', 'YYYY-MM-DD') AS ts_now_6, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS year_col, + 2020 AS year_py, + 1995 AS year_pd, + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) AS month_col, + 2 AS month_str, + 1 AS month_dt, + EXTRACT(DAY FROM CAST(o_orderdate AS DATETIME)) AS day_col, + 25 AS day_str, + 23 AS hour_str, + 59 AS minute_str, + 59 AS second_ts, + DATEDIFF(CAST('1992-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), DAY) AS dd_col_str, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1992-01-01' AS TIMESTAMP), DAY) AS dd_str_col, + DATEDIFF(CAST(o_orderdate AS DATETIME), TIME_STR_TO_TIME('1995-10-10 00:00:00'), MONTH) AS dd_pd_col, + DATEDIFF(TIME_STR_TO_TIME('1992-01-01 12:30:45'), CAST(o_orderdate AS DATETIME), YEAR) AS dd_col_dt, + DATEDIFF(TIME_STR_TO_TIME('1992-01-01 12:30:45'), CAST('1992-01-01' AS TIMESTAMP), WEEK) AS dd_dt_str, + DAY_OF_WEEK(o_orderdate) AS dow_col, + 3 AS dow_str1, + 4 AS dow_str2, + 5 AS dow_str3, + 6 AS dow_str4, + 0 AS dow_str5, + 1 AS dow_str6, + 2 AS dow_str7, + 3 AS dow_dt, + 2 AS dow_pd, + CASE + WHEN DAY_OF_WEEK(o_orderdate) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(o_orderdate) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(o_orderdate) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(o_orderdate) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(o_orderdate) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(o_orderdate) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(o_orderdate) = 6 + THEN 'Saturday' + END AS dayname_col, + 'Monday' AS dayname_str1, + 'Tuesday' AS dayname_str2, + 'Wednesday' AS dayname_str3, + 'Thursday' AS dayname_str4, + 'Friday' AS dayname_str5, + 'Saturday' AS dayname_str6, + 'Sunday' AS dayname_dt +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/datetime_relative_oracle.sql b/tests/test_sql_refsols/datetime_relative_oracle.sql new file mode 100644 index 000000000..39826dfcc --- /dev/null +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -0,0 +1,31 @@ +WITH _T0 AS ( + SELECT + o_orderdate AS O_ORDERDATE + FROM TPCH.ORDERS + ORDER BY + o_custkey NULLS FIRST, + 1 NULLS FIRST + FETCH FIRST 10 ROWS ONLY +) +SELECT + TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'YEAR') AS d1, + TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'MONTH') AS d2, + DATE_ADD( + DATE_SUB( + DATE_ADD( + DATE_SUB(DATE_ADD(DATE_SUB(CAST(O_ORDERDATE AS TIMESTAMP), 11, YEAR), 9, 'MONTH'), 7, DAY), + 5, + 'HOUR' + ), + 3, + MINUTE + ), + 1, + 'SECOND' + ) AS d3, + TIME_STR_TO_TIME('2025-07-04 12:00:00') AS d4, + TIME_STR_TO_TIME('2025-07-04 12:58:00') AS d5, + TIME_STR_TO_TIME('2025-07-26 02:45:25') AS d6 +FROM _T0 +ORDER BY + O_ORDERDATE NULLS FIRST diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql new file mode 100644 index 000000000..e7db84617 --- /dev/null +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -0,0 +1,164 @@ +SELECT + TIME_STR_TO_TIME('2025-07-04 12:58:45') AS _expr0, + TIME_STR_TO_TIME('2024-12-31 11:59:00') AS _expr1, + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS _expr2, + TO_DATE('1999-03-14', 'YYYY-MM-DD') AS _expr3, + CURRENT_TIMESTAMP AS _expr4, + CURRENT_TIMESTAMP AS _expr5, + CURRENT_TIMESTAMP AS _expr6, + CURRENT_TIMESTAMP AS _expr7, + CURRENT_TIMESTAMP AS _expr8, + CURRENT_TIMESTAMP AS _expr9, + CURRENT_TIMESTAMP AS _expr10, + CURRENT_TIMESTAMP AS _expr11, + CURRENT_TIMESTAMP AS _expr12, + CURRENT_TIMESTAMP AS _expr13, + CURRENT_TIMESTAMP AS _expr14, + CURRENT_TIMESTAMP AS _expr15, + CURRENT_TIMESTAMP AS _expr16, + CURRENT_TIMESTAMP AS _expr17, + CURRENT_TIMESTAMP AS _expr18, + CAST(o_orderdate AS TIMESTAMP) AS _expr19, + TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND) AS _expr20, + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 8, 'MINUTE'), 141, MONTH) AS _expr21, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), SECOND), HOUR) AS _expr22, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), SECOND), HOUR) AS _expr23, + DATE_ADD(DATE_SUB(CURRENT_TIMESTAMP, 96, HOUR), 15, 'YEAR') AS _expr24, + DATE_ADD( + TIMESTAMP_TRUNC(DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 3, YEAR), MINUTE), + 65, + 'MONTH' + ) AS _expr25, + TRUNC(DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 56, HOUR), 'YEAR') AS _expr26, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 63, DAY), MINUTE), SECOND) AS _expr27, + TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS _expr28, + DATE_ADD(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 312, HOUR), SECOND), 48, 'YEAR') AS _expr29, + DATE_SUB( + DATE_ADD(TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 75, 'DAY'), 'DAY'), 600, 'MINUTE'), + 294, + DAY + ) AS _expr30, + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 480, 'MONTH'), 45, YEAR) AS _expr31, + TIMESTAMP_TRUNC( + TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 270, MINUTE), 34, SECOND), 'DAY'), + SECOND + ) AS _expr32, + DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 213, 'SECOND') AS _expr33, + DATE_ADD( + DATE_ADD(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 13, 'MINUTE'), 28, 'YEAR'), + 344, + 'SECOND' + ) AS _expr34, + TRUNC(CURRENT_TIMESTAMP, 'DAY') AS _expr35, + TIME_STR_TO_TIME('2116-01-01 00:49:00') AS _expr36, + TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 'DAY') AS _expr37, + TRUNC(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 'YEAR') AS _expr38, + TIME_STR_TO_TIME('2025-07-01 00:22:00') AS _expr39, + TRUNC(CURRENT_TIMESTAMP, 'YEAR') AS _expr40, + TRUNC( + DATE_SUB( + DATE_ADD(DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 82, 'SECOND'), 415, 'SECOND'), + 160, + SECOND + ), + 'YEAR' + ) AS _expr41, + DATE_ADD(CURRENT_TIMESTAMP, 192, 'MONTH') AS _expr42, + DATE_ADD( + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), MINUTE), HOUR), + 486, + 'MINUTE' + ) AS _expr43, + DATE_SUB(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND), 50, HOUR) AS _expr44, + TIMESTAMP_TRUNC( + DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 297, 'DAY'), 72, 'MONTH'), 92, MONTH), + HOUR + ) AS _expr45, + TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 285, 'SECOND'), 'DAY') AS _expr46, + TO_DATE('1999-05-15', 'YYYY-MM-DD') AS _expr47, + DATE_SUB(TRUNC(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 1, 'HOUR'), 'MONTH'), 21, DAY) AS _expr48, + DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 212, 'MINUTE'), 368, 'YEAR') AS _expr49, + TO_DATE('2024-01-01', 'YYYY-MM-DD') AS _expr50, + TO_DATE('1999-03-14', 'YYYY-MM-DD') AS _expr51, + DATE_ADD( + TIMESTAMP_TRUNC(TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 60, HOUR), 'DAY'), MINUTE), + 196, + 'YEAR' + ) AS _expr52, + DATE_ADD( + TIMESTAMP_TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 40, HOUR), 385, DAY), MINUTE), + 29, + 'HOUR' + ) AS _expr53, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 405, 'DAY'), HOUR), MINUTE) AS _expr54, + DATE_ADD( + DATE_ADD(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), SECOND), 98, 'YEAR'), + 96, + 'MONTH' + ) AS _expr55, + DATE_ADD( + TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, MINUTE), SECOND), 'DAY'), + 78, + 'SECOND' + ) AS _expr56, + DATE_ADD( + DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 136, 'HOUR'), 104, 'MINUTE'), 104, MONTH), + 312, + 'DAY' + ) AS _expr57, + DATE_SUB(DATE_ADD(CURRENT_TIMESTAMP, 45, 'MONTH'), 135, SECOND) AS _expr58, + EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS _expr59, + 2025 AS _expr60, + 1999 AS _expr61, + EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS _expr62, + 6 AS _expr63, + 3 AS _expr64, + EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS _expr65, + 4 AS _expr66, + 4 AS _expr67, + EXTRACT(HOUR FROM CURRENT_TIMESTAMP) AS _expr68, + 0 AS _expr69, + 0 AS _expr70, + EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS _expr71, + 30 AS _expr72, + 0 AS _expr73, + EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS _expr74, + 45 AS _expr75, + 0 AS _expr76, + DATEDIFF(CURRENT_TIMESTAMP, CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS _expr77, + DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), CAST(o_orderdate AS DATETIME), YEAR) AS _expr78, + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MONTH) AS _expr79, + DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), TIME_STR_TO_TIME('2006-05-01 12:00:00'), MONTH) AS _expr80, + DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, DAY) AS _expr81, + DATEDIFF(CURRENT_TIMESTAMP, CAST('1999-03-14' AS TIMESTAMP), DAY) AS _expr82, + DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, HOUR) AS _expr83, + DATEDIFF(CAST(o_orderdate AS DATETIME), TO_DATE('2005-06-30', 'YYYY-MM-DD'), HOUR) AS _expr84, + DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CURRENT_TIMESTAMP, MINUTE) AS _expr85, + DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), CAST(o_orderdate AS DATETIME), MINUTE) AS _expr86, + DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS _expr87, + DATEDIFF( + CAST('2018-02-14 12:41:06' AS TIMESTAMP), + TO_DATE('2005-06-30', 'YYYY-MM-DD'), + SECOND + ) AS _expr88, + DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CAST(o_orderdate AS DATETIME), YEAR) AS _expr89, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS _expr90, + DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), CAST(o_orderdate AS DATETIME), MONTH) AS _expr91, + DATEDIFF( + CAST('2018-02-14 12:41:06' AS TIMESTAMP), + TIME_STR_TO_TIME('2019-07-04 11:30:00'), + MONTH + ) AS _expr92, + DATEDIFF(CAST(o_orderdate AS DATETIME), CURRENT_TIMESTAMP, DAY) AS _expr93, + DATEDIFF(CURRENT_TIMESTAMP, TIME_STR_TO_TIME('2019-07-04 11:30:00'), DAY) AS _expr94, + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2022-11-24', 'YYYY-MM-DD'), HOUR) AS _expr95, + DATEDIFF( + TIME_STR_TO_TIME('2020-12-31 00:31:06'), + CAST('2018-02-14 12:41:06' AS TIMESTAMP), + HOUR + ) AS _expr96, + DATEDIFF(TIME_STR_TO_TIME('2020-12-31 00:31:06'), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MINUTE) AS _expr97, + DATEDIFF(CAST('2018-02-14 12:41:06' AS TIMESTAMP), CURRENT_TIMESTAMP, MINUTE) AS _expr98, + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), CURRENT_TIMESTAMP, SECOND) AS _expr99, + DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS _expr100 +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/deep_best_analysis_oracle.sql b/tests/test_sql_refsols/deep_best_analysis_oracle.sql new file mode 100644 index 000000000..e8d0e5b2a --- /dev/null +++ b/tests/test_sql_refsols/deep_best_analysis_oracle.sql @@ -0,0 +1,109 @@ +WITH _T2 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY, + c_nationkey AS C_NATIONKEY + FROM TPCH.CUSTOMER +), _T AS ( + SELECT + C_ACCTBAL, + C_CUSTKEY, + C_NATIONKEY, + ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS _W + FROM _T2 +), _S4 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), _T_2 AS ( + SELECT + _S5.C_ACCTBAL, + _S4.N_NATIONKEY, + _S4.N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY _S4.N_REGIONKEY ORDER BY _S5.C_ACCTBAL DESC, _S5.C_CUSTKEY) AS _W + FROM _S4 _S4 + JOIN _T2 _S5 + ON _S4.N_NATIONKEY = _S5.C_NATIONKEY +), _S7 AS ( + SELECT + C_ACCTBAL, + N_NATIONKEY, + N_REGIONKEY + FROM _T_2 + WHERE + _W = 1 +), _T_3 AS ( + SELECT + _S8.N_NATIONKEY, + _S8.N_REGIONKEY, + PARTSUPP.ps_availqty AS PS_AVAILQTY, + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUPPLIER.s_nationkey AS S_NATIONKEY, + SUPPLIER.s_suppkey AS S_SUPPKEY, + ROW_NUMBER() OVER (PARTITION BY _S8.N_REGIONKEY ORDER BY PARTSUPP.ps_availqty DESC, PARTSUPP.ps_partkey) AS _W + FROM _S4 _S8 + JOIN TPCH.SUPPLIER SUPPLIER + ON SUPPLIER.s_nationkey = _S8.N_NATIONKEY + JOIN TPCH.PARTSUPP PARTSUPP + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +), _T_4 AS ( + SELECT + N_NATIONKEY, + N_REGIONKEY, + PS_AVAILQTY, + PS_PARTKEY, + S_NATIONKEY, + S_SUPPKEY, + ROW_NUMBER() OVER (PARTITION BY N_REGIONKEY ORDER BY PS_AVAILQTY DESC, S_SUPPKEY) AS _W + FROM _T_3 + WHERE + _W = 1 +), _S13 AS ( + SELECT + N_NATIONKEY, + N_REGIONKEY, + PS_AVAILQTY, + PS_PARTKEY, + S_SUPPKEY + FROM _T_4 + WHERE + N_NATIONKEY = S_NATIONKEY AND _W = 1 +), _T_5 AS ( + SELECT + C_CUSTKEY, + C_NATIONKEY, + ROW_NUMBER() OVER (ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS _W + FROM _T2 +), _S15 AS ( + SELECT + C_CUSTKEY, + C_NATIONKEY + FROM _T_5 + WHERE + _W = 1 +) +SELECT + REGION.r_name, + NATION.n_name, + _T.C_CUSTKEY AS c_key, + _T.C_ACCTBAL AS c_bal, + _S7.C_ACCTBAL AS cr_bal, + _S13.S_SUPPKEY AS s_key, + _S13.PS_PARTKEY AS p_key, + _S13.PS_AVAILQTY AS p_qty, + _S15.C_CUSTKEY AS cg_key +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN _T _T + ON NATION.n_nationkey = _T.C_NATIONKEY AND _T._W = 1 +LEFT JOIN _S7 _S7 + ON NATION.n_nationkey = _S7.N_NATIONKEY AND REGION.r_regionkey = _S7.N_REGIONKEY +LEFT JOIN _S13 _S13 + ON NATION.n_nationkey = _S13.N_NATIONKEY AND REGION.r_regionkey = _S13.N_REGIONKEY +LEFT JOIN _S15 _S15 + ON NATION.n_nationkey = _S15.C_NATIONKEY +ORDER BY + 2 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen10_oracle.sql b/tests/test_sql_refsols/defog_academic_gen10_oracle.sql new file mode 100644 index 000000000..3fcab37c3 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen10_oracle.sql @@ -0,0 +1,5 @@ +SELECT + title +FROM MAIN.PUBLICATION +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen11_oracle.sql b/tests/test_sql_refsols/defog_academic_gen11_oracle.sql new file mode 100644 index 000000000..b4fd8b3e6 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen11_oracle.sql @@ -0,0 +1,13 @@ +WITH _S0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.PUBLICATION +), _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.AUTHOR +) +SELECT + _S0.N_ROWS / NULLIF(_S1.N_ROWS, 0) AS publication_to_author_ratio +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/defog_academic_gen12_oracle.sql b/tests/test_sql_refsols/defog_academic_gen12_oracle.sql new file mode 100644 index 000000000..a3ff46359 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen12_oracle.sql @@ -0,0 +1,3 @@ +SELECT + SUM(NOT cid IS NULL) / NULLIF(SUM(NOT jid IS NULL), 0) AS ratio +FROM MAIN.PUBLICATION diff --git a/tests/test_sql_refsols/defog_academic_gen13_oracle.sql b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql new file mode 100644 index 000000000..eb8c255e8 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql @@ -0,0 +1,23 @@ +WITH _S1 AS ( + SELECT + did AS DID, + COUNT(*) AS N_ROWS + FROM MAIN.DOMAIN_PUBLICATION + GROUP BY + did +), _S3 AS ( + SELECT + did AS DID, + COUNT(*) AS N_ROWS + FROM MAIN.DOMAIN_KEYWORD + GROUP BY + did +) +SELECT + DOMAIN.did AS domain_id, + NVL(_S1.N_ROWS, 0) / NULLIF(_S3.N_ROWS, 0) AS ratio +FROM MAIN.DOMAIN DOMAIN +LEFT JOIN _S1 _S1 + ON DOMAIN.did = _S1.DID +LEFT JOIN _S3 _S3 + ON DOMAIN.did = _S3.DID diff --git a/tests/test_sql_refsols/defog_academic_gen14_oracle.sql b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql new file mode 100644 index 000000000..ca6d0ba14 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql @@ -0,0 +1,8 @@ +SELECT + year, + COUNT(*) AS num_publications, + COUNT(DISTINCT jid) AS num_journals, + COUNT(*) / NULLIF(COUNT(DISTINCT jid), 0) AS ratio +FROM MAIN.PUBLICATION +GROUP BY + year diff --git a/tests/test_sql_refsols/defog_academic_gen15_oracle.sql b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql new file mode 100644 index 000000000..d9a01a6ac --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql @@ -0,0 +1,18 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(ORGANIZATION.continent) AS ANYTHING_CONTINENT, + COUNT(AUTHOR.oid) AS COUNT_OID + FROM MAIN.ORGANIZATION ORGANIZATION + LEFT JOIN MAIN.AUTHOR AUTHOR + ON AUTHOR.oid = ORGANIZATION.oid + GROUP BY + ORGANIZATION.oid +) +SELECT + ANYTHING_CONTINENT AS continent, + NVL(SUM(COUNT_OID), 0) / COUNT(*) AS ratio +FROM _T1 +GROUP BY + ANYTHING_CONTINENT +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen16_oracle.sql b/tests/test_sql_refsols/defog_academic_gen16_oracle.sql new file mode 100644 index 000000000..6fd7a3f5e --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen16_oracle.sql @@ -0,0 +1,19 @@ +WITH _S3 AS ( + SELECT + WRITES.aid AS AID, + COUNT(DISTINCT PUBLICATION.pid) AS NDISTINCT_PID + FROM MAIN.WRITES WRITES + JOIN MAIN.PUBLICATION PUBLICATION + ON PUBLICATION.pid = WRITES.pid AND PUBLICATION.year = 2021 + GROUP BY + WRITES.aid +) +SELECT + AUTHOR.name, + _S3.NDISTINCT_PID AS count_publication +FROM MAIN.AUTHOR AUTHOR +JOIN _S3 _S3 + ON AUTHOR.aid = _S3.AID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen17_oracle.sql b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql new file mode 100644 index 000000000..f6638bd62 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ANY_VALUE(CONFERENCE.name) AS name, + NVL(NULLIF(COUNT(PUBLICATION.cid), 0), 0) AS count_publications +FROM MAIN.CONFERENCE CONFERENCE +LEFT JOIN MAIN.PUBLICATION PUBLICATION + ON CONFERENCE.cid = PUBLICATION.cid +GROUP BY + CONFERENCE.cid +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql new file mode 100644 index 000000000..fef7d2f38 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + jid AS JID, + COUNT(*) AS N_ROWS + FROM MAIN.PUBLICATION + GROUP BY + jid +) +SELECT + JOURNAL.name, + JOURNAL.jid AS journal_id, + NVL(_S1.N_ROWS, 0) AS num_publications +FROM MAIN.JOURNAL JOURNAL +LEFT JOIN _S1 _S1 + ON JOURNAL.jid = _S1.JID +ORDER BY + 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen19_oracle.sql b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql new file mode 100644 index 000000000..e6dc99683 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ANY_VALUE(CONFERENCE.name) AS name, + NVL(NULLIF(COUNT(PUBLICATION.cid), 0), 0) AS num_publications +FROM MAIN.CONFERENCE CONFERENCE +LEFT JOIN MAIN.PUBLICATION PUBLICATION + ON CONFERENCE.cid = PUBLICATION.cid +GROUP BY + CONFERENCE.cid +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen1_oracle.sql b/tests/test_sql_refsols/defog_academic_gen1_oracle.sql new file mode 100644 index 000000000..1b959360c --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen1_oracle.sql @@ -0,0 +1,18 @@ +WITH _T0 AS ( + SELECT + WRITES.aid AS AID, + COUNT(DISTINCT DOMAIN_PUBLICATION.did) AS NDISTINCT_DID + FROM MAIN.WRITES WRITES + JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid + JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did + AND DOMAIN.name IN ('Data Science', 'Machine Learning') + GROUP BY + WRITES.aid +) +SELECT + AUTHOR.name +FROM MAIN.AUTHOR AUTHOR +JOIN _T0 _T0 + ON AUTHOR.aid = _T0.AID AND _T0.NDISTINCT_DID = 2 diff --git a/tests/test_sql_refsols/defog_academic_gen20_oracle.sql b/tests/test_sql_refsols/defog_academic_gen20_oracle.sql new file mode 100644 index 000000000..4db5a69e3 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen20_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS n +FROM MAIN.PUBLICATION PUBLICATION +JOIN MAIN.JOURNAL JOURNAL + ON JOURNAL.jid = PUBLICATION.jid AND LOWER(JOURNAL.name) LIKE 'j%' diff --git a/tests/test_sql_refsols/defog_academic_gen21_oracle.sql b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql new file mode 100644 index 000000000..aa793bf3f --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql @@ -0,0 +1,12 @@ +SELECT + ORGANIZATION.name AS oranization_name, + ORGANIZATION.oid AS organization_id +FROM MAIN.ORGANIZATION ORGANIZATION +JOIN MAIN.AUTHOR AUTHOR + ON AUTHOR.oid = ORGANIZATION.oid +JOIN MAIN.WRITES WRITES + ON AUTHOR.aid = WRITES.aid +JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid +JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did AND DOMAIN.name = 'Machine Learning' diff --git a/tests/test_sql_refsols/defog_academic_gen22_oracle.sql b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql new file mode 100644 index 000000000..033908e18 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql @@ -0,0 +1,16 @@ +WITH _S0 AS ( + SELECT + aid AS AID, + did AS DID + FROM MAIN.DOMAIN_AUTHOR +) +SELECT + AUTHOR.name, + AUTHOR.aid AS author_id +FROM MAIN.AUTHOR AUTHOR +JOIN _S0 _S0 + ON AUTHOR.aid = _S0.AID +JOIN _S0 _S1 + ON _S0.DID = _S1.DID +JOIN MAIN.AUTHOR AUTHOR_2 + ON AUTHOR_2.aid = _S1.AID AND LOWER(AUTHOR_2.name) LIKE '%martin%' diff --git a/tests/test_sql_refsols/defog_academic_gen23_oracle.sql b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql new file mode 100644 index 000000000..56dd99741 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql @@ -0,0 +1,6 @@ +SELECT + AUTHOR.name, + AUTHOR.aid AS author_id +FROM MAIN.AUTHOR AUTHOR +JOIN MAIN.ORGANIZATION ORGANIZATION + ON AUTHOR.oid = ORGANIZATION.oid diff --git a/tests/test_sql_refsols/defog_academic_gen24_oracle.sql b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql new file mode 100644 index 000000000..271916517 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql @@ -0,0 +1,19 @@ +WITH _S7 AS ( + SELECT + DOMAIN_CONFERENCE.cid AS CID, + WRITES.pid AS PID + FROM MAIN.WRITES WRITES + JOIN MAIN.DOMAIN_AUTHOR DOMAIN_AUTHOR + ON DOMAIN_AUTHOR.aid = WRITES.aid + JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_AUTHOR.did AND LOWER(DOMAIN.name) LIKE '%sociology%' + JOIN MAIN.DOMAIN_CONFERENCE DOMAIN_CONFERENCE + ON DOMAIN.did = DOMAIN_CONFERENCE.did +) +SELECT + PUBLICATION.title +FROM MAIN.PUBLICATION PUBLICATION +JOIN _S7 _S7 + ON PUBLICATION.cid = _S7.CID AND PUBLICATION.pid = _S7.PID +WHERE + PUBLICATION.year = 2020 diff --git a/tests/test_sql_refsols/defog_academic_gen25_oracle.sql b/tests/test_sql_refsols/defog_academic_gen25_oracle.sql new file mode 100644 index 000000000..4ed17f9f9 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen25_oracle.sql @@ -0,0 +1,9 @@ +SELECT DISTINCT + AUTHOR.name AS author_name +FROM MAIN.AUTHOR AUTHOR +JOIN MAIN.WRITES WRITES + ON AUTHOR.aid = WRITES.aid +JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid +JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did AND DOMAIN.name = 'Computer Science' diff --git a/tests/test_sql_refsols/defog_academic_gen2_oracle.sql b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql new file mode 100644 index 000000000..064538245 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql @@ -0,0 +1,16 @@ +WITH _S3 AS ( + SELECT + WRITES.aid AS AID, + SUM(PUBLICATION.citation_num) AS SUM_CITATION_NUM + FROM MAIN.WRITES WRITES + JOIN MAIN.PUBLICATION PUBLICATION + ON PUBLICATION.pid = WRITES.pid + GROUP BY + WRITES.aid +) +SELECT + AUTHOR.name, + NVL(_S3.SUM_CITATION_NUM, 0) AS total_citations +FROM MAIN.AUTHOR AUTHOR +JOIN _S3 _S3 + ON AUTHOR.aid = _S3.AID diff --git a/tests/test_sql_refsols/defog_academic_gen3_oracle.sql b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql new file mode 100644 index 000000000..c60cca3b1 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql @@ -0,0 +1,6 @@ +SELECT + year, + COUNT(*) AS _expr0 +FROM MAIN.PUBLICATION +GROUP BY + year diff --git a/tests/test_sql_refsols/defog_academic_gen4_oracle.sql b/tests/test_sql_refsols/defog_academic_gen4_oracle.sql new file mode 100644 index 000000000..3cc9a35e2 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen4_oracle.sql @@ -0,0 +1,16 @@ +WITH _S3 AS ( + SELECT + DOMAIN_PUBLICATION.did AS DID, + AVG(PUBLICATION.reference_num) AS AVG_REFERENCE_NUM + FROM MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + JOIN MAIN.PUBLICATION PUBLICATION + ON DOMAIN_PUBLICATION.pid = PUBLICATION.pid + GROUP BY + DOMAIN_PUBLICATION.did +) +SELECT + DOMAIN.name, + _S3.AVG_REFERENCE_NUM AS average_references +FROM MAIN.DOMAIN DOMAIN +LEFT JOIN _S3 _S3 + ON DOMAIN.did = _S3.DID diff --git a/tests/test_sql_refsols/defog_academic_gen5_oracle.sql b/tests/test_sql_refsols/defog_academic_gen5_oracle.sql new file mode 100644 index 000000000..e8d9e4f86 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen5_oracle.sql @@ -0,0 +1,6 @@ +SELECT + year, + AVG(citation_num) AS average_citations +FROM MAIN.PUBLICATION +GROUP BY + year diff --git a/tests/test_sql_refsols/defog_academic_gen6_oracle.sql b/tests/test_sql_refsols/defog_academic_gen6_oracle.sql new file mode 100644 index 000000000..3cf8c207f --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen6_oracle.sql @@ -0,0 +1,6 @@ +SELECT + title +FROM MAIN.PUBLICATION +ORDER BY + citation_num DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen7_oracle.sql b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql new file mode 100644 index 000000000..773797334 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + did AS DID, + COUNT(DISTINCT aid) AS NDISTINCT_AID + FROM MAIN.DOMAIN_AUTHOR + GROUP BY + did +) +SELECT + DOMAIN.name, + NVL(_S1.NDISTINCT_AID, 0) AS author_count +FROM MAIN.DOMAIN DOMAIN +LEFT JOIN _S1 _S1 + ON DOMAIN.did = _S1.DID +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen8_oracle.sql b/tests/test_sql_refsols/defog_academic_gen8_oracle.sql new file mode 100644 index 000000000..2f0e61a30 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen8_oracle.sql @@ -0,0 +1,6 @@ +SELECT + title +FROM MAIN.PUBLICATION +ORDER BY + reference_num DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen9_oracle.sql b/tests/test_sql_refsols/defog_academic_gen9_oracle.sql new file mode 100644 index 000000000..82e0c97fa --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen9_oracle.sql @@ -0,0 +1,7 @@ +SELECT + title, + citation_num +FROM MAIN.PUBLICATION +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv10_oracle.sql b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql new file mode 100644 index 000000000..0d4d5f38e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) AS MONTH_SBTXDATETIME, + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) AS YEAR_SBTXDATETIME, + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + GROUP BY + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)), + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)), + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustname AS name, + NVL(_S1.N_ROWS, 0) AS num_transactions +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID + AND _S1.MONTH_SBTXDATETIME = EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) + AND _S1.YEAR_SBTXDATETIME = EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv11_oracle.sql b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql new file mode 100644 index 000000000..3a46a6f5e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n_customers +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickersymbol IN ('AMZN', 'AAPL', 'GOOGL', 'META', 'NFLX') +WHERE + SBCUSTOMER.sbcustemail LIKE '%.com' diff --git a/tests/test_sql_refsols/defog_broker_adv12_oracle.sql b/tests/test_sql_refsols/defog_broker_adv12_oracle.sql new file mode 100644 index 000000000..8838d355a --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv12_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNT(*) AS n_customers +FROM MAIN.SBCUSTOMER +WHERE + ( + LOWER(sbcustname) LIKE '%ez' OR LOWER(sbcustname) LIKE 'j%' + ) + AND LOWER(sbcuststate) LIKE '%a' diff --git a/tests/test_sql_refsols/defog_broker_adv13_oracle.sql b/tests/test_sql_refsols/defog_broker_adv13_oracle.sql new file mode 100644 index 000000000..6173b1741 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv13_oracle.sql @@ -0,0 +1,8 @@ +SELECT + sbcustcountry AS cust_country, + COUNT(*) AS TAC +FROM MAIN.SBCUSTOMER +WHERE + sbcustjoindate >= TO_DATE('2023-01-01', 'YYYY-MM-DD') +GROUP BY + sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql new file mode 100644 index 000000000..1759f243b --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + sbdptickerid AS SBDPTICKERID, + COUNT(sbdpclose) AS COUNT_SBDPCLOSE, + SUM(sbdpclose) AS SUM_SBDPCLOSE + FROM MAIN.SBDAILYPRICE + WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sbdpdate AS DATETIME), DAY) <= 7 + GROUP BY + sbdptickerid +) +SELECT + SBTICKER.sbtickertype AS ticker_type, + SUM(_S1.SUM_SBDPCLOSE) / SUM(_S1.COUNT_SBDPCLOSE) AS ACP +FROM MAIN.SBTICKER SBTICKER +JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBDPTICKERID +GROUP BY + SBTICKER.sbtickertype diff --git a/tests/test_sql_refsols/defog_broker_adv15_oracle.sql b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql new file mode 100644 index 000000000..e1cebfb27 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql @@ -0,0 +1,10 @@ +SELECT + sbcustcountry AS country, + 100 * ( + NVL(SUM(sbcuststatus = 'active'), 0) / COUNT(*) + ) AS ar +FROM MAIN.SBCUSTOMER +WHERE + sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' +GROUP BY + sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql new file mode 100644 index 000000000..4260360a9 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -0,0 +1,23 @@ +WITH _S1 AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + SUM(sbtxtax + sbtxcommission) AS SUM_EXPR, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH) AND sbtxtype = 'sell' + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + ( + 100.0 * ( + NVL(_S1.SUM_SBTXAMOUNT, 0) - NVL(_S1.SUM_EXPR, 0) + ) + ) / NVL(_S1.SUM_SBTXAMOUNT, 0) AS SPM +FROM MAIN.SBTICKER SBTICKER +JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_broker_adv1_oracle.sql b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql new file mode 100644 index 000000000..c24b8cb5d --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustname AS name, + NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql new file mode 100644 index 000000000..2f4a3b8ff --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 10, DAY), 'DAY') + AND sbtxtype = 'buy' + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + NVL(_S1.N_ROWS, 0) AS tx_count +FROM MAIN.SBTICKER SBTICKER +LEFT JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv3_oracle.sql b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql new file mode 100644 index 000000000..7cb8a51f8 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql @@ -0,0 +1,19 @@ +WITH _T1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS, + SUM(sbtxstatus = 'success') AS SUM_EXPR + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustname AS name, + ( + 100.0 * NVL(_T1.SUM_EXPR, 0) + ) / _T1.N_ROWS AS success_rate +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN _T1 _T1 + ON SBCUSTOMER.sbcustid = _T1.SBTXCUSTID AND _T1.N_ROWS >= 5 +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_broker_adv4_oracle.sql b/tests/test_sql_refsols/defog_broker_adv4_oracle.sql new file mode 100644 index 000000000..ddeb351a6 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv4_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + sbdptickerid AS SBDPTICKERID, + MAX(sbdphigh) AS MAX_SBDPHIGH, + MIN(sbdplow) AS MIN_SBDPLOW + FROM MAIN.SBDAILYPRICE + WHERE + sbdpdate <= TO_DATE('2023-04-04', 'YYYY-MM-DD') + AND sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') + GROUP BY + sbdptickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + _S1.MAX_SBDPHIGH - _S1.MIN_SBDPLOW AS price_change +FROM MAIN.SBTICKER SBTICKER +LEFT JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBDPTICKERID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql new file mode 100644 index 000000000..377b1212f --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql @@ -0,0 +1,59 @@ +WITH _S0 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbdpdate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))), ( + 2 * -1 + )) + END + ) AS MONTH, + sbdptickerid AS SBDPTICKERID, + COUNT(sbdpclose) AS COUNT_SBDPCLOSE, + MAX(sbdphigh) AS MAX_SBDPHIGH, + MIN(sbdplow) AS MIN_SBDPLOW, + SUM(sbdpclose) AS SUM_SBDPCLOSE + FROM MAIN.SBDAILYPRICE + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbdpdate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))), ( + 2 * -1 + )) + END + ), + sbdptickerid +), _T0 AS ( + SELECT + _S0.MONTH, + SBTICKER.sbtickersymbol AS SBTICKERSYMBOL, + MAX(_S0.MAX_SBDPHIGH) AS MAX_MAX_SBDPHIGH, + MIN(_S0.MIN_SBDPLOW) AS MIN_MIN_SBDPLOW, + SUM(_S0.COUNT_SBDPCLOSE) AS SUM_COUNT_SBDPCLOSE, + SUM(_S0.SUM_SBDPCLOSE) AS SUM_SUM_SBDPCLOSE + FROM _S0 _S0 + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = _S0.SBDPTICKERID + GROUP BY + _S0.MONTH, + SBTICKER.sbtickersymbol +) +SELECT + SBTICKERSYMBOL AS symbol, + MONTH AS month, + SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE AS avg_close, + MAX_MAX_SBDPHIGH AS max_high, + MIN_MIN_SBDPLOW AS min_low, + ( + ( + SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE + ) - LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) + ) / LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) AS momc +FROM _T0 diff --git a/tests/test_sql_refsols/defog_broker_adv6_oracle.sql b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql new file mode 100644 index 000000000..439f89fb9 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustname AS name, + _S1.N_ROWS AS num_tx, + NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount, + RANK() OVER (ORDER BY NVL(_S1.SUM_SBTXAMOUNT, 0) DESC) AS cust_rank +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql new file mode 100644 index 000000000..68fecfd7b --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -0,0 +1,78 @@ +WITH _S2 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))), ( + 2 * -1 + )) + END + ) AS MONTH, + COUNT(*) AS N_ROWS + FROM MAIN.SBCUSTOMER + WHERE + sbcustjoindate < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'MONTH') + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))), ( + 2 * -1 + )) + END + ) +), _S3 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) AS MONTH, + AVG(SBTRANSACTION.sbtxamount) AS AVG_SBTXAMOUNT + FROM MAIN.SBCUSTOMER SBCUSTOMER + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) = EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) + AND EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) = EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) + AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + WHERE + SBCUSTOMER.sbcustjoindate < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'MONTH') + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) +) +SELECT + _S2.MONTH AS month, + _S2.N_ROWS AS customer_signups, + _S3.AVG_SBTXAMOUNT AS avg_tx_amount +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.MONTH = _S3.MONTH diff --git a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql new file mode 100644 index 000000000..a124a5926 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql @@ -0,0 +1,10 @@ +SELECT + NULLIF(COUNT(*), 0) AS n_transactions, + NVL(SUM(SBTRANSACTION.sbtxamount), 0) AS total_amount +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON LOWER(SBCUSTOMER.sbcustcountry) = 'usa' + AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid +WHERE + SBTRANSACTION.sbtxdatetime < TRUNC(CURRENT_TIMESTAMP, 'WEEK') + AND SBTRANSACTION.sbtxdatetime >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 1, WEEK) diff --git a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql new file mode 100644 index 000000000..f1247db1e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql @@ -0,0 +1,20 @@ +SELECT + TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') AS week, + COUNT(*) AS num_transactions, + NVL( + SUM(( + MOD(( + DAY_OF_WEEK(SBTRANSACTION.sbtxdatetime) + 6 + ), 7) + ) IN (5, 6)), + 0 + ) AS weekend_transactions +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickertype = 'stock' +WHERE + SBTRANSACTION.sbtxdatetime < TRUNC(CURRENT_TIMESTAMP, 'WEEK') + AND SBTRANSACTION.sbtxdatetime >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 8, WEEK) +GROUP BY + TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_broker_basic10_oracle.sql b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql new file mode 100644 index 000000000..28dcbe3a8 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql @@ -0,0 +1,6 @@ +SELECT + SBTICKER.sbtickerid AS _id, + SBTICKER.sbtickersymbol AS symbol +FROM MAIN.SBTICKER SBTICKER +JOIN MAIN.SBDAILYPRICE SBDAILYPRICE + ON SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid diff --git a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql new file mode 100644 index 000000000..ef3b58c45 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 30, DAY), 'DAY') + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustcountry AS country, + NVL(SUM(_S1.N_ROWS), 0) AS num_transactions, + NVL(SUM(_S1.SUM_SBTXAMOUNT), 0) AS total_amount +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +GROUP BY + SBCUSTOMER.sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_basic2_oracle.sql b/tests/test_sql_refsols/defog_broker_basic2_oracle.sql new file mode 100644 index 000000000..6f963cb54 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic2_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxtype AS transaction_type, + COUNT(DISTINCT sbtxcustid) AS num_customers, + AVG(sbtxshares) AS avg_shares +FROM MAIN.SBTRANSACTION +WHERE + sbtxdatetime <= TO_DATE('2023-03-31', 'YYYY-MM-DD') + AND sbtxdatetime >= TO_DATE('2023-01-01', 'YYYY-MM-DD') +GROUP BY + sbtxtype +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic3_oracle.sql b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql new file mode 100644 index 000000000..43686a8c6 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + COUNT(*) AS N_ROWS, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + NVL(_S1.N_ROWS, 0) AS num_transactions, + NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount +FROM MAIN.SBTICKER SBTICKER +LEFT JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic4_oracle.sql b/tests/test_sql_refsols/defog_broker_basic4_oracle.sql new file mode 100644 index 000000000..f393e80a3 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic4_oracle.sql @@ -0,0 +1,34 @@ +WITH _S0 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + sbtxtickerid AS SBTXTICKERID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid, + sbtxtickerid +), _S2 AS ( + SELECT + SBTICKER.sbtickertype AS SBTICKERTYPE, + _S0.SBTXCUSTID, + SUM(_S0.N_ROWS) AS SUM_N_ROWS + FROM _S0 _S0 + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = _S0.SBTXTICKERID + GROUP BY + SBTICKER.sbtickertype, + _S0.SBTXCUSTID +) +SELECT + SBCUSTOMER.sbcuststate AS state, + _S2.SBTICKERTYPE AS ticker_type, + SUM(_S2.SUM_N_ROWS) AS num_transactions +FROM _S2 _S2 +JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = _S2.SBTXCUSTID +GROUP BY + SBCUSTOMER.sbcuststate, + _S2.SBTICKERTYPE +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic5_oracle.sql b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql new file mode 100644 index 000000000..aae7e245d --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql @@ -0,0 +1,5 @@ +SELECT + SBCUSTOMER.sbcustid AS _id +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid AND SBTRANSACTION.sbtxtype = 'buy' diff --git a/tests/test_sql_refsols/defog_broker_basic6_oracle.sql b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql new file mode 100644 index 000000000..40f0b5e9d --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql @@ -0,0 +1,6 @@ +SELECT + SBTICKER.sbtickerid AS _id +FROM MAIN.SBTICKER SBTICKER +JOIN MAIN.SBDAILYPRICE SBDAILYPRICE + ON SBDAILYPRICE.sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') + AND SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid diff --git a/tests/test_sql_refsols/defog_broker_basic7_oracle.sql b/tests/test_sql_refsols/defog_broker_basic7_oracle.sql new file mode 100644 index 000000000..2ff35b8be --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic7_oracle.sql @@ -0,0 +1,9 @@ +SELECT + sbtxstatus AS status, + COUNT(*) AS num_transactions +FROM MAIN.SBTRANSACTION +GROUP BY + sbtxstatus +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic8_oracle.sql b/tests/test_sql_refsols/defog_broker_basic8_oracle.sql new file mode 100644 index 000000000..bc7fec654 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic8_oracle.sql @@ -0,0 +1,9 @@ +SELECT + sbcustcountry AS country, + COUNT(*) AS num_customers +FROM MAIN.SBCUSTOMER +GROUP BY + sbcustcountry +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic9_oracle.sql b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql new file mode 100644 index 000000000..7467ecb95 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql @@ -0,0 +1,6 @@ +SELECT + SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustname AS name +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid diff --git a/tests/test_sql_refsols/defog_broker_gen1_oracle.sql b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql new file mode 100644 index 000000000..fc5ae4c8e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql @@ -0,0 +1,8 @@ +SELECT + MIN(SBDAILYPRICE.sbdpclose) AS lowest_price +FROM MAIN.SBDAILYPRICE SBDAILYPRICE +JOIN MAIN.SBTICKER SBTICKER + ON SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid + AND SBTICKER.sbtickersymbol = 'VTI' +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(SBDAILYPRICE.sbdpdate AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql new file mode 100644 index 000000000..b2e6fa910 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql @@ -0,0 +1,6 @@ +SELECT + COUNT(*) AS transaction_count +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + AND SBCUSTOMER.sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 70, DAY), 'DAY') diff --git a/tests/test_sql_refsols/defog_broker_gen3_oracle.sql b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql new file mode 100644 index 000000000..ff2528e48 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + MIN(sbtxdatetime) AS MIN_SBTXDATETIME + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS cust_id, + DATEDIFF( + CAST(_S1.MIN_SBTXDATETIME AS DATETIME), + CAST(SBCUSTOMER.sbcustjoindate AS DATETIME), + SECOND + ) / 86400.0 AS DaysFromJoinToFirstTransaction +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql new file mode 100644 index 000000000..5ecfd9079 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + WHERE + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY') = TO_DATE('2023-04-01', 'YYYY-MM-DD') + AND sbtxtype = 'sell' + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustname AS name, + NVL(_S1.N_ROWS, 0) AS num_tx +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_gen5_oracle.sql b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql new file mode 100644 index 000000000..59c8567b5 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql @@ -0,0 +1,12 @@ +SELECT + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') AS month, + AVG(sbtxprice) AS avg_price +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) IN (1, 2, 3) + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + AND sbtxstatus = 'success' +GROUP BY + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql new file mode 100644 index 000000000..e4c217050 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + sale_id AS SALE_ID, + MAX(payment_date) AS MAX_PAYMENT_DATE + FROM MAIN.PAYMENTS_RECEIVED + GROUP BY + sale_id +) +SELECT + ROUND( + AVG( + DATEDIFF(CAST(_S1.MAX_PAYMENT_DATE AS DATETIME), CAST(SALES.sale_date AS DATETIME), DAY) + ), + 2 + ) AS avg_days_to_payment +FROM MAIN.SALES SALES +LEFT JOIN _S1 _S1 + ON SALES._id = _S1.SALE_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql new file mode 100644 index 000000000..4a8dfc7de --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql @@ -0,0 +1,19 @@ +WITH _S0 AS ( + SELECT + car_id AS CAR_ID, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + EXTRACT(YEAR FROM CAST(sale_date AS DATETIME)) = 2023 + GROUP BY + car_id +) +SELECT + ( + ( + NVL(SUM(_S0.SUM_SALE_PRICE), 0) - NVL(SUM(CARS.cost), 0) + ) / NVL(SUM(CARS.cost), 0) + ) * 100 AS GPM +FROM _S0 _S0 +JOIN MAIN.CARS CARS + ON CARS._id = _S0.CAR_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql new file mode 100644 index 000000000..061b61a35 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql @@ -0,0 +1,14 @@ +SELECT + CARS.make, + CARS.model, + SALES.sale_price +FROM MAIN.SALES SALES +JOIN MAIN.CARS CARS + ON CARS._id = SALES.car_id +JOIN MAIN.INVENTORY_SNAPSHOTS INVENTORY_SNAPSHOTS + ON CARS._id = INVENTORY_SNAPSHOTS.car_id + AND INVENTORY_SNAPSHOTS.snapshot_date = SALES.sale_date + AND NOT INVENTORY_SNAPSHOTS.is_in_inventory +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql new file mode 100644 index 000000000..35e025121 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS TSC +FROM MAIN.SALES +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql new file mode 100644 index 000000000..52c71ad39 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + AVG(sale_price) AS AVG_SALE_PRICE + FROM MAIN.SALES + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + _S1.AVG_SALE_PRICE AS ASP +FROM MAIN.SALESPERSONS SALESPERSONS +LEFT JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql new file mode 100644 index 000000000..b0798c8a8 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS._id, + SALESPERSONS.first_name, + SALESPERSONS.last_name, + NVL(_S1.SUM_SALE_PRICE, 0) AS total +FROM MAIN.SALESPERSONS SALESPERSONS +LEFT JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql new file mode 100644 index 000000000..e310104b3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -0,0 +1,21 @@ +SELECT + TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') AS payment_week, + COUNT(*) AS total_payments, + NVL( + SUM( + ( + MOD(( + DAY_OF_WEEK(PAYMENTS_RECEIVED.payment_date) + 6 + ), 7) + ) IN (5, 6) + ), + 0 + ) AS weekend_payments +FROM MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED +JOIN MAIN.SALES SALES + ON PAYMENTS_RECEIVED.sale_id = SALES._id AND SALES.sale_price > 30000 +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) <= 8 + AND DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) >= 1 +GROUP BY + TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql new file mode 100644 index 000000000..103486c61 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS + FROM MAIN.SALES + WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 30 + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS._id, + SALESPERSONS.first_name, + SALESPERSONS.last_name, + _S1.N_ROWS AS num_sales +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 4 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql new file mode 100644 index 000000000..b2be4d80b --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql @@ -0,0 +1,21 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(CARS.make) AS ANYTHING_MAKE, + ANY_VALUE(CARS.model) AS ANYTHING_MODEL, + COUNT(SALES.car_id) AS COUNT_CAR_ID + FROM MAIN.CARS CARS + LEFT JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id + WHERE + LOWER(CARS.vin_number) LIKE '%m5%' + GROUP BY + CARS._id +) +SELECT + ANYTHING_MAKE AS make, + ANYTHING_MODEL AS model, + NVL(SUM(COUNT_CAR_ID), 0) AS num_sales +FROM _T1 +GROUP BY + ANYTHING_MAKE, + ANYTHING_MODEL diff --git a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql new file mode 100644 index 000000000..822289164 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql @@ -0,0 +1,9 @@ +SELECT + COUNT(*) AS num_sales, + CASE WHEN COUNT(*) <> 0 THEN NVL(SUM(SALES.sale_price), 0) ELSE NULL END AS total_revenue +FROM MAIN.CARS CARS +JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id + AND SALES.sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 30, DAY) +WHERE + LOWER(CARS.make) LIKE '%toyota%' diff --git a/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql new file mode 100644 index 000000000..e4a4a4f4a --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_sales, + _S1.N_ROWS AS num_sales, + RANK() OVER (ORDER BY NVL(_S1.SUM_SALE_PRICE, 0) DESC) AS sales_rank +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql new file mode 100644 index 000000000..f117716b5 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql @@ -0,0 +1,20 @@ +WITH _T AS ( + SELECT + car_id AS CAR_ID, + is_in_inventory AS IS_IN_INVENTORY, + ROW_NUMBER() OVER (PARTITION BY car_id ORDER BY snapshot_date DESC) AS _W + FROM MAIN.INVENTORY_SNAPSHOTS +) +SELECT + ANY_VALUE(CARS.make) AS make, + ANY_VALUE(CARS.model) AS model, + MAX(SALES.sale_price) AS highest_sale_price +FROM MAIN.CARS CARS +JOIN _T _T + ON CARS._id = _T.CAR_ID AND NOT _T.IS_IN_INVENTORY AND _T._W = 1 +LEFT JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id +GROUP BY + CARS._id +ORDER BY + 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql new file mode 100644 index 000000000..8da3ad13a --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + car_id AS CAR_ID, + AVG(sale_price) AS AVG_SALE_PRICE + FROM MAIN.SALES + GROUP BY + car_id +) +SELECT + CARS.make, + CARS.model, + CARS.year, + CARS.color, + CARS.vin_number, + _S1.AVG_SALE_PRICE AS avg_sale_price +FROM MAIN.CARS CARS +LEFT JOIN _S1 _S1 + ON CARS._id = _S1.CAR_ID +WHERE + LOWER(CARS.make) LIKE '%fords%' OR LOWER(CARS.model) LIKE '%mustang%' diff --git a/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql new file mode 100644 index 000000000..ffee74ac5 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(sale_price) AS ASP +FROM MAIN.SALES +WHERE + sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' diff --git a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql new file mode 100644 index 000000000..5d5532a4b --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql @@ -0,0 +1,22 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 3, MONTH) + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + NVL(_S1.N_ROWS, 0) AS total_sales, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue +FROM MAIN.SALESPERSONS SALESPERSONS +LEFT JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql new file mode 100644 index 000000000..309996ad3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql @@ -0,0 +1,8 @@ +SELECT + CARS._id, + CARS.make, + CARS.model, + CARS.year +FROM MAIN.CARS CARS +JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id diff --git a/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql new file mode 100644 index 000000000..78f8ce95e --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql @@ -0,0 +1,5 @@ +SELECT + CUSTOMERS._id +FROM MAIN.CUSTOMERS CUSTOMERS +JOIN MAIN.SALES SALES + ON CUSTOMERS._id = SALES.customer_id diff --git a/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql new file mode 100644 index 000000000..01e3e7313 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql @@ -0,0 +1,8 @@ +SELECT + SALESPERSONS._id AS salesperson_id +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN MAIN.SALES SALES + ON SALES.salesperson_id = SALESPERSONS._id +JOIN MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED + ON PAYMENTS_RECEIVED.payment_method = 'cash' + AND PAYMENTS_RECEIVED.sale_id = SALES._id diff --git a/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql new file mode 100644 index 000000000..ca96da0e3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql @@ -0,0 +1,7 @@ +SELECT + SALESPERSONS._id, + SALESPERSONS.first_name, + SALESPERSONS.last_name +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN MAIN.SALES SALES + ON SALES.salesperson_id = SALESPERSONS._id diff --git a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql new file mode 100644 index 000000000..81e9bacc8 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql @@ -0,0 +1,22 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 30 + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + _S1.N_ROWS AS total_sales, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql new file mode 100644 index 000000000..c837e2702 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql @@ -0,0 +1,12 @@ +SELECT + CUSTOMERS.state, + COUNT(DISTINCT SALES.customer_id) AS unique_customers, + NVL(SUM(SALES.sale_price), 0) AS total_revenue +FROM MAIN.SALES SALES +JOIN MAIN.CUSTOMERS CUSTOMERS + ON CUSTOMERS._id = SALES.customer_id +GROUP BY + CUSTOMERS.state +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql new file mode 100644 index 000000000..fa57bcc72 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql @@ -0,0 +1,10 @@ +SELECT + payment_method, + COUNT(*) AS total_payments, + NVL(SUM(payment_amount), 0) AS total_amount +FROM MAIN.PAYMENTS_RECEIVED +GROUP BY + payment_method +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql new file mode 100644 index 000000000..51b30b8f3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + car_id AS CAR_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + GROUP BY + car_id +) +SELECT + CARS.make, + CARS.model, + NVL(_S1.N_ROWS, 0) AS total_sales, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue +FROM MAIN.CARS CARS +LEFT JOIN _S1 _S1 + ON CARS._id = _S1.CAR_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic9_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic9_oracle.sql new file mode 100644 index 000000000..f0051b3fd --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic9_oracle.sql @@ -0,0 +1,9 @@ +SELECT + state, + COUNT(*) AS total_signups +FROM MAIN.CUSTOMERS +GROUP BY + state +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql new file mode 100644 index 000000000..99d0ee519 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql @@ -0,0 +1,11 @@ +SELECT + first_name, + last_name, + phone, + DATEDIFF(CAST(termination_date AS DATETIME), CAST(hire_date AS DATETIME), DAY) AS days_employed +FROM MAIN.SALESPERSONS +WHERE + NOT termination_date IS NULL +ORDER BY + 4 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql new file mode 100644 index 000000000..8cff8f98f --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS weekend_payments +FROM MAIN.PAYMENTS_MADE +WHERE + ( + MOD(( + DAY_OF_WEEK(payment_date) + 6 + ), 7) + ) IN (5, 6) + AND vendor_name = 'Utility Company' diff --git a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql new file mode 100644 index 000000000..32befecca --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql @@ -0,0 +1,13 @@ +SELECT + payment_date, + payment_method, + NVL(SUM(payment_amount), 0) AS total_amount +FROM MAIN.PAYMENTS_RECEIVED +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(payment_date AS DATETIME), WEEK) = 1 +GROUP BY + payment_date, + payment_method +ORDER BY + 1 DESC NULLS LAST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql new file mode 100644 index 000000000..93b1b0f57 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -0,0 +1,33 @@ +WITH _S0 AS ( + SELECT + TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER') AS QUARTER, + customer_id AS CUSTOMER_ID, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + EXTRACT(YEAR FROM CAST(sale_date AS DATETIME)) = 2023 + GROUP BY + TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER'), + customer_id +), _T1 AS ( + SELECT + _S0.QUARTER, + CUSTOMERS.state AS STATE, + SUM(_S0.SUM_SALE_PRICE) AS SUM_SUM_SALE_PRICE + FROM _S0 _S0 + JOIN MAIN.CUSTOMERS CUSTOMERS + ON CUSTOMERS._id = _S0.CUSTOMER_ID + GROUP BY + _S0.QUARTER, + CUSTOMERS.state +) +SELECT + QUARTER AS quarter, + STATE AS customer_state, + SUM_SUM_SALE_PRICE AS total_sales +FROM _T1 +WHERE + NOT SUM_SUM_SALE_PRICE IS NULL AND SUM_SUM_SALE_PRICE > 0 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql new file mode 100644 index 000000000..e341242df --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql @@ -0,0 +1,20 @@ +WITH _T AS ( + SELECT + car_id AS CAR_ID, + is_in_inventory AS IS_IN_INVENTORY, + RANK() OVER (ORDER BY snapshot_date DESC) AS _W + FROM MAIN.INVENTORY_SNAPSHOTS + WHERE + EXTRACT(MONTH FROM CAST(snapshot_date AS DATETIME)) = 3 + AND EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 +) +SELECT + CARS._id, + CARS.make, + CARS.model, + CARS.year +FROM _T _T +JOIN MAIN.CARS CARS + ON CARS._id = _T.CAR_ID +WHERE + _T.IS_IN_INVENTORY AND _T._W = 1 diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql new file mode 100644 index 000000000..54abc90be --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql @@ -0,0 +1,21 @@ +WITH _S3 AS ( + SELECT + TREATMENTS.drug_id AS DRUG_ID, + COUNT(*) AS N_ROWS + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.ADVERSE_EVENTS ADVERSE_EVENTS + ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id + AND TRUNC(CAST(ADVERSE_EVENTS.reported_dt AS TIMESTAMP), 'MONTH') = TRUNC(CAST(TREATMENTS.start_dt AS TIMESTAMP), 'MONTH') + GROUP BY + TREATMENTS.drug_id +) +SELECT + DRUGS.drug_id, + DRUGS.drug_name, + _S3.N_ROWS AS num_adverse_events +FROM MAIN.DRUGS DRUGS +JOIN _S3 _S3 + ON DRUGS.drug_id = _S3.DRUG_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql new file mode 100644 index 000000000..0dcf91911 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS num_patients_with_gmail_or_yahoo +FROM MAIN.PATIENTS +WHERE + email LIKE '%@gmail.com' OR email LIKE '%@yahoo.com' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql new file mode 100644 index 000000000..7eca7d159 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql @@ -0,0 +1,7 @@ +SELECT + first_name, + last_name, + specialty +FROM MAIN.DOCTORS +WHERE + LOWER(first_name) LIKE 'j%' OR LOWER(last_name) LIKE '%son%' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql new file mode 100644 index 000000000..f63887b27 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS PIC_female +FROM MAIN.PATIENTS +WHERE + gender = 'Female' AND ins_type = 'private' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql new file mode 100644 index 000000000..482c93660 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(weight_kg) AS CAW_male +FROM MAIN.PATIENTS +WHERE + gender = 'Male' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql new file mode 100644 index 000000000..52bc4e847 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -0,0 +1,20 @@ +WITH _S3 AS ( + SELECT + drug_id AS DRUG_ID, + AVG( + tot_drug_amt / DATEDIFF(CAST(end_dt AS DATETIME), CAST(start_dt AS DATETIME), DAY) + ) AS AVG_DDD + FROM MAIN.TREATMENTS + WHERE + NOT end_dt IS NULL + GROUP BY + drug_id +) +SELECT + DRUGS.drug_name, + _S3.AVG_DDD AS avg_ddd +FROM MAIN.DRUGS DRUGS +JOIN MAIN.TREATMENTS TREATMENTS + ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT TREATMENTS.end_dt IS NULL +LEFT JOIN _S3 _S3 + ON DRUGS.drug_id = _S3.DRUG_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql new file mode 100644 index 000000000..15c5a4d0b --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql @@ -0,0 +1,9 @@ +SELECT + ( + ( + AVG(day100_pasi_score) - AVG(day7_pasi_score) + ) / AVG(day7_pasi_score) + ) * 100 AS d7d100pir +FROM MAIN.OUTCOMES +WHERE + NOT day100_pasi_score IS NULL AND NOT day7_pasi_score IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql new file mode 100644 index 000000000..78e84803c --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql @@ -0,0 +1,7 @@ +SELECT DISTINCT + DOCTORS.loc_state AS state +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'biologic' +JOIN MAIN.DOCTORS DOCTORS + ON DOCTORS.doc_id = TREATMENTS.doc_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql new file mode 100644 index 000000000..58f79825c --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql @@ -0,0 +1,7 @@ +SELECT + AVG(PATIENTS.weight_kg) AS avg_weight +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND LOWER(DRUGS.drug_name) = 'drugalin' +JOIN MAIN.PATIENTS PATIENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql new file mode 100644 index 000000000..9c576f138 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ADVERSE_EVENTS.description, + ADVERSE_EVENTS.treatment_id, + DRUGS.drug_id, + DRUGS.drug_name +FROM MAIN.ADVERSE_EVENTS ADVERSE_EVENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'topical' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql new file mode 100644 index 000000000..53e8a3e3d --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS patient_count +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id +JOIN MAIN.DIAGNOSES DIAGNOSES + ON DIAGNOSES.diag_id = TREATMENTS.diag_id + AND LOWER(DIAGNOSES.diag_name) = 'psoriasis vulgaris' +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND LOWER(DRUGS.drug_type) = 'biologic' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql new file mode 100644 index 000000000..bf0356723 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql @@ -0,0 +1,31 @@ +WITH _T1 AS ( + SELECT + MIN(EXTRACT(YEAR FROM CAST(TREATMENTS_2.start_dt AS DATETIME))) AS MIN_YEAR_START_DT + FROM MAIN.PATIENTS PATIENTS + JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id + LEFT JOIN MAIN.TREATMENTS TREATMENTS_2 + ON PATIENTS.patient_id = TREATMENTS_2.patient_id + GROUP BY + PATIENTS.patient_id +), _T0 AS ( + SELECT + MIN_YEAR_START_DT, + COUNT(*) AS N_ROWS + FROM _T1 + GROUP BY + MIN_YEAR_START_DT +) +SELECT + CAST(MIN_YEAR_START_DT AS CLOB) AS year, + N_ROWS AS number_of_new_patients, + CASE + WHEN ( + N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + ) <> 0 + THEN N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + ELSE NULL + END AS npi +FROM _T0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql new file mode 100644 index 000000000..b7e2433f0 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql @@ -0,0 +1,16 @@ +WITH _S1 AS ( + SELECT + doc_id AS DOC_ID, + COUNT(DISTINCT drug_id) AS NDISTINCT_DRUG_ID + FROM MAIN.TREATMENTS + GROUP BY + doc_id +) +SELECT + DOCTORS.doc_id, + DOCTORS.specialty, + _S1.NDISTINCT_DRUG_ID AS num_distinct_drugs, + DENSE_RANK() OVER (PARTITION BY DOCTORS.specialty ORDER BY _S1.NDISTINCT_DRUG_ID DESC) AS SDRSDR +FROM MAIN.DOCTORS DOCTORS +JOIN _S1 _S1 + ON DOCTORS.doc_id = _S1.DOC_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql new file mode 100644 index 000000000..d9e60aeb8 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql @@ -0,0 +1,9 @@ +SELECT + COUNT(*) AS num_treatments +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.PATIENTS PATIENTS + ON LOWER(PATIENTS.first_name) = 'alice' + AND PATIENTS.patient_id = TREATMENTS.patient_id +WHERE + TREATMENTS.start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND TREATMENTS.start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 6, MONTH) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql new file mode 100644 index 000000000..e33d49c5a --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -0,0 +1,27 @@ +WITH _T0 AS ( + SELECT + TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') AS START_MONTH, + COUNT(*) AS N_ROWS, + COUNT(DISTINCT diag_id) AS NDISTINCT_DIAG_ID + FROM MAIN.TREATMENTS + WHERE + DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 12, MONTH) <= TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') + AND TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + GROUP BY + TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') +) +SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM START_MONTH), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) + END + ) AS start_month, + NDISTINCT_DIAG_ID AS PMPD, + N_ROWS AS PMTC +FROM _T0 +ORDER BY + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql new file mode 100644 index 000000000..38990537b --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -0,0 +1,78 @@ +WITH _S2 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))), ( + 2 * -1 + )) + END + ) AS TREATMENT_MONTH, + COUNT(DISTINCT patient_id) AS NDISTINCT_PATIENT_ID + FROM MAIN.TREATMENTS + WHERE + start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 3, MONTH) + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))), ( + 2 * -1 + )) + END + ) +), _S3 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) AS TREATMENT_MONTH, + COUNT(DISTINCT TREATMENTS.patient_id) AS NDISTINCT_PATIENT_ID + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'biologic' + WHERE + TREATMENTS.start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND TREATMENTS.start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 3, MONTH) + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) +) +SELECT + _S2.TREATMENT_MONTH AS month, + _S2.NDISTINCT_PATIENT_ID AS patient_count, + NVL(_S3.NDISTINCT_PATIENT_ID, 0) AS biologic_treatment_count +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.TREATMENT_MONTH = _S3.TREATMENT_MONTH +ORDER BY + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql new file mode 100644 index 000000000..f83061557 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql @@ -0,0 +1,6 @@ +SELECT + DRUGS.drug_id, + DRUGS.drug_name +FROM MAIN.DRUGS DRUGS +JOIN MAIN.TREATMENTS TREATMENTS + ON DRUGS.drug_id = TREATMENTS.drug_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql new file mode 100644 index 000000000..525ea1b8f --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -0,0 +1,31 @@ +WITH _S1 AS ( + SELECT + doc_id AS DOC_ID, + COUNT(*) AS N_ROWS, + SUM(tot_drug_amt) AS SUM_TOT_DRUG_AMT + FROM MAIN.TREATMENTS + WHERE + start_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') + GROUP BY + doc_id +), _T1 AS ( + SELECT + DOCTORS.specialty AS SPECIALTY, + SUM(_S1.N_ROWS) AS SUM_N_ROWS, + SUM(_S1.SUM_TOT_DRUG_AMT) AS SUM_SUM_TOT_DRUG_AMT + FROM MAIN.DOCTORS DOCTORS + LEFT JOIN _S1 _S1 + ON DOCTORS.doc_id = _S1.DOC_ID + GROUP BY + DOCTORS.specialty +) +SELECT + SPECIALTY AS specialty, + SUM_N_ROWS AS num_treatments, + NVL(SUM_SUM_TOT_DRUG_AMT, 0) AS total_drug_amount +FROM _T1 +WHERE + SUM_N_ROWS <> 0 +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql new file mode 100644 index 000000000..9290669b7 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql @@ -0,0 +1,63 @@ +WITH _T2 AS ( + SELECT + end_dt AS END_DT, + patient_id AS PATIENT_ID, + treatment_id AS TREATMENT_ID + FROM MAIN.TREATMENTS + WHERE + EXTRACT(YEAR FROM CAST(end_dt AS DATETIME)) = 2022 +), _T3 AS ( + SELECT + day100_pasi_score AS DAY100_PASI_SCORE, + treatment_id AS TREATMENT_ID + FROM MAIN.OUTCOMES + WHERE + NOT day100_pasi_score IS NULL +), _S3 AS ( + SELECT + ins_type AS INS_TYPE, + patient_id AS PATIENT_ID + FROM MAIN.PATIENTS +), _S10 AS ( + SELECT + _S3.INS_TYPE, + COUNT(DISTINCT _T2.PATIENT_ID) AS NDISTINCT_PATIENT_ID + FROM _T2 _T2 + JOIN _T3 _T3 + ON _T2.TREATMENT_ID = _T3.TREATMENT_ID + JOIN _S3 _S3 + ON _S3.PATIENT_ID = _T2.PATIENT_ID + GROUP BY + _S3.INS_TYPE +), _S9 AS ( + SELECT + treatment_id AS TREATMENT_ID, + COUNT(day100_pasi_score) AS COUNT_DAY100_PASI_SCORE, + SUM(day100_pasi_score) AS SUM_DAY100_PASI_SCORE + FROM MAIN.OUTCOMES + GROUP BY + treatment_id +), _S11 AS ( + SELECT + SUM(_S9.SUM_DAY100_PASI_SCORE) / SUM(_S9.COUNT_DAY100_PASI_SCORE) AS AVG_DAY100_PASI_SCORE, + _S7.INS_TYPE + FROM _T2 _T6 + JOIN _T3 _T7 + ON _T6.TREATMENT_ID = _T7.TREATMENT_ID + JOIN _S3 _S7 + ON _S7.PATIENT_ID = _T6.PATIENT_ID + JOIN _S9 _S9 + ON _S9.TREATMENT_ID = _T6.TREATMENT_ID + GROUP BY + _S7.INS_TYPE +) +SELECT + _S10.INS_TYPE AS insurance_type, + _S10.NDISTINCT_PATIENT_ID AS num_distinct_patients, + _S11.AVG_DAY100_PASI_SCORE AS avg_pasi_score_day100 +FROM _S10 _S10 +LEFT JOIN _S11 _S11 + ON _S10.INS_TYPE = _S11.INS_TYPE +ORDER BY + 3 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql new file mode 100644 index 000000000..ba625b6b6 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + drug_id AS DRUG_ID, + AVG(tot_drug_amt) AS AVG_TOT_DRUG_AMT, + COUNT(*) AS N_ROWS + FROM MAIN.TREATMENTS + GROUP BY + drug_id +) +SELECT + DRUGS.drug_name, + NVL(_S1.N_ROWS, 0) AS num_treatments, + _S1.AVG_TOT_DRUG_AMT AS avg_drug_amount +FROM MAIN.DRUGS DRUGS +LEFT JOIN _S1 _S1 + ON DRUGS.drug_id = _S1.DRUG_ID +ORDER BY + 2 DESC NULLS LAST, + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql new file mode 100644 index 000000000..7044080db --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql @@ -0,0 +1,30 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(TREATMENTS.diag_id) AS ANYTHING_DIAG_ID, + ANY_VALUE(TREATMENTS.patient_id) AS ANYTHING_PATIENT_ID, + MAX(OUTCOMES.day100_itch_vas) AS MAX_DAY100_ITCH_VAS + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.OUTCOMES OUTCOMES + ON OUTCOMES.treatment_id = TREATMENTS.treatment_id + GROUP BY + OUTCOMES.treatment_id +), _S3 AS ( + SELECT + ANYTHING_DIAG_ID, + MAX(MAX_DAY100_ITCH_VAS) AS MAX_MAX_DAY100_ITCH_VAS, + COUNT(DISTINCT ANYTHING_PATIENT_ID) AS NDISTINCT_ANYTHING_PATIENT_ID + FROM _T1 + GROUP BY + ANYTHING_DIAG_ID +) +SELECT + DIAGNOSES.diag_name AS diagnosis_name, + _S3.NDISTINCT_ANYTHING_PATIENT_ID AS num_patients, + _S3.MAX_MAX_DAY100_ITCH_VAS AS max_itch_score +FROM MAIN.DIAGNOSES DIAGNOSES +JOIN _S3 _S3 + ON DIAGNOSES.diag_id = _S3.ANYTHING_DIAG_ID +ORDER BY + 3 DESC NULLS LAST, + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql new file mode 100644 index 000000000..07f71c274 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql @@ -0,0 +1,7 @@ +SELECT + DOCTORS.doc_id, + DOCTORS.first_name, + DOCTORS.last_name +FROM MAIN.DOCTORS DOCTORS +JOIN MAIN.TREATMENTS TREATMENTS + ON DOCTORS.doc_id = TREATMENTS.doc_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql new file mode 100644 index 000000000..6998557e6 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + PATIENTS.patient_id, + PATIENTS.first_name, + PATIENTS.last_name +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id +JOIN MAIN.OUTCOMES OUTCOMES + ON OUTCOMES.treatment_id = TREATMENTS.treatment_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql new file mode 100644 index 000000000..c1015336f --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ins_type AS insurance_type, + AVG(height_cm) AS avg_height, + AVG(weight_kg) AS avg_weight +FROM MAIN.PATIENTS +GROUP BY + ins_type +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql new file mode 100644 index 000000000..0a21cc8de --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql @@ -0,0 +1,9 @@ +SELECT + specialty, + COUNT(*) AS num_doctors +FROM MAIN.DOCTORS +GROUP BY + specialty +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql new file mode 100644 index 000000000..c6256e898 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql @@ -0,0 +1,7 @@ +SELECT + PATIENTS.patient_id, + PATIENTS.first_name, + PATIENTS.last_name +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql new file mode 100644 index 000000000..964d6dcdb --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql @@ -0,0 +1,13 @@ +SELECT + ADVERSE_EVENTS.treatment_id, + TREATMENTS.start_dt AS treatment_start_date, + ADVERSE_EVENTS.reported_dt AS adverse_event_date, + ADVERSE_EVENTS.description +FROM MAIN.ADVERSE_EVENTS ADVERSE_EVENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id + AND DATEDIFF( + CAST(ADVERSE_EVENTS.reported_dt AS DATETIME), + CAST(TREATMENTS.start_dt AS DATETIME), + DAY + ) <= 10 diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql new file mode 100644 index 000000000..788d00c7a --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql @@ -0,0 +1,26 @@ +WITH _T AS ( + SELECT + doc_id AS DOC_ID, + start_dt AS START_DT, + treatment_id AS TREATMENT_ID, + ROW_NUMBER() OVER (PARTITION BY doc_id ORDER BY start_dt) AS _W + FROM MAIN.TREATMENTS +), _S1 AS ( + SELECT + DOC_ID, + START_DT, + TREATMENT_ID + FROM _T + WHERE + _W = 1 +) +SELECT + DOCTORS.last_name, + DOCTORS.year_reg, + _S1.START_DT AS first_treatment_date, + _S1.TREATMENT_ID AS first_treatment_id +FROM MAIN.DOCTORS DOCTORS +LEFT JOIN _S1 _S1 + ON DOCTORS.doc_id = _S1.DOC_ID +WHERE + DOCTORS.year_reg = EXTRACT(YEAR FROM DATE_SUB(CURRENT_TIMESTAMP, 2, YEAR)) diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql new file mode 100644 index 000000000..405b438a7 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(DATEDIFF(CURRENT_TIMESTAMP, CAST(date_of_birth AS DATETIME), YEAR)) AS average_age +FROM MAIN.PATIENTS +WHERE + gender = 'Male' AND ins_type = 'private' diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql new file mode 100644 index 000000000..e3f8ff9ae --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql @@ -0,0 +1,19 @@ +SELECT + TREATMENTS_2.treatment_id, + TREATMENTS_2.start_dt AS treatment_start_date, + TREATMENTS_2.end_dt AS treatment_end_date, + CONCOMITANT_MEDS.start_dt AS concomitant_med_start_date, + CONCOMITANT_MEDS.end_dt AS concomitant_med_end_date +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.CONCOMITANT_MEDS CONCOMITANT_MEDS + ON CONCOMITANT_MEDS.treatment_id = TREATMENTS.treatment_id +JOIN MAIN.TREATMENTS TREATMENTS_2 + ON CONCOMITANT_MEDS.treatment_id = TREATMENTS_2.treatment_id + AND DATEDIFF( + CAST(CONCOMITANT_MEDS.start_dt AS DATETIME), + CAST(TREATMENTS_2.start_dt AS DATETIME), + DAY + ) <= 14 + AND TREATMENTS_2.is_placebo +WHERE + TREATMENTS.is_placebo = TRUE diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql new file mode 100644 index 000000000..b231e94be --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql @@ -0,0 +1,11 @@ +SELECT + COUNT(*) AS num_treatments +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.DIAGNOSES DIAGNOSES + ON DIAGNOSES.diag_id = TREATMENTS.diag_id + AND LOWER(DIAGNOSES.diag_name) LIKE '%psoriasis%' +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT DRUGS.fda_appr_dt IS NULL +WHERE + NOT TREATMENTS.end_dt IS NULL + AND TREATMENTS.end_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql new file mode 100644 index 000000000..6fee26cc1 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql @@ -0,0 +1,9 @@ +SELECT + WALLET_TRANSACTIONS_DAILY.sender_id AS user_id, + COUNT(*) AS total_transactions +FROM MAIN.USERS USERS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id + AND WALLET_TRANSACTIONS_DAILY.sender_type = 0 +GROUP BY + WALLET_TRANSACTIONS_DAILY.sender_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql new file mode 100644 index 000000000..339cd6a87 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql @@ -0,0 +1,18 @@ +SELECT + USER_SESSIONS.user_id AS uid, + SUM( + DATEDIFF( + CAST(USER_SESSIONS.session_end_ts AS DATETIME), + CAST(USER_SESSIONS.session_start_ts AS DATETIME), + SECOND + ) + ) AS total_duration +FROM MAIN.USERS USERS +JOIN MAIN.USER_SESSIONS USER_SESSIONS + ON USERS.uid = USER_SESSIONS.user_id + AND USER_SESSIONS.session_end_ts < '2023-06-08' + AND USER_SESSIONS.session_start_ts >= '2023-06-01' +GROUP BY + USER_SESSIONS.user_id +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql new file mode 100644 index 000000000..70cd17a4f --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUPONS.cid AS coupon_id, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount +FROM MAIN.COUPONS COUPONS +LEFT JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON COUPONS.cid = WALLET_TRANSACTIONS_DAILY.coupon_id +WHERE + COUPONS.merchant_id = '1' +GROUP BY + COUPONS.cid diff --git a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql new file mode 100644 index 000000000..4a17a3456 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql @@ -0,0 +1,6 @@ +SELECT + COUNT(*) AS TUC +FROM MAIN.USER_SESSIONS +WHERE + session_end_ts >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH), 'DAY') + OR session_start_ts >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql new file mode 100644 index 000000000..bc455ae65 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(status = 'success'), 0) / COUNT(*) AS _expr0 +FROM MAIN.WALLET_TRANSACTIONS_DAILY +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(created_at AS DATETIME), MONTH) = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql new file mode 100644 index 000000000..daa189a31 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql @@ -0,0 +1,21 @@ +WITH _S3 AS ( + SELECT + COUPONS.merchant_id AS MERCHANT_ID, + COUNT(*) AS N_ROWS + FROM MAIN.COUPONS COUPONS + JOIN MAIN.MERCHANTS MERCHANTS + ON COUPONS.merchant_id = MERCHANTS.mid + AND DATEDIFF(CAST(COUPONS.created_at AS DATETIME), CAST(MERCHANTS.created_at AS DATETIME), MONTH) = 0 + GROUP BY + COUPONS.merchant_id +) +SELECT + MERCHANTS.mid AS merchant_id, + MERCHANTS.name AS merchant_name, + NVL(_S3.N_ROWS, 0) AS coupons_per_merchant +FROM MAIN.MERCHANTS MERCHANTS +LEFT JOIN _S3 _S3 + ON MERCHANTS.mid = _S3.MERCHANT_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql new file mode 100644 index 000000000..46759086c --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql @@ -0,0 +1,12 @@ +SELECT + ANY_VALUE(USERS.username) AS username, + COUNT(*) AS total_unread_notifs +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.status = 'unread' + AND NOTIFICATIONS.type = 'promotion' + AND NOTIFICATIONS.user_id = USERS.uid +WHERE + LOWER(USERS.country) = 'us' +GROUP BY + NOTIFICATIONS.user_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql new file mode 100644 index 000000000..a400fa7a7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql @@ -0,0 +1,9 @@ +SELECT + ANY_VALUE(MERCHANTS.name) AS name, + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.coupon_id) / COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.txid) AS CPUR +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + WALLET_TRANSACTIONS_DAILY.receiver_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql new file mode 100644 index 000000000..af55a5d09 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql @@ -0,0 +1,19 @@ +SELECT + TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') AS week, + COUNT(*) AS num_notifs, + NVL( + SUM(( + MOD(( + DAY_OF_WEEK(NOTIFICATIONS.created_at) + 6 + ), 7) + ) IN (5, 6)), + 0 + ) AS weekend_notifs +FROM MAIN.NOTIFICATIONS NOTIFICATIONS +JOIN MAIN.USERS USERS + ON NOTIFICATIONS.user_id = USERS.uid AND USERS.country IN ('US', 'CA') +WHERE + NOTIFICATIONS.created_at < TRUNC(CURRENT_TIMESTAMP, 'WEEK') + AND NOTIFICATIONS.created_at >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 3, WEEK) +GROUP BY + TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql new file mode 100644 index 000000000..65a45ff17 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ANY_VALUE(MERCHANTS.name) AS merchant_name, + COUNT(*) AS total_coupons +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.COUPONS COUPONS + ON COUPONS.merchant_id = MERCHANTS.mid +WHERE + LOWER(MERCHANTS.category) LIKE '%retail%' AND MERCHANTS.status = 'active' +GROUP BY + COUPONS.merchant_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql new file mode 100644 index 000000000..f6da2c390 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql @@ -0,0 +1,12 @@ +SELECT + COUNT(*) AS num_transactions, + CASE + WHEN COUNT(*) <> 0 + THEN NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) + ELSE NULL + END AS total_amount +FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY +JOIN MAIN.USERS USERS + ON USERS.country = 'US' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql new file mode 100644 index 000000000..f2e00e4f0 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(balance) AS AMB +FROM MAIN.WALLET_USER_BALANCE_DAILY +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(updated_at AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql new file mode 100644 index 000000000..e3bbd9ad8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + balance AS BALANCE, + user_id AS USER_ID, + ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY updated_at DESC) AS _W + FROM MAIN.WALLET_USER_BALANCE_DAILY +) +SELECT + USER_ID AS user_id, + BALANCE AS latest_balance +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql new file mode 100644 index 000000000..461713544 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + marketing_opt_in AS MARKETING_OPT_IN, + user_id AS USER_ID, + ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS _W + FROM MAIN.USER_SETTING_SNAPSHOT +) +SELECT + USERS.uid, + _T.MARKETING_OPT_IN AS marketing_opt_in +FROM MAIN.USERS USERS +JOIN _T _T + ON USERS.uid = _T.USER_ID AND _T._W = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql new file mode 100644 index 000000000..90ce9d77a --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql @@ -0,0 +1,13 @@ +SELECT + WALLET_TRANSACTIONS_DAILY.receiver_id AS merchants_id, + ANY_VALUE(MERCHANTS.name) AS merchants_name, + ANY_VALUE(MERCHANTS.category) AS category, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_revenue, + ROW_NUMBER() OVER (ORDER BY NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) DESC) AS mrr +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id + AND WALLET_TRANSACTIONS_DAILY.receiver_type = 1 + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + WALLET_TRANSACTIONS_DAILY.receiver_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql new file mode 100644 index 000000000..1733ce8d8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql @@ -0,0 +1,10 @@ +SELECT + TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') AS year_month, + COUNT(DISTINCT sender_id) AS active_users +FROM MAIN.WALLET_TRANSACTIONS_DAILY +WHERE + created_at < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND created_at >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 2, MONTH) + AND sender_type = 0 +GROUP BY + TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql new file mode 100644 index 000000000..b3d311310 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + amount AS AMOUNT, + receiver_id AS RECEIVER_ID + FROM MAIN.WALLET_TRANSACTIONS_DAILY + WHERE + created_at >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 150, DAY), 'DAY') + AND receiver_type = 1 +) +SELECT + ANY_VALUE(MERCHANTS.name) AS merchant_name, + NVL(NULLIF(COUNT(_S1.RECEIVER_ID), 0), 0) AS total_transactions, + NVL(SUM(_S1.AMOUNT), 0) AS total_amount +FROM MAIN.MERCHANTS MERCHANTS +LEFT JOIN _S1 _S1 + ON MERCHANTS.mid = _S1.RECEIVER_ID +GROUP BY + MERCHANTS.mid +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql new file mode 100644 index 000000000..e9bd25cf7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql @@ -0,0 +1,12 @@ +SELECT + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS TIMESTAMP), 'MONTH') AS month, + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.sender_id) AS active_users +FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY +JOIN MAIN.USERS USERS + ON USERS.status = 'active' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + EXTRACT(YEAR FROM CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATETIME)) = 2023 + AND WALLET_TRANSACTIONS_DAILY.sender_type = 0 + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS TIMESTAMP), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql new file mode 100644 index 000000000..8a6bdf8d9 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql @@ -0,0 +1,6 @@ +SELECT + MERCHANTS.mid AS merchant_id, + MERCHANTS.name AS merchant_name +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.COUPONS COUPONS + ON COUPONS.merchant_id = MERCHANTS.mid diff --git a/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql new file mode 100644 index 000000000..6a3d1b881 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql @@ -0,0 +1,6 @@ +SELECT + MERCHANTS.mid AS merchant +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id + AND WALLET_TRANSACTIONS_DAILY.receiver_type = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql new file mode 100644 index 000000000..4d70d0ac7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql @@ -0,0 +1,5 @@ +SELECT + USERS.uid AS user_id +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.type = 'transaction' AND NOTIFICATIONS.user_id = USERS.uid diff --git a/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql new file mode 100644 index 000000000..c4afae6f5 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql @@ -0,0 +1,6 @@ +SELECT + USERS.uid, + USERS.username +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.user_id = USERS.uid diff --git a/tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql new file mode 100644 index 000000000..1fad261a8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + device_type, + COUNT(*) AS count +FROM MAIN.USER_SESSIONS +GROUP BY + device_type +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql new file mode 100644 index 000000000..641290b6c --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql @@ -0,0 +1,9 @@ +SELECT + status, + COUNT(*) AS count +FROM MAIN.WALLET_TRANSACTIONS_DAILY +GROUP BY + status +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql new file mode 100644 index 000000000..148c636dc --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql @@ -0,0 +1,12 @@ +SELECT + ANY_VALUE(COUPONS.code) AS coupon_code, + COUNT(WALLET_TRANSACTIONS_DAILY.txid) AS redemption_count, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount +FROM MAIN.COUPONS COUPONS +LEFT JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON COUPONS.cid = WALLET_TRANSACTIONS_DAILY.coupon_id +GROUP BY + COUPONS.cid +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql new file mode 100644 index 000000000..6e97509d8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql @@ -0,0 +1,14 @@ +SELECT + USERS.country, + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.sender_id) AS user_count, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_amount +FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY +LEFT JOIN MAIN.USERS USERS + ON USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + WALLET_TRANSACTIONS_DAILY.sender_type = 0 +GROUP BY + USERS.country +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql new file mode 100644 index 000000000..e9f9f48e5 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql @@ -0,0 +1,26 @@ +WITH _T0 AS ( + SELECT + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY WALLET_MERCHANT_BALANCE_DAILY.balance DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(WALLET_MERCHANT_BALANCE_DAILY.balance) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN WALLET_MERCHANT_BALANCE_DAILY.balance + ELSE NULL + END AS EXPR_1 + FROM MAIN.WALLET_MERCHANT_BALANCE_DAILY WALLET_MERCHANT_BALANCE_DAILY + JOIN MAIN.MERCHANTS MERCHANTS + ON LOWER(MERCHANTS.category) LIKE '%retail%' + AND MERCHANTS.mid = WALLET_MERCHANT_BALANCE_DAILY.merchant_id + AND MERCHANTS.status = 'active' + WHERE + TRUNC(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS TIMESTAMP), 'DAY') = TRUNC(CURRENT_TIMESTAMP, 'DAY') +) +SELECT + AVG(EXPR_1) AS _expr0 +FROM _T0 diff --git a/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql new file mode 100644 index 000000000..eb3840caa --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql @@ -0,0 +1,23 @@ +WITH _S0 AS ( + SELECT + MIN(snapshot_date) AS MIN_SNAPSHOT_DATE + FROM MAIN.USER_SETTING_SNAPSHOT + WHERE + EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 +), _S1 AS ( + SELECT + snapshot_date AS SNAPSHOT_DATE, + AVG(tx_limit_daily) AS AVG_TX_LIMIT_DAILY, + AVG(tx_limit_monthly) AS AVG_TX_LIMIT_MONTHLY + FROM MAIN.USER_SETTING_SNAPSHOT + WHERE + EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 + GROUP BY + snapshot_date +) +SELECT + _S1.AVG_TX_LIMIT_DAILY AS avg_daily_limit, + _S1.AVG_TX_LIMIT_MONTHLY AS avg_monthly_limit +FROM _S0 _S0 +LEFT JOIN _S1 _S1 + ON _S0.MIN_SNAPSHOT_DATE = _S1.SNAPSHOT_DATE diff --git a/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql new file mode 100644 index 000000000..12217a386 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql @@ -0,0 +1,8 @@ +SELECT + device_type, + AVG( + DATEDIFF(CAST(session_end_ts AS DATETIME), CAST(session_start_ts AS DATETIME), SECOND) + ) AS avg_session_duration_seconds +FROM MAIN.USER_SESSIONS +GROUP BY + device_type diff --git a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql new file mode 100644 index 000000000..51a3f4d03 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql @@ -0,0 +1,36 @@ +WITH _T1 AS ( + SELECT + merchant_id AS MERCHANT_ID, + start_date AS START_DATE + FROM MAIN.COUPONS +), _S1 AS ( + SELECT + MERCHANT_ID, + MIN(START_DATE) AS MIN_START_DATE + FROM _T1 + GROUP BY + MERCHANT_ID +), _S4 AS ( + SELECT + MERCHANTS.mid AS MID, + _S1.MIN_START_DATE, + ANY_VALUE(MERCHANTS.created_at) AS ANYTHING_CREATED_AT, + MAX(COUPONS.cid) AS MAX_CID + FROM MAIN.MERCHANTS MERCHANTS + LEFT JOIN _S1 _S1 + ON MERCHANTS.mid = _S1.MERCHANT_ID + LEFT JOIN MAIN.COUPONS COUPONS + ON COUPONS.merchant_id = MERCHANTS.mid AND COUPONS.start_date = _S1.MIN_START_DATE + GROUP BY + MERCHANTS.mid, + _S1.MIN_START_DATE +) +SELECT + _S4.MID AS merchants_id, + _S4.ANYTHING_CREATED_AT AS merchant_registration_date, + _S4.MIN_START_DATE AS earliest_coupon_start_date, + _S4.MAX_CID AS earliest_coupon_id +FROM _S4 _S4 +JOIN _T1 _S5 + ON _S4.MID = _S5.MERCHANT_ID + AND _S5.START_DATE <= DATE_ADD(CAST(_S4.ANYTHING_CREATED_AT AS TIMESTAMP), 1, 'YEAR') diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql new file mode 100644 index 000000000..6264d6c93 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -0,0 +1,11 @@ +SELECT + USERS.username, + USERS.email, + USERS.created_at +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.user_id = USERS.uid +JOIN MAIN.USERS USERS_2 + ON NOTIFICATIONS.created_at <= DATE_ADD(CAST(USERS_2.created_at AS TIMESTAMP), 1, 'YEAR') + AND NOTIFICATIONS.created_at >= USERS_2.created_at + AND NOTIFICATIONS.user_id = USERS_2.uid diff --git a/tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql new file mode 100644 index 000000000..3b989280f --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql @@ -0,0 +1,7 @@ +SELECT + name, + rating +FROM MAIN.RESTAURANT +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql new file mode 100644 index 000000000..566fd4aac --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql @@ -0,0 +1,15 @@ +WITH _S0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + WHERE + rating > 4.5 +), _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT +) +SELECT + _S0.N_ROWS / _S1.N_ROWS AS ratio +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql new file mode 100644 index 000000000..6140ced43 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql @@ -0,0 +1,3 @@ +SELECT + NVL(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio +FROM MAIN.RESTAURANT diff --git a/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql new file mode 100644 index 000000000..3f873154b --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'new york' diff --git a/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql new file mode 100644 index 000000000..d107fd0cd --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(LOWER(food_type) = 'vegan'), 0) / NULLIF(SUM(LOWER(food_type) <> 'vegan'), 0) AS ratio +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'san francisco' diff --git a/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql new file mode 100644 index 000000000..c4cd6b49b --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(LOWER(food_type) = 'italian'), 0) / NULLIF(COUNT(*), 0) AS ratio +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'los angeles' diff --git a/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql new file mode 100644 index 000000000..2a5b78bd7 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql @@ -0,0 +1,17 @@ +WITH _T0 AS ( + SELECT + city_name AS CITY_NAME, + name AS NAME, + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + GROUP BY + city_name, + name +) +SELECT + CITY_NAME AS city_name, + NAME AS name, + N_ROWS AS n_restaurants +FROM _T0 +WHERE + N_ROWS > 1 diff --git a/tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql new file mode 100644 index 000000000..af6d498f2 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql @@ -0,0 +1,8 @@ +SELECT + city_name, + AVG(rating) AS avg_rating +FROM MAIN.RESTAURANT +WHERE + LOWER(food_type) = 'mexican' +GROUP BY + city_name diff --git a/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql new file mode 100644 index 000000000..64c651bf1 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql @@ -0,0 +1,43 @@ +WITH _S0 AS ( + SELECT + city_name AS CITY_NAME, + region AS REGION + FROM MAIN.GEOGRAPHIC +), _S1 AS ( + SELECT + city_name AS CITY_NAME + FROM MAIN.RESTAURANT +), _S6 AS ( + SELECT DISTINCT + _S0.REGION + FROM _S0 _S0 + JOIN _S1 _S1 + ON _S0.CITY_NAME = _S1.CITY_NAME +), _S5 AS ( + SELECT + city_name AS CITY_NAME, + COUNT(rating) AS COUNT_RATING, + SUM(rating) AS SUM_RATING + FROM MAIN.RESTAURANT + GROUP BY + city_name +), _S7 AS ( + SELECT + SUM(_S5.SUM_RATING) / SUM(_S5.COUNT_RATING) AS AVG_RATING, + _S2.REGION + FROM _S0 _S2 + JOIN _S1 _S3 + ON _S2.CITY_NAME = _S3.CITY_NAME + JOIN _S5 _S5 + ON _S2.CITY_NAME = _S5.CITY_NAME + GROUP BY + _S2.REGION +) +SELECT + _S6.REGION AS rest_region, + _S7.AVG_RATING AS avg_rating +FROM _S6 _S6 +LEFT JOIN _S7 _S7 + ON _S6.REGION = _S7.REGION +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql new file mode 100644 index 000000000..c181210f5 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql @@ -0,0 +1,21 @@ +WITH _S0 AS ( + SELECT + city_name AS CITY_NAME, + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + WHERE + LOWER(food_type) = 'italian' + GROUP BY + city_name +) +SELECT + GEOGRAPHIC.region AS rest_region, + SUM(_S0.N_ROWS) AS n_restaurants +FROM _S0 _S0 +JOIN MAIN.GEOGRAPHIC GEOGRAPHIC + ON GEOGRAPHIC.city_name = _S0.CITY_NAME +GROUP BY + GEOGRAPHIC.region +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql new file mode 100644 index 000000000..d75957d8f --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql @@ -0,0 +1,6 @@ +SELECT + food_type, + COUNT(*) AS restaurants +FROM MAIN.RESTAURANT +GROUP BY + food_type diff --git a/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql new file mode 100644 index 000000000..4d1d8701d --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql @@ -0,0 +1,19 @@ +WITH _S0 AS ( + SELECT + city_name AS CITY_NAME, + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + GROUP BY + city_name +) +SELECT + GEOGRAPHIC.region AS rest_region, + SUM(_S0.N_ROWS) AS n_restaurants +FROM _S0 _S0 +JOIN MAIN.GEOGRAPHIC GEOGRAPHIC + ON GEOGRAPHIC.city_name = _S0.CITY_NAME +GROUP BY + GEOGRAPHIC.region +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql new file mode 100644 index 000000000..7ee13cbdd --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql @@ -0,0 +1,6 @@ +SELECT + city_name +FROM MAIN.RESTAURANT +ORDER BY + rating DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql new file mode 100644 index 000000000..47cfd7ec6 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql @@ -0,0 +1,6 @@ +SELECT + name, + rating +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'new york' AND rating > 4 diff --git a/tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql new file mode 100644 index 000000000..765fb6c80 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql @@ -0,0 +1,9 @@ +SELECT + RESTAURANT.name, + RESTAURANT.food_type +FROM MAIN.LOCATION LOCATION +JOIN MAIN.RESTAURANT RESTAURANT + ON LOCATION.restaurant_id = RESTAURANT.id +WHERE + LOWER(LOCATION.city_name) = 'san francisco' + AND LOWER(LOCATION.street_name) = 'market st' diff --git a/tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql new file mode 100644 index 000000000..f1628a159 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql @@ -0,0 +1,5 @@ +SELECT + name +FROM MAIN.RESTAURANT +WHERE + LOWER(food_type) = 'italian' diff --git a/tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql new file mode 100644 index 000000000..b88818312 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql @@ -0,0 +1,5 @@ +SELECT + name +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'los angeles' AND rating > 4 diff --git a/tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql new file mode 100644 index 000000000..c4ec51cdf --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql @@ -0,0 +1,6 @@ +SELECT + city_name, + COUNT(*) AS total_count +FROM MAIN.LOCATION +GROUP BY + city_name diff --git a/tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql new file mode 100644 index 000000000..edb9bf11b --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql @@ -0,0 +1,9 @@ +SELECT + food_type, + AVG(rating) AS avg_rating +FROM MAIN.RESTAURANT +GROUP BY + food_type +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql new file mode 100644 index 000000000..be1d37312 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql @@ -0,0 +1,11 @@ +SELECT + city_name, + COUNT(*) AS num_restaurants +FROM MAIN.RESTAURANT +WHERE + LOWER(food_type) = 'italian' +GROUP BY + city_name +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql new file mode 100644 index 000000000..d9d423edc --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql @@ -0,0 +1,9 @@ +SELECT + city_name, + COUNT(*) AS num_restaurants +FROM MAIN.LOCATION +GROUP BY + city_name +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql new file mode 100644 index 000000000..e1eda430d --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql @@ -0,0 +1,8 @@ +SELECT + street_name +FROM MAIN.LOCATION +GROUP BY + street_name +ORDER BY + COUNT(*) DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql new file mode 100644 index 000000000..2dd5e2521 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql @@ -0,0 +1,5 @@ +SELECT + name +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'new york' OR LOWER(food_type) = 'italian' diff --git a/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql new file mode 100644 index 000000000..597e3305d --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql @@ -0,0 +1,33 @@ +WITH _S1 AS ( + SELECT + city_name AS CITY_NAME, + region AS REGION + FROM MAIN.GEOGRAPHIC +), _S6 AS ( + SELECT DISTINCT + _S1.REGION + FROM MAIN.LOCATION LOCATION + LEFT JOIN _S1 _S1 + ON LOCATION.city_name = _S1.CITY_NAME +), _S7 AS ( + SELECT + _S3.REGION, + SUM(CASE WHEN NOT RESTAURANT.rating IS NULL THEN 1 ELSE 0 END) AS SUM_EXPR, + SUM(RESTAURANT.rating) AS SUM_RATING + FROM MAIN.LOCATION LOCATION + LEFT JOIN _S1 _S3 + ON LOCATION.city_name = _S3.CITY_NAME + JOIN MAIN.RESTAURANT RESTAURANT + ON LOCATION.restaurant_id = RESTAURANT.id + GROUP BY + _S3.REGION +) +SELECT + _S6.REGION AS region_name, + _S7.SUM_RATING / _S7.SUM_EXPR AS avg_rating +FROM _S6 _S6 +JOIN _S7 _S7 + ON _S6.REGION = _S7.REGION +ORDER BY + 1 NULLS FIRST, + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql new file mode 100644 index 000000000..9f8c97897 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql @@ -0,0 +1,7 @@ +SELECT + name +FROM MAIN.RESTAURANT +ORDER BY + rating DESC NULLS LAST, + 1 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql new file mode 100644 index 000000000..ec5eea326 --- /dev/null +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -0,0 +1,68 @@ +WITH _T3 AS ( + SELECT + o_orderdate AS O_ORDERDATE + FROM TPCH.ORDERS +), _S0 AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM _T3 +), _S2 AS ( + SELECT + DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) AS ORD_WK, + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN TPCH.ORDERS ORDERS + ON DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) < 10 + AND ORDERS.o_orderpriority = '1-URGENT' + AND ORDERS.o_orderstatus = 'F' + GROUP BY + DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) +), _S3 AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM _T3 +), _T0 AS ( + SELECT + DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ) AS LINE_WK, + _S2.ORD_WK, + ANY_VALUE(_S2.N_ROWS) AS ANYTHING_N_ROWS, + COUNT(*) AS N_ROWS + FROM _S2 _S2 + CROSS JOIN _S3 _S3 + JOIN TPCH.LINEITEM LINEITEM + ON DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ) < 10 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1992 + AND LINEITEM.l_returnflag = 'R' + AND LINEITEM.l_shipmode = 'RAIL' + AND _S2.ORD_WK = DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ) + GROUP BY + DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ), + _S2.ORD_WK +) +SELECT + ORD_WK AS wk, + N_ROWS AS n_lines, + ANYTHING_N_ROWS AS n_orders, + ROUND( + SUM(N_ROWS) OVER (ORDER BY LINE_WK ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(ANYTHING_N_ROWS) OVER (ORDER BY ORD_WK ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 4 + ) AS lpo +FROM _T0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/double_partition_oracle.sql b/tests/test_sql_refsols/double_partition_oracle.sql new file mode 100644 index 000000000..843f4d0f3 --- /dev/null +++ b/tests/test_sql_refsols/double_partition_oracle.sql @@ -0,0 +1,15 @@ +WITH _T0 AS ( + SELECT + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) +) +SELECT + YEAR_O_ORDERDATE AS year, + MAX(N_ROWS) AS best_month +FROM _T0 +GROUP BY + YEAR_O_ORDERDATE diff --git a/tests/test_sql_refsols/dumb_aggregation_oracle.sql b/tests/test_sql_refsols/dumb_aggregation_oracle.sql new file mode 100644 index 000000000..18c231309 --- /dev/null +++ b/tests/test_sql_refsols/dumb_aggregation_oracle.sql @@ -0,0 +1,46 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 2 ROWS ONLY +), _S1 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY r_regionkey ORDER BY r_regionkey DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(r_regionkey) OVER (PARTITION BY r_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN r_regionkey + ELSE NULL + END AS AVG_EXPR + FROM TPCH.REGION +) +SELECT + _S0.N_NAME AS nation_name, + _S1.R_NAME AS a1, + _S1.R_NAME AS a2, + _S1.R_REGIONKEY AS a3, + CASE + WHEN NOT CASE WHEN _S1.R_NAME <> 'AMERICA' THEN _S1.R_REGIONKEY ELSE NULL END IS NULL + THEN 1 + ELSE 0 + END AS a4, + 1 AS a5, + _S1.R_REGIONKEY AS a6, + _S1.R_NAME AS a7, + _S1.AVG_EXPR AS a8 +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.N_REGIONKEY = _S1.R_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql new file mode 100644 index 000000000..50f710944 --- /dev/null +++ b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql @@ -0,0 +1,32 @@ +WITH _S2 AS ( + SELECT + ev_dt AS EV_DT, + ev_key AS EV_KEY + FROM EVENTS +) +SELECT + EVENTS.ev_name AS event_name, + ERAS.er_name AS era_name, + EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) AS event_year, + SEASONS.s_name AS season_name, + TIMES.t_name AS tod +FROM EVENTS EVENTS +JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) +JOIN _S2 _S2 + ON EVENTS.ev_key = _S2.EV_KEY +JOIN SEASONS SEASONS + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) +JOIN _S2 _S6 + ON EVENTS.ev_key = _S6.EV_KEY +JOIN TIMES TIMES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(_S6.EV_DT AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(_S6.EV_DT AS DATETIME)) +WHERE + EVENTS.ev_typ = 'culture' +ORDER BY + EVENTS.ev_dt NULLS FIRST +FETCH FIRST 6 ROWS ONLY diff --git a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql new file mode 100644 index 000000000..ade631cd8 --- /dev/null +++ b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql @@ -0,0 +1,27 @@ +WITH _T2 AS ( + SELECT + ERAS.er_end_year AS ER_END_YEAR, + ERAS.er_name AS ER_NAME, + ERAS.er_start_year AS ER_START_YEAR, + EVENTS.ev_dt AS EV_DT, + DATEDIFF( + CAST(EVENTS.ev_dt AS DATETIME), + CAST(LAG(EVENTS.ev_dt, 1) OVER (PARTITION BY ERAS.er_name, ERAS.er_name ORDER BY EVENTS.ev_dt) AS DATETIME), + DAY + ) AS DAY_GAP + FROM ERAS ERAS + JOIN EVENTS EVENTS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) +) +SELECT + ER_NAME AS era_name, + AVG(DAY_GAP) AS avg_event_gap +FROM _T2 +WHERE + ER_END_YEAR > EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) + AND ER_START_YEAR <= EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) +GROUP BY + ER_NAME +ORDER BY + ANY_VALUE(ER_START_YEAR) NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_events_per_season_oracle.sql b/tests/test_sql_refsols/epoch_events_per_season_oracle.sql new file mode 100644 index 000000000..585bbad16 --- /dev/null +++ b/tests/test_sql_refsols/epoch_events_per_season_oracle.sql @@ -0,0 +1,13 @@ +SELECT + SEASONS.s_name AS season_name, + COUNT(*) AS n_events +FROM SEASONS SEASONS +JOIN EVENTS EVENTS + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) +GROUP BY + SEASONS.s_name +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql new file mode 100644 index 000000000..4c896c87b --- /dev/null +++ b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql @@ -0,0 +1,19 @@ +WITH _T AS ( + SELECT + ERAS.er_name AS ER_NAME, + ERAS.er_start_year AS ER_START_YEAR, + EVENTS.ev_name AS EV_NAME, + ROW_NUMBER() OVER (PARTITION BY ERAS.er_name ORDER BY EVENTS.ev_dt) AS _W + FROM ERAS ERAS + JOIN EVENTS EVENTS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) +) +SELECT + ER_NAME AS era_name, + EV_NAME AS event_name +FROM _T +WHERE + _W = 1 +ORDER BY + ER_START_YEAR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql new file mode 100644 index 000000000..766e646c5 --- /dev/null +++ b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql @@ -0,0 +1,86 @@ +WITH _S0 AS ( + SELECT + s_month1 AS S_MONTH1, + s_month2 AS S_MONTH2, + s_month3 AS S_MONTH3, + s_name AS S_NAME + FROM SEASONS +), _S5 AS ( + SELECT + ev_dt AS EV_DT, + ev_name AS EV_NAME + FROM EVENTS +), _S9 AS ( + SELECT + _S2.S_NAME, + SEARCHES.search_id AS SEARCH_ID + FROM _S0 _S2 + JOIN SEARCHES SEARCHES + ON _S2.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S2.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S2.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + JOIN _S5 _S5 + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(_S5.EV_NAME), '%') + JOIN _S0 _S7 + ON _S2.S_NAME = _S7.S_NAME + AND ( + _S7.S_MONTH1 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + OR _S7.S_MONTH2 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + OR _S7.S_MONTH3 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + ) +), _T1 AS ( + SELECT + _S0.S_NAME, + COUNT(_S9.SEARCH_ID) AS COUNT_SEARCH_ID + FROM _S0 _S0 + JOIN SEARCHES SEARCHES + ON _S0.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S0.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S0.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + LEFT JOIN _S9 _S9 + ON SEARCHES.search_id = _S9.SEARCH_ID AND _S0.S_NAME = _S9.S_NAME + GROUP BY + SEARCHES.search_id, + _S0.S_NAME +), _S16 AS ( + SELECT + S_NAME, + COUNT(*) AS N_ROWS, + SUM(( + NOT NULLIF(COUNT_SEARCH_ID, 0) IS NULL AND NULLIF(COUNT_SEARCH_ID, 0) > 0 + )) AS SUM_IS_INTRA_SEASON + FROM _T1 + GROUP BY + S_NAME +), _S17 AS ( + SELECT + _S10.S_NAME, + COUNT(*) AS N_ROWS, + SUM(_S15.S_NAME = _S10.S_NAME) AS SUM_IS_INTRA_SEASON + FROM _S0 _S10 + JOIN _S5 _S11 + ON _S10.S_MONTH1 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + OR _S10.S_MONTH2 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + OR _S10.S_MONTH3 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + JOIN SEARCHES SEARCHES + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(_S11.EV_NAME), '%') + JOIN _S0 _S15 + ON _S15.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S15.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S15.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + _S10.S_NAME +) +SELECT + _S16.S_NAME AS season_name, + ROUND(( + 100.0 * NVL(_S16.SUM_IS_INTRA_SEASON, 0) + ) / _S16.N_ROWS, 2) AS pct_season_searches, + ROUND(( + 100.0 * NVL(_S17.SUM_IS_INTRA_SEASON, 0) + ) / NVL(_S17.N_ROWS, 0), 2) AS pct_event_searches +FROM _S16 _S16 +LEFT JOIN _S17 _S17 + ON _S16.S_NAME = _S17.S_NAME +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql new file mode 100644 index 000000000..02aa44615 --- /dev/null +++ b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql @@ -0,0 +1,29 @@ +WITH _T2 AS ( + SELECT + SEARCHES.search_engine AS SEARCH_ENGINE, + TIMES.t_name AS T_NAME, + COUNT(*) AS N_ROWS + FROM TIMES TIMES + JOIN SEARCHES SEARCHES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + SEARCHES.search_engine, + TIMES.t_name +), _T AS ( + SELECT + SEARCH_ENGINE, + T_NAME, + N_ROWS, + ROW_NUMBER() OVER (PARTITION BY T_NAME ORDER BY N_ROWS DESC, SEARCH_ENGINE) AS _W + FROM _T2 +) +SELECT + T_NAME AS tod, + SEARCH_ENGINE AS search_engine, + N_ROWS AS n_searches +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql new file mode 100644 index 000000000..9299070ad --- /dev/null +++ b/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql @@ -0,0 +1,28 @@ +WITH _T1 AS ( + SELECT + EVENTS.ev_typ AS EV_TYP, + USERS.user_region AS USER_REGION, + COUNT(DISTINCT SEARCHES.search_id) AS NDISTINCT_SEARCH_ID + FROM EVENTS EVENTS + JOIN SEARCHES SEARCHES + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN USERS USERS + ON SEARCHES.search_user_id = USERS.user_id + GROUP BY + EVENTS.ev_typ, + USERS.user_region +), _T AS ( + SELECT + EV_TYP, + USER_REGION, + NDISTINCT_SEARCH_ID, + ROW_NUMBER() OVER (PARTITION BY USER_REGION ORDER BY NDISTINCT_SEARCH_ID DESC) AS _W + FROM _T1 +) +SELECT + USER_REGION AS region, + EV_TYP AS event_type, + NDISTINCT_SEARCH_ID AS n_searches +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql new file mode 100644 index 000000000..94566b070 --- /dev/null +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql @@ -0,0 +1,19 @@ +WITH _S0 AS ( + SELECT + ev_dt AS EV_DT, + ev_key AS EV_KEY + FROM EVENTS +) +SELECT + COUNT(DISTINCT _S0.EV_KEY) AS n_events +FROM _S0 _S0 +JOIN TIMES TIMES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(_S0.EV_DT AS DATETIME)) + AND TIMES.t_name = 'Pre-Dawn' + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(_S0.EV_DT AS DATETIME)) +JOIN _S0 _S2 + ON _S0.EV_KEY = _S2.EV_KEY +JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(_S2.EV_DT AS DATETIME)) + AND ERAS.er_name = 'Cold War' + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(_S2.EV_DT AS DATETIME)) diff --git a/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql b/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql new file mode 100644 index 000000000..46530b80a --- /dev/null +++ b/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql @@ -0,0 +1,29 @@ +WITH _S0 AS ( + SELECT + user_id AS USER_ID, + user_name AS USER_NAME + FROM USERS +), _S1 AS ( + SELECT + search_string AS SEARCH_STRING, + search_user_id AS SEARCH_USER_ID + FROM SEARCHES +) +SELECT + ANY_VALUE(_S0.USER_NAME) AS user_name, + COUNT(DISTINCT _S7.USER_ID) AS n_other_users +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.USER_ID = _S1.SEARCH_USER_ID +JOIN EVENTS EVENTS + ON LOWER(_S1.SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') +JOIN _S1 _S5 + ON LOWER(_S5.SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') +JOIN _S0 _S7 + ON _S0.USER_NAME <> _S7.USER_NAME AND _S5.SEARCH_USER_ID = _S7.USER_ID +GROUP BY + _S0.USER_ID +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 7 ROWS ONLY diff --git a/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql b/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql new file mode 100644 index 000000000..ab4c80c99 --- /dev/null +++ b/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql @@ -0,0 +1,35 @@ +WITH _S0 AS ( + SELECT + user_id AS USER_ID, + user_name AS USER_NAME + FROM USERS +), _T2 AS ( + SELECT + _S0.USER_ID, + ANY_VALUE(SEARCHES.search_user_id) AS ANYTHING_SEARCH_USER_ID, + ANY_VALUE(_S0.USER_NAME) AS ANYTHING_USER_NAME + FROM _S0 _S0 + JOIN SEARCHES SEARCHES + ON SEARCHES.search_user_id = _S0.USER_ID + JOIN EVENTS EVENTS + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN SEARCHES SEARCHES_2 + ON LOWER(SEARCHES_2.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN _S0 _S7 + ON SEARCHES_2.search_user_id = _S7.USER_ID AND _S0.USER_NAME <> _S7.USER_NAME + GROUP BY + SEARCHES.search_id, + _S0.USER_ID +) +SELECT + ANY_VALUE(ANYTHING_USER_NAME) AS user_name, + COUNT(*) AS n_searches +FROM _T2 +WHERE + ANYTHING_SEARCH_USER_ID = USER_ID +GROUP BY + USER_ID +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 4 ROWS ONLY diff --git a/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql new file mode 100644 index 000000000..55a1b08b5 --- /dev/null +++ b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql @@ -0,0 +1,20 @@ +WITH _T0 AS ( + SELECT + TIMES.t_name AS T_NAME, + ANY_VALUE(TIMES.t_start_hour) AS ANYTHING_T_START_HOUR, + COUNT(*) AS N_ROWS + FROM TIMES TIMES + JOIN SEARCHES SEARCHES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + TIMES.t_name +) +SELECT + T_NAME AS tod, + ROUND(( + 100.0 * N_ROWS + ) / SUM(N_ROWS) OVER (), 2) AS pct_searches +FROM _T0 +ORDER BY + ANYTHING_T_START_HOUR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql new file mode 100644 index 000000000..518f51a92 --- /dev/null +++ b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql @@ -0,0 +1,22 @@ +WITH _T0 AS ( + SELECT + TIMES.t_name AS T_NAME, + ANY_VALUE(TIMES.t_start_hour) AS ANYTHING_T_START_HOUR, + AVG(SEARCHES.search_num_results) AS AVG_SEARCH_NUM_RESULTS, + COUNT(*) AS N_ROWS + FROM TIMES TIMES + JOIN SEARCHES SEARCHES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + TIMES.t_name +) +SELECT + T_NAME AS tod, + ROUND(( + 100.0 * N_ROWS + ) / SUM(N_ROWS) OVER (), 2) AS pct_searches, + ROUND(AVG_SEARCH_NUM_RESULTS, 2) AS avg_results +FROM _T0 +ORDER BY + ANYTHING_T_START_HOUR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql b/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql new file mode 100644 index 000000000..da14a0d97 --- /dev/null +++ b/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql @@ -0,0 +1,15 @@ +SELECT + EVENTS.ev_typ AS event_type, + COUNT(*) AS n_events +FROM EVENTS EVENTS +JOIN SEASONS SEASONS + ON ( + SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + ) + AND SEASONS.s_name = 'Summer' +GROUP BY + EVENTS.ev_typ +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql new file mode 100644 index 000000000..9c93974e4 --- /dev/null +++ b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql @@ -0,0 +1,23 @@ +WITH _S0 AS ( + SELECT DISTINCT + search_engine AS SEARCH_ENGINE + FROM SEARCHES +), _S1 AS ( + SELECT + search_engine AS SEARCH_ENGINE, + COUNT(DISTINCT search_user_id) AS NDISTINCT_SEARCH_USER_ID + FROM SEARCHES + WHERE + EXTRACT(YEAR FROM CAST(search_ts AS DATETIME)) <= 2019 + AND EXTRACT(YEAR FROM CAST(search_ts AS DATETIME)) >= 2010 + GROUP BY + search_engine +) +SELECT + _S0.SEARCH_ENGINE AS engine, + NVL(_S1.NDISTINCT_SEARCH_USER_ID, 0) AS n_users +FROM _S0 _S0 +LEFT JOIN _S1 _S1 + ON _S0.SEARCH_ENGINE = _S1.SEARCH_ENGINE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql new file mode 100644 index 000000000..30588f15b --- /dev/null +++ b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql @@ -0,0 +1,30 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(SEARCHES.search_user_id) AS ANYTHING_SEARCH_USER_ID + FROM SEARCHES SEARCHES + JOIN EVENTS EVENTS + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_name = 'Cold War' + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + GROUP BY + SEARCHES.search_id +), _S5 AS ( + SELECT + ANYTHING_SEARCH_USER_ID, + COUNT(*) AS N_ROWS + FROM _T1 + GROUP BY + ANYTHING_SEARCH_USER_ID +) +SELECT + USERS.user_name, + _S5.N_ROWS AS n_cold_war_searches +FROM USERS USERS +JOIN _S5 _S5 + ON USERS.user_id = _S5.ANYTHING_SEARCH_USER_ID +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/extract_colors_oracle.sql b/tests/test_sql_refsols/extract_colors_oracle.sql new file mode 100644 index 000000000..89b70ac66 --- /dev/null +++ b/tests/test_sql_refsols/extract_colors_oracle.sql @@ -0,0 +1,283 @@ +WITH _S0 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 1 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S0 + WHERE + rest <> '' +), _S1 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S0 +), _S2 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 2 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S2 + WHERE + rest <> '' +), _S3 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S2 +), _S4 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 3 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S4 + WHERE + rest <> '' +), _S5 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S4 +), _S6 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 4 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S6 + WHERE + rest <> '' +), _S7 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S6 +), _S8 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 5 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S8 + WHERE + rest <> '' +), _S9 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S8 +), _S10 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 6 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S10 + WHERE + rest <> '' +), _S11 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S10 +) +SELECT + p_partkey AS key, + UPPER( + ( + SELECT + _S0.PART + FROM _S0 _S0 + CROSS JOIN _S1 _S1 + WHERE + _S0.PART_INDEX <> 0 + AND _S0.PART_INDEX = CASE + WHEN _S0.IDX > 0 + THEN _S0.IDX + WHEN _S0.IDX < 0 + THEN _S1.TOTAL_PARTS + _S0.IDX + 1 + ELSE 1 + END + ) + ) AS c1, + UPPER( + ( + SELECT + _S2.PART + FROM _S2 _S2 + CROSS JOIN _S3 _S3 + WHERE + _S2.PART_INDEX <> 0 + AND _S2.PART_INDEX = CASE + WHEN _S2.IDX > 0 + THEN _S2.IDX + WHEN _S2.IDX < 0 + THEN _S3.TOTAL_PARTS + _S2.IDX + 1 + ELSE 1 + END + ) + ) AS c2, + UPPER( + ( + SELECT + _S4.PART + FROM _S4 _S4 + CROSS JOIN _S5 _S5 + WHERE + _S4.PART_INDEX <> 0 + AND _S4.PART_INDEX = CASE + WHEN _S4.IDX > 0 + THEN _S4.IDX + WHEN _S4.IDX < 0 + THEN _S5.TOTAL_PARTS + _S4.IDX + 1 + ELSE 1 + END + ) + ) AS c3, + UPPER( + ( + SELECT + _S6.PART + FROM _S6 _S6 + CROSS JOIN _S7 _S7 + WHERE + _S6.PART_INDEX <> 0 + AND _S6.PART_INDEX = CASE + WHEN _S6.IDX > 0 + THEN _S6.IDX + WHEN _S6.IDX < 0 + THEN _S7.TOTAL_PARTS + _S6.IDX + 1 + ELSE 1 + END + ) + ) AS c4, + UPPER( + ( + SELECT + _S8.PART + FROM _S8 _S8 + CROSS JOIN _S9 _S9 + WHERE + _S8.PART_INDEX <> 0 + AND _S8.PART_INDEX = CASE + WHEN _S8.IDX > 0 + THEN _S8.IDX + WHEN _S8.IDX < 0 + THEN _S9.TOTAL_PARTS + _S8.IDX + 1 + ELSE 1 + END + ) + ) AS c5, + UPPER( + ( + SELECT + _S10.PART + FROM _S10 _S10 + CROSS JOIN _S11 _S11 + WHERE + _S10.PART_INDEX <> 0 + AND _S10.PART_INDEX = CASE + WHEN _S10.IDX > 0 + THEN _S10.IDX + WHEN _S10.IDX < 0 + THEN _S11.TOTAL_PARTS + _S10.IDX + 1 + ELSE 1 + END + ) + ) AS c6 +FROM TPCH.PART +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/first_order_in_year_oracle.sql b/tests/test_sql_refsols/first_order_in_year_oracle.sql new file mode 100644 index 000000000..b7bff4dc7 --- /dev/null +++ b/tests/test_sql_refsols/first_order_in_year_oracle.sql @@ -0,0 +1,19 @@ +WITH _T AS ( + SELECT + o_orderdate AS O_ORDERDATE, + o_orderkey AS O_ORDERKEY, + LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS _W, + LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS _W_2 + FROM TPCH.ORDERS + WHERE + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 +) +SELECT + O_ORDERDATE AS order_date, + O_ORDERKEY AS key +FROM _T +WHERE + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) <> EXTRACT(YEAR FROM CAST(_W_2 AS DATETIME)) + OR _W IS NULL +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/first_order_per_customer_oracle.sql b/tests/test_sql_refsols/first_order_per_customer_oracle.sql new file mode 100644 index 000000000..e13ddceda --- /dev/null +++ b/tests/test_sql_refsols/first_order_per_customer_oracle.sql @@ -0,0 +1,20 @@ +WITH _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + o_totalprice AS O_TOTALPRICE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate, o_orderkey) AS _W + FROM TPCH.ORDERS +) +SELECT + CUSTOMER.c_name AS name, + _T.O_ORDERDATE AS first_order_date, + _T.O_TOTALPRICE AS first_order_price +FROM TPCH.CUSTOMER CUSTOMER +JOIN _T _T + ON CUSTOMER.c_custkey = _T.O_CUSTKEY AND _T._W = 1 +WHERE + CUSTOMER.c_acctbal >= 9000.0 +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/floor_and_ceil_2_oracle.sql b/tests/test_sql_refsols/floor_and_ceil_2_oracle.sql new file mode 100644 index 000000000..9bf1dda59 --- /dev/null +++ b/tests/test_sql_refsols/floor_and_ceil_2_oracle.sql @@ -0,0 +1,9 @@ +SELECT + ps_suppkey AS supplier_key, + ps_partkey AS part_key, + FLOOR(ps_availqty) AS complete_parts, + CEIL(ps_supplycost * FLOOR(ps_availqty)) AS total_cost +FROM TPCH.PARTSUPP +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/floor_and_ceil_oracle.sql b/tests/test_sql_refsols/floor_and_ceil_oracle.sql new file mode 100644 index 000000000..fbccc9e04 --- /dev/null +++ b/tests/test_sql_refsols/floor_and_ceil_oracle.sql @@ -0,0 +1,11 @@ +SELECT + FLOOR(5.6) AS floor_frac, + CEIL(5.4) AS ceil_frac, + FLOOR(-5.4) AS floor_frac_neg, + CEIL(-5.6) AS ceil_frac_neg, + FLOOR(6) AS floor_int, + CEIL(6) AS ceil_int, + FLOOR(-6) AS floor_int_neg, + CEIL(-6) AS ceil_int_neg +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/get_part_single_oracle.sql b/tests/test_sql_refsols/get_part_single_oracle.sql new file mode 100644 index 000000000..5b24c77cb --- /dev/null +++ b/tests/test_sql_refsols/get_part_single_oracle.sql @@ -0,0 +1,49 @@ +WITH _S0 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + SBCUSTNAME AS REST, + ' ' AS DELIM, + -1 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S0 + WHERE + rest <> '' +), _S1 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S0 +) +SELECT + ( + SELECT + _S0.PART + FROM _S0 _S0 + CROSS JOIN _S1 _S1 + WHERE + _S0.PART_INDEX <> 0 + AND _S0.PART_INDEX = CASE + WHEN _S0.IDX > 0 + THEN _S0.IDX + WHEN _S0.IDX < 0 + THEN _S1.TOTAL_PARTS + _S0.IDX + 1 + ELSE 1 + END + ) AS last_name +FROM MAIN.SBCUSTOMER +WHERE + sbcustname = 'Alex Rodriguez' diff --git a/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..5f50f8fab --- /dev/null +++ b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql @@ -0,0 +1,51 @@ +WITH _T0 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY CASE WHEN c_acctbal >= 0 THEN c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN c_acctbal >= 0 THEN c_acctbal ELSE NULL END) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN c_acctbal >= 0 THEN c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_5, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(c_acctbal) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN c_acctbal + ELSE NULL + END AS EXPR_6, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY CASE WHEN c_acctbal < 0 THEN c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN c_acctbal < 0 THEN c_acctbal ELSE NULL END) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN c_acctbal < 0 THEN c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_7 + FROM TPCH.CUSTOMER +) +SELECT + COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS n_red_acctbal, + COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS n_black_acctbal, + AVG(EXPR_7) AS median_red_acctbal, + AVG(EXPR_5) AS median_black_acctbal, + AVG(EXPR_6) AS median_overall_acctbal +FROM _T0 diff --git a/tests/test_sql_refsols/highest_priority_per_year_oracle.sql b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql new file mode 100644 index 000000000..a8dc8028e --- /dev/null +++ b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql @@ -0,0 +1,34 @@ +WITH _T3 AS ( + SELECT + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + o_orderpriority AS O_ORDERPRIORITY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), + o_orderpriority +), _T2 AS ( + SELECT + O_ORDERPRIORITY, + YEAR_O_ORDERDATE, + ( + 100.0 * N_ROWS + ) / SUM(N_ROWS) OVER (PARTITION BY YEAR_O_ORDERDATE) AS PRIORITY_PCT + FROM _T3 +), _T AS ( + SELECT + O_ORDERPRIORITY, + YEAR_O_ORDERDATE, + PRIORITY_PCT, + ROW_NUMBER() OVER (PARTITION BY YEAR_O_ORDERDATE ORDER BY PRIORITY_PCT DESC) AS _W + FROM _T2 +) +SELECT + YEAR_O_ORDERDATE AS order_year, + O_ORDERPRIORITY AS highest_priority, + PRIORITY_PCT AS priority_pct +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/hour_minute_day_oracle.sql b/tests/test_sql_refsols/hour_minute_day_oracle.sql new file mode 100644 index 000000000..f61e48ec1 --- /dev/null +++ b/tests/test_sql_refsols/hour_minute_day_oracle.sql @@ -0,0 +1,13 @@ +SELECT + SBTRANSACTION.sbtxid AS transaction_id, + EXTRACT(HOUR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr0, + EXTRACT(MINUTE FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr1, + EXTRACT(SECOND FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr2 +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickersymbol IN ('AAPL', 'GOOGL', 'NFLX') +WHERE + EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql new file mode 100644 index 000000000..c66d1c7d0 --- /dev/null +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql @@ -0,0 +1,12 @@ +SELECT + NVL("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, + CALCULATE.".WHERE" AS _where, + CALCULATE."LIKE" AS _like, + CALCULATE.datetime, + "WHERE".abs, + "WHERE".has +FROM KEYWORDS."WHERE" "WHERE" +JOIN KEYWORDS.CALCULATE CALCULATE + ON "WHERE".".CALCULATE" = CALCULATE.".WHERE" +WHERE + "WHERE".".CALCULATE" = 4 AND "WHERE".present IS NULL diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql new file mode 100644 index 000000000..2b4d0af84 --- /dev/null +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql @@ -0,0 +1,12 @@ +SELECT + "CAST".id2 AS id1, + "CAST".id AS id2, + "lowercase_detail"."select" AS fk1_select, + "lowercase_detail"."as" AS fk1_as, + lowercase_detail_2."two words" AS fk2_two_words +FROM KEYWORDS."CAST" "CAST" +JOIN KEYWORDS."lowercase_detail" "lowercase_detail" + ON "CAST".id2 = "lowercase_detail".id + AND "lowercase_detail"."0 = 0 and '" = '2 "0 = 0 and ''" field name' +JOIN KEYWORDS."lowercase_detail" lowercase_detail_2 + ON "CAST".id = lowercase_detail_2.id AND lowercase_detail_2.id = 1 diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql new file mode 100644 index 000000000..10b3a0514 --- /dev/null +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql @@ -0,0 +1,14 @@ +SELECT + "MixedCase_1:1"."Id" AS id_, + "MixedCase_1:1"."LowerCaseId" AS LowerCaseID, + "UPPERCASE_MASTER"."INTEGER" AS integer, + "lowercase_detail"."as" AS as_, + "UPPERCASE_MASTER"."ORDER BY" AS order_ +FROM KEYWORDS."MixedCase_1:1" "MixedCase_1:1" +JOIN KEYWORDS."lowercase_detail" "lowercase_detail" + ON "MixedCase_1:1"."LowerCaseId" = "lowercase_detail".id + AND "lowercase_detail"."as" = '10 as reserved word' +JOIN KEYWORDS."UPPERCASE_MASTER" "UPPERCASE_MASTER" + ON "MixedCase_1:1"."Id" = "UPPERCASE_MASTER".id +WHERE + "MixedCase_1:1"."(parentheses)" = '5 (parentheses)' diff --git a/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql new file mode 100644 index 000000000..a0bb869cd --- /dev/null +++ b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql @@ -0,0 +1,22 @@ +WITH _S0 AS ( + SELECT + MAX("WHERE") AS MAX_WHERE + FROM KEYWORDS."PARTITION" +), _S1 AS ( + SELECT + AVG("= ""QUOTE""") AS AVG_QUOTE, + COUNT("`cast`") AS COUNT_CAST, + MAX("`name""[") AS MAX_NAME, + MIN("= ""QUOTE""") AS MIN_QUOTE, + SUM("`name""[") AS SUM_NAME + FROM KEYWORDS."""QUOTED TABLE_NAME""" +) +SELECT + _S0.MAX_WHERE AS max_where, + _S1.MIN_QUOTE AS min_quote, + _S1.MAX_NAME AS max_name, + _S1.COUNT_CAST AS count_cast, + _S1.AVG_QUOTE AS quote_avg, + NVL(_S1.SUM_NAME, 0) AS sum_name +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql b/tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql new file mode 100644 index 000000000..961b216cd --- /dev/null +++ b/tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql @@ -0,0 +1,9 @@ +SELECT + "COUNT".node, + "CAST".types, + 2.0 AS expr +FROM KEYWORDS."COUNT" "COUNT" +JOIN KEYWORDS."CAST" "CAST" + ON "CAST".pk_field_name = "COUNT".this +WHERE + "COUNT".node = 4071 diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql new file mode 100644 index 000000000..1e6f25015 --- /dev/null +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql @@ -0,0 +1,12 @@ +SELECT + """," AS dbl_quote_dot, + "." AS dot, + "." + NVL("FLOAT", str, 1) AS addition, + "__col__" AS col, + "__col1__" AS col1, + def AS def_, + del AS __del__, + "__init__" +FROM KEYWORDS."COUNT" +WHERE + "int" = 8051 diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql b/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql new file mode 100644 index 000000000..632332320 --- /dev/null +++ b/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql @@ -0,0 +1,12 @@ +SELECT + """QUOTED TABLE_NAME"""."`cast`" AS cast_, + """QUOTED TABLE_NAME"""."`name""[" AS name, + """QUOTED TABLE_NAME"""."= ""QUOTE""" AS quote_, + "lowercase_detail"."0 = 0 and '" AS _0_0_and, + "lowercase_detail"."as" AS as_ +FROM KEYWORDS."""QUOTED TABLE_NAME""" """QUOTED TABLE_NAME""" +JOIN KEYWORDS."lowercase_detail" "lowercase_detail" + ON """QUOTED TABLE_NAME"""."`name""[" = "lowercase_detail".id +WHERE + """QUOTED TABLE_NAME"""."= ""QUOTE""" = 4 + AND """QUOTED TABLE_NAME"""."`name""[" = 7 diff --git a/tests/test_sql_refsols/keywords_single_quote_use_oracle.sql b/tests/test_sql_refsols/keywords_single_quote_use_oracle.sql new file mode 100644 index 000000000..fe99680de --- /dev/null +++ b/tests/test_sql_refsols/keywords_single_quote_use_oracle.sql @@ -0,0 +1,5 @@ +SELECT + description +FROM KEYWORDS.MASTER +WHERE + description <> 'One-One ''master row' AND id1 = 1 AND id2 = 1 diff --git a/tests/test_sql_refsols/many_net_filter_10_oracle.sql b/tests/test_sql_refsols/many_net_filter_10_oracle.sql new file mode 100644 index 000000000..dcdf211d0 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_10_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey AND NATION_2.n_regionkey = 2 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_11_oracle.sql b/tests/test_sql_refsols/many_net_filter_11_oracle.sql new file mode 100644 index 000000000..dfe91cb98 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_11_oracle.sql @@ -0,0 +1,13 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey AND NATION.n_regionkey < 3 +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey AND NATION_2.n_regionkey > 0 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey + AND NOT CUSTOMER.c_nationkey IN (1, 4, 7, 10, 13, 16, 19, 22) +WHERE + NOT SUPPLIER.s_nationkey IN (0, 3, 6, 9, 12, 15, 18, 21, 24) diff --git a/tests/test_sql_refsols/many_net_filter_1_oracle.sql b/tests/test_sql_refsols/many_net_filter_1_oracle.sql new file mode 100644 index 000000000..4855aa6fc --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_1_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = SUPPLIER.s_nationkey +WHERE + SUPPLIER.s_nationkey = 1 diff --git a/tests/test_sql_refsols/many_net_filter_2_oracle.sql b/tests/test_sql_refsols/many_net_filter_2_oracle.sql new file mode 100644 index 000000000..31d53e2ae --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_2_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = SUPPLIER.s_nationkey +WHERE + SUPPLIER.s_nationkey = 2 diff --git a/tests/test_sql_refsols/many_net_filter_3_oracle.sql b/tests/test_sql_refsols/many_net_filter_3_oracle.sql new file mode 100644 index 000000000..345668635 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_3_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = 3 + AND CUSTOMER.c_nationkey = SUPPLIER.s_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_4_oracle.sql b/tests/test_sql_refsols/many_net_filter_4_oracle.sql new file mode 100644 index 000000000..4d1be14b4 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_4_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN _S1 _S1 + ON SUPPLIER.s_nationkey = _S1.N_NATIONKEY +JOIN _S1 _S3 + ON _S1.N_REGIONKEY = _S3.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY +WHERE + SUPPLIER.s_nationkey = 4 diff --git a/tests/test_sql_refsols/many_net_filter_5_oracle.sql b/tests/test_sql_refsols/many_net_filter_5_oracle.sql new file mode 100644 index 000000000..dc6644eae --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_5_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = 5 AND NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_6_oracle.sql b/tests/test_sql_refsols/many_net_filter_6_oracle.sql new file mode 100644 index 000000000..9b5320dc4 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_6_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey AND NATION_2.n_nationkey = 6 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_7_oracle.sql b/tests/test_sql_refsols/many_net_filter_7_oracle.sql new file mode 100644 index 000000000..edf363166 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_7_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN _S1 _S1 + ON SUPPLIER.s_nationkey = _S1.N_NATIONKEY +JOIN _S1 _S3 + ON _S1.N_REGIONKEY = _S3.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = 7 + AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY diff --git a/tests/test_sql_refsols/many_net_filter_8_oracle.sql b/tests/test_sql_refsols/many_net_filter_8_oracle.sql new file mode 100644 index 000000000..71d14b5dd --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_8_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey AND NATION.n_regionkey = 0 +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_9_oracle.sql b/tests/test_sql_refsols/many_net_filter_9_oracle.sql new file mode 100644 index 000000000..7e6408b59 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_9_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey AND NATION.n_regionkey = 1 +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql new file mode 100644 index 000000000..b35180fcb --- /dev/null +++ b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql @@ -0,0 +1,52 @@ +WITH _T7 AS ( + SELECT + o_orderdate AS O_ORDERDATE, + o_orderpriority AS O_ORDERPRIORITY, + o_totalprice AS O_TOTALPRICE + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' +), _T5 AS ( + SELECT + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM _T7 + GROUP BY + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) +), _T4 AS ( + SELECT + SUM_O_TOTALPRICE, + YEAR_O_ORDERDATE, + LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE) AS NEXT_YEAR_TOTAL_SPENT + FROM _T5 +), _T2 AS ( + SELECT + EXTRACT(MONTH FROM CAST(_T8.O_ORDERDATE AS DATETIME)) AS MONTH_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + SUM(_T8.O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM _T4 _T4 + JOIN _T7 _T8 + ON _T4.YEAR_O_ORDERDATE = EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) + WHERE + _T4.NEXT_YEAR_TOTAL_SPENT < NVL(_T4.SUM_O_TOTALPRICE, 0) + GROUP BY + EXTRACT(MONTH FROM CAST(_T8.O_ORDERDATE AS DATETIME)), + EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) +), _T AS ( + SELECT + MONTH_O_ORDERDATE, + YEAR_O_ORDERDATE, + SUM_O_TOTALPRICE, + LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS _W, + LAG(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS _W_2 + FROM _T2 +) +SELECT + YEAR_O_ORDERDATE AS year, + MONTH_O_ORDERDATE AS month +FROM _T +WHERE + _W < NVL(SUM_O_TOTALPRICE, 0) AND _W_2 < NVL(SUM_O_TOTALPRICE, 0) +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/n_orders_first_day_oracle.sql b/tests/test_sql_refsols/n_orders_first_day_oracle.sql new file mode 100644 index 000000000..9c364559c --- /dev/null +++ b/tests/test_sql_refsols/n_orders_first_day_oracle.sql @@ -0,0 +1,10 @@ +WITH _T AS ( + SELECT + RANK() OVER (ORDER BY o_orderdate) AS _W + FROM TPCH.ORDERS +) +SELECT + COUNT(*) AS n_orders +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..ef73f8bb2 --- /dev/null +++ b/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql @@ -0,0 +1,62 @@ +WITH _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_nationkey AS C_NATIONKEY, + NATION.n_name AS N_NAME, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_5, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_6, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_7 + FROM TPCH.NATION NATION + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AMERICA' + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + ANY_VALUE(N_NAME) AS nation_name, + COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS n_red_acctbal, + COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS n_black_acctbal, + AVG(EXPR_7) AS median_red_acctbal, + AVG(EXPR_5) AS median_black_acctbal, + AVG(EXPR_6) AS median_overall_acctbal +FROM _T1 +GROUP BY + C_NATIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/nation_best_order_oracle.sql b/tests/test_sql_refsols/nation_best_order_oracle.sql new file mode 100644 index 000000000..94b746662 --- /dev/null +++ b/tests/test_sql_refsols/nation_best_order_oracle.sql @@ -0,0 +1,36 @@ +WITH _T3 AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ORDERS.o_totalprice AS O_TOTALPRICE, + ( + 100.0 * ORDERS.o_totalprice + ) / SUM(ORDERS.o_totalprice) OVER (PARTITION BY CUSTOMER.c_nationkey) AS VALUE_PERCENTAGE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T AS ( + SELECT + C_NAME, + C_NATIONKEY, + O_ORDERKEY, + O_TOTALPRICE, + VALUE_PERCENTAGE, + ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY O_TOTALPRICE DESC) AS _W + FROM _T3 +) +SELECT + NATION.n_name AS nation_name, + _T.C_NAME AS customer_name, + _T.O_ORDERKEY AS order_key, + _T.O_TOTALPRICE AS order_value, + _T.VALUE_PERCENTAGE AS value_percentage +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' +JOIN _T _T + ON NATION.n_nationkey = _T.C_NATIONKEY AND _T._W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/numerical_functions_oracle.sql b/tests/test_sql_refsols/numerical_functions_oracle.sql new file mode 100644 index 000000000..beb2c6395 --- /dev/null +++ b/tests/test_sql_refsols/numerical_functions_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ABS(c_acctbal) AS abs_value, + ROUND(c_acctbal, 2) AS round_value, + CEIL(c_acctbal) AS ceil_value, + FLOOR(c_acctbal) AS floor_value, + POWER(c_acctbal, 2) AS power_value, + POWER(c_acctbal, 0.5) AS sqrt_value, + CASE WHEN c_acctbal = 0 THEN 0 ELSE CASE WHEN c_acctbal < 0 THEN -1 ELSE 1 END END AS sign_value, + LEAST(c_acctbal, 0) AS smallest_value, + GREATEST(c_acctbal, 0) AS largest_value +FROM TPCH.CUSTOMER diff --git a/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql new file mode 100644 index 000000000..32fab572f --- /dev/null +++ b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql @@ -0,0 +1,13 @@ +SELECT + AVG( + DATEDIFF( + CAST(LEAST(LINEITEM.l_commitdate, LINEITEM.l_receiptdate) AS DATETIME), + CAST(ORDERS.o_orderdate AS DATETIME), + DAY + ) + ) AS avg_gap +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.ORDERS ORDERS + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +WHERE + LINEITEM.l_shipmode = 'RAIL' diff --git a/tests/test_sql_refsols/order_info_per_priority_oracle.sql b/tests/test_sql_refsols/order_info_per_priority_oracle.sql new file mode 100644 index 000000000..4824c7fde --- /dev/null +++ b/tests/test_sql_refsols/order_info_per_priority_oracle.sql @@ -0,0 +1,19 @@ +WITH _T AS ( + SELECT + o_orderkey AS O_ORDERKEY, + o_orderpriority AS O_ORDERPRIORITY, + o_totalprice AS O_TOTALPRICE, + ROW_NUMBER() OVER (PARTITION BY o_orderpriority ORDER BY o_totalprice DESC) AS _W + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +) +SELECT + O_ORDERPRIORITY AS order_priority, + O_ORDERKEY AS order_key, + O_TOTALPRICE AS order_total_price +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/order_quarter_test_oracle.sql b/tests/test_sql_refsols/order_quarter_test_oracle.sql new file mode 100644 index 000000000..3276ffee3 --- /dev/null +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -0,0 +1,18 @@ +SELECT + o_orderdate AS order_date, + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATETIME)) AS quarter, + TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER') AS quarter_start, + DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 1, 'QUARTER') AS next_quarter, + DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 1, QUARTER) AS prev_quarter, + DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 2, 'QUARTER') AS two_quarters_ahead, + DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 2, QUARTER) AS two_quarters_behind, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1995-01-01' AS TIMESTAMP), QUARTER) AS quarters_since_1995, + DATEDIFF(CAST('2000-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), QUARTER) AS quarters_until_2000, + DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 4, QUARTER) AS same_quarter_prev_year, + DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 4, 'QUARTER') AS same_quarter_next_year +FROM TPCH.ORDERS +WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1995 +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql new file mode 100644 index 000000000..a76fa5d8e --- /dev/null +++ b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql @@ -0,0 +1,37 @@ +WITH _S4 AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + o_orderkey AS O_ORDERKEY + FROM TPCH.ORDERS +), _T AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + CUSTOMER.c_name AS C_NAME, + _S3.O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY _S3.O_CUSTKEY ORDER BY _S3.O_ORDERDATE, _S3.O_ORDERKEY) AS _W + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'VIETNAM' + JOIN _S4 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY +), _S5 AS ( + SELECT + C_CUSTKEY, + C_NAME, + O_ORDERDATE + FROM _T + WHERE + _W = 1 +) +SELECT + _S5.C_NAME AS customer_name, + _S4.O_ORDERKEY AS order_key, + DATEDIFF(CAST(_S4.O_ORDERDATE AS DATETIME), CAST(_S5.O_ORDERDATE AS DATETIME), DAY) AS days_since_first_order +FROM _S4 _S4 +LEFT JOIN _S5 _S5 + ON _S4.O_CUSTKEY = _S5.C_CUSTKEY +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/part_cross_part_a_oracle.sql b/tests/test_sql_refsols/part_cross_part_a_oracle.sql new file mode 100644 index 000000000..cb017e43d --- /dev/null +++ b/tests/test_sql_refsols/part_cross_part_a_oracle.sql @@ -0,0 +1,35 @@ +WITH _S0 AS ( + SELECT DISTINCT + sbtickerexchange AS SBTICKEREXCHANGE + FROM MAIN.SBTICKER +), _S9 AS ( + SELECT + SBCUSTOMER.sbcustid AS SBCUSTID, + _S2.SBTICKEREXCHANGE, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerexchange = _S2.SBTICKEREXCHANGE + AND SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + GROUP BY + SBCUSTOMER.sbcustid, + _S2.SBTICKEREXCHANGE +) +SELECT + SBCUSTOMER.sbcuststate AS state, + _S0.SBTICKEREXCHANGE AS exchange, + NVL(SUM(_S9.N_ROWS), 0) AS n +FROM _S0 _S0 +CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S9 _S9 + ON SBCUSTOMER.sbcustid = _S9.SBCUSTID + AND _S0.SBTICKEREXCHANGE = _S9.SBTICKEREXCHANGE +GROUP BY + SBCUSTOMER.sbcuststate, + _S0.SBTICKEREXCHANGE +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_b_oracle.sql b/tests/test_sql_refsols/part_cross_part_b_oracle.sql new file mode 100644 index 000000000..aff0ebb50 --- /dev/null +++ b/tests/test_sql_refsols/part_cross_part_b_oracle.sql @@ -0,0 +1,46 @@ +WITH _S0 AS ( + SELECT DISTINCT + sbcuststate AS SBCUSTSTATE + FROM MAIN.SBCUSTOMER +), _T2 AS ( + SELECT + sbtxdatetime AS SBTXDATETIME + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +), _S1 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S3 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S9 AS ( + SELECT + _S3.MONTH, + _S2.SBCUSTSTATE, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + CROSS JOIN _S3 _S3 + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + AND _S3.MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + AND SBCUSTOMER.sbcuststate = _S2.SBCUSTSTATE + GROUP BY + _S3.MONTH, + _S2.SBCUSTSTATE +) +SELECT + _S0.SBCUSTSTATE AS state, + _S1.MONTH AS month_of_year, + SUM(NVL(_S9.N_ROWS, 0)) OVER (PARTITION BY _S0.SBCUSTSTATE ORDER BY _S1.MONTH ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +LEFT JOIN _S9 _S9 + ON _S0.SBCUSTSTATE = _S9.SBCUSTSTATE AND _S1.MONTH = _S9.MONTH +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_c_oracle.sql b/tests/test_sql_refsols/part_cross_part_c_oracle.sql new file mode 100644 index 000000000..44e2df7f9 --- /dev/null +++ b/tests/test_sql_refsols/part_cross_part_c_oracle.sql @@ -0,0 +1,44 @@ +WITH _S0 AS ( + SELECT DISTINCT + sbcuststate AS SBCUSTSTATE + FROM MAIN.SBCUSTOMER +), _T2 AS ( + SELECT + sbtxdatetime AS SBTXDATETIME + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +), _S1 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S3 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S9 AS ( + SELECT + _S3.MONTH, + _S2.SBCUSTSTATE, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + CROSS JOIN _S3 _S3 + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + AND _S3.MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + AND SBCUSTOMER.sbcuststate = _S2.SBCUSTSTATE + GROUP BY + _S3.MONTH, + _S2.SBCUSTSTATE +) +SELECT + _S0.SBCUSTSTATE AS state, + MAX(NVL(_S9.N_ROWS, 0)) AS max_n +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +LEFT JOIN _S9 _S9 + ON _S0.SBCUSTSTATE = _S9.SBCUSTSTATE AND _S1.MONTH = _S9.MONTH +GROUP BY + _S0.SBCUSTSTATE diff --git a/tests/test_sql_refsols/part_reduced_size_oracle.sql b/tests/test_sql_refsols/part_reduced_size_oracle.sql new file mode 100644 index 000000000..a8675c6dd --- /dev/null +++ b/tests/test_sql_refsols/part_reduced_size_oracle.sql @@ -0,0 +1,25 @@ +WITH _S0 AS ( + SELECT + p_partkey AS P_PARTKEY, + p_retailprice AS P_RETAILPRICE, + p_size AS P_SIZE + FROM TPCH.PART + ORDER BY + CAST(p_retailprice AS INT) NULLS FIRST + FETCH FIRST 2 ROWS ONLY +) +SELECT + CAST(_S0.P_SIZE / 2.5 AS DOUBLE PRECISION) AS reduced_size, + CAST(_S0.P_RETAILPRICE AS INT) AS retail_price_int, + LISTAGG('', 'old size: ', CAST(_S0.P_SIZE AS CLOB)) AS message, + LINEITEM.l_discount AS discount, + TO_CHAR(LINEITEM.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, + TO_CHAR(LINEITEM.l_receiptdate, 'MM/DD') AS date_md, + TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MIP.M.') AS am_pm +FROM _S0 _S0 +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = _S0.P_PARTKEY +ORDER BY + 4 DESC NULLS LAST, + 5 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql new file mode 100644 index 000000000..58ed7cd20 --- /dev/null +++ b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql @@ -0,0 +1,41 @@ +WITH _T4 AS ( + SELECT + l_orderkey AS L_ORDERKEY, + l_partkey AS L_PARTKEY, + l_quantity AS L_QUANTITY, + l_shipmode AS L_SHIPMODE + FROM TPCH.LINEITEM + WHERE + l_shipmode = 'RAIL' +), _S6 AS ( + SELECT + _T4.L_PARTKEY, + ANY_VALUE(PART.p_name) AS ANYTHING_P_NAME, + SUM(_T4.L_QUANTITY) AS SUM_L_QUANTITY + FROM TPCH.PART PART + JOIN _T4 _T4 + ON PART.p_partkey = _T4.L_PARTKEY + JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 + AND ORDERS.o_orderkey = _T4.L_ORDERKEY + WHERE + PART.p_container LIKE 'SM%' + GROUP BY + _T4.L_PARTKEY +) +SELECT + ANY_VALUE(_S6.ANYTHING_P_NAME) AS name, + NVL(ANY_VALUE(_S6.SUM_L_QUANTITY), 0) AS qty_95, + NVL(SUM(_T6.L_QUANTITY), 0) AS qty_96 +FROM _S6 _S6 +JOIN _T4 _T6 + ON _S6.L_PARTKEY = _T6.L_PARTKEY +JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1996 + AND ORDERS.o_orderkey = _T6.L_ORDERKEY +GROUP BY + _T6.L_PARTKEY +ORDER BY + NVL(SUM(_T6.L_QUANTITY), 0) - NVL(ANY_VALUE(_S6.SUM_L_QUANTITY), 0) DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql new file mode 100644 index 000000000..2e021f3ea --- /dev/null +++ b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql @@ -0,0 +1,16 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + CUSTOMER.c_phone AS C_PHONE, + NTILE(100) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + C_NAME AS name +FROM _T +WHERE + C_PHONE LIKE '%00' AND _W = 95 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/percentile_nations_oracle.sql b/tests/test_sql_refsols/percentile_nations_oracle.sql new file mode 100644 index 000000000..02fa060e6 --- /dev/null +++ b/tests/test_sql_refsols/percentile_nations_oracle.sql @@ -0,0 +1,5 @@ +SELECT + n_name AS name, + NTILE(5) OVER (ORDER BY n_name) AS p1, + NTILE(5) OVER (ORDER BY n_name) AS p2 +FROM TPCH.NATION diff --git a/tests/test_sql_refsols/prev_next_regions_oracle.sql b/tests/test_sql_refsols/prev_next_regions_oracle.sql new file mode 100644 index 000000000..95d25b1a2 --- /dev/null +++ b/tests/test_sql_refsols/prev_next_regions_oracle.sql @@ -0,0 +1,9 @@ +SELECT + LAG(r_name, 2) OVER (ORDER BY r_name) AS two_preceding, + LAG(r_name, 1) OVER (ORDER BY r_name) AS one_preceding, + r_name AS current_region, + LEAD(r_name, 1) OVER (ORDER BY r_name) AS one_following, + LEAD(r_name, 2) OVER (ORDER BY r_name) AS two_following +FROM TPCH.REGION +ORDER BY + 3 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_1_oracle.sql b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql new file mode 100644 index 000000000..e44b1431c --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql @@ -0,0 +1,14 @@ +WITH _T0 AS ( + SELECT + CASE + WHEN FLOOR(0.3 * COUNT(o_totalprice) OVER ()) < ROW_NUMBER() OVER (ORDER BY o_totalprice DESC NULLS LAST) + THEN o_totalprice + ELSE NULL + END AS EXPR_1 + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 +) +SELECT + MAX(EXPR_1) AS seventieth_order_price +FROM _T0 diff --git a/tests/test_sql_refsols/quantile_function_test_2_oracle.sql b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql new file mode 100644 index 000000000..3c129aed5 --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql @@ -0,0 +1,81 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_3_oracle.sql b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql new file mode 100644 index 000000000..3c129aed5 --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql @@ -0,0 +1,81 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_4_oracle.sql b/tests/test_sql_refsols/quantile_function_test_4_oracle.sql new file mode 100644 index 000000000..1e74b3980 --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_4_oracle.sql @@ -0,0 +1,80 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000272' +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_test_1_oracle.sql b/tests/test_sql_refsols/quantile_test_1_oracle.sql new file mode 100644 index 000000000..e44b1431c --- /dev/null +++ b/tests/test_sql_refsols/quantile_test_1_oracle.sql @@ -0,0 +1,14 @@ +WITH _T0 AS ( + SELECT + CASE + WHEN FLOOR(0.3 * COUNT(o_totalprice) OVER ()) < ROW_NUMBER() OVER (ORDER BY o_totalprice DESC NULLS LAST) + THEN o_totalprice + ELSE NULL + END AS EXPR_1 + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 +) +SELECT + MAX(EXPR_1) AS seventieth_order_price +FROM _T0 diff --git a/tests/test_sql_refsols/quantile_test_2_oracle.sql b/tests/test_sql_refsols/quantile_test_2_oracle.sql new file mode 100644 index 000000000..3c129aed5 --- /dev/null +++ b/tests/test_sql_refsols/quantile_test_2_oracle.sql @@ -0,0 +1,81 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql new file mode 100644 index 000000000..6ffb981b0 --- /dev/null +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -0,0 +1,83 @@ +WITH _T2 AS ( + SELECT + pr_name AS PR_NAME, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'RubyCopper-Star' +), _S1 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _S7 AS ( + SELECT + _S3.CA_DT, + COUNT(*) AS N_ROWS + FROM _T2 _T4 + JOIN _S1 _S3 + ON _S3.CA_DT < TRUNC(DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S3.CA_DT >= _T4.PR_RELEASE + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_product_id = 800544 + AND _S3.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + GROUP BY + _S3.CA_DT +), _S22 AS ( + SELECT + TRUNC(CAST(_S1.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + SUM(_S7.N_ROWS) AS SUM_N_ROWS + FROM _T2 _T2 + JOIN _S1 _S1 + ON _S1.CA_DT < TRUNC(DATE_ADD(CAST(_T2.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S1.CA_DT >= _T2.PR_RELEASE + LEFT JOIN _S7 _S7 + ON _S1.CA_DT = _S7.CA_DT + GROUP BY + TRUNC(CAST(_S1.CA_DT AS TIMESTAMP), 'QUARTER') +), _S13 AS ( + SELECT DISTINCT + TRUNC(CAST(_S11.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + FROM _T2 _T10 + JOIN _S1 _S11 + ON _S11.CA_DT < TRUNC(DATE_ADD(CAST(_T10.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S11.CA_DT >= _T10.PR_RELEASE +), _S17 AS ( + SELECT + _S15.CA_DT + FROM _T2 _T11 + JOIN _S1 _S15 + ON _S15.CA_DT < TRUNC(DATE_ADD(CAST(_T11.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S15.CA_DT >= _T11.PR_RELEASE +), _S23 AS ( + SELECT + _S13.QUARTER, + COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID + FROM MAIN.PRODUCTS PRODUCTS + JOIN MAIN.COUNTRIES COUNTRIES + ON COUNTRIES.co_name = 'CN' + CROSS JOIN _S13 _S13 + JOIN _S17 _S17 + ON _S13.QUARTER = TRUNC(CAST(_S17.CA_DT AS TIMESTAMP), 'QUARTER') + JOIN MAIN.INCIDENTS INCIDENTS + ON COUNTRIES.co_id = INCIDENTS.in_repair_country_id + AND _S17.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = 800544 + WHERE + PRODUCTS.pr_name = 'RubyCopper-Star' + GROUP BY + _S13.QUARTER +) +SELECT + _S22.QUARTER AS quarter, + NVL(_S23.NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + NVL(_S22.SUM_N_ROWS, 0) AS n_sold, + ROUND( + SUM(NVL(_S23.NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY _S22.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S22.SUM_N_ROWS, 0)) OVER (ORDER BY _S22.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS quarter_cum +FROM _S22 _S22 +LEFT JOIN _S23 _S23 + ON _S22.QUARTER = _S23.QUARTER +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/quarter_function_test_oracle.sql b/tests/test_sql_refsols/quarter_function_test_oracle.sql new file mode 100644 index 000000000..09ae15616 --- /dev/null +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -0,0 +1,58 @@ +SELECT + 1 AS _expr0, + 1 AS _expr1, + 1 AS _expr2, + 2 AS _expr3, + 2 AS _expr4, + 2 AS _expr5, + 3 AS _expr6, + 3 AS _expr7, + 3 AS _expr8, + 4 AS _expr9, + 4 AS _expr10, + 4 AS _expr11, + 1 AS _expr12, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_jan, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_feb, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_mar, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS q2_apr, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS q2_may, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS q2_jun, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS q3_jul, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS q3_aug, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS q3_sep, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS q4_oct, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS q4_nov, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS q4_dec, + TO_DATE('2024-01-01', 'YYYY-MM-DD') AS ts_q1, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS alias1, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS alias2, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS alias3, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS alias4, + TIME_STR_TO_TIME('2023-04-02 02:00:00') AS chain1, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS chain2, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS chain3, + TIME_STR_TO_TIME('2023-04-15 12:30:45') AS plus_1q, + TIME_STR_TO_TIME('2023-07-15 12:30:45') AS plus_2q, + TO_DATE('2023-10-15', 'YYYY-MM-DD') AS plus_3q, + TIME_STR_TO_TIME('2022-10-15 12:30:45') AS minus_1q, + TIME_STR_TO_TIME('2022-07-15 12:30:45') AS minus_2q, + TO_DATE('2022-04-15', 'YYYY-MM-DD') AS minus_3q, + TO_DATE('2023-08-15', 'YYYY-MM-DD') AS syntax1, + TO_DATE('2024-02-15', 'YYYY-MM-DD') AS syntax2, + TO_DATE('2024-08-15', 'YYYY-MM-DD') AS syntax3, + TO_DATE('2022-08-15', 'YYYY-MM-DD') AS syntax4, + DATEDIFF(CAST('2023-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff1, + DATEDIFF(CAST('2023-07-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff2, + DATEDIFF(CAST('2023-10-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff3, + DATEDIFF(CAST('2023-12-31' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff4, + DATEDIFF(CAST('2024-01-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff5, + DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff6, + DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2022-10-15' AS TIMESTAMP), QUARTER) AS q_diff7, + DATEDIFF(CAST('2025-01-01' AS TIMESTAMP), CAST('2020-01-01' AS TIMESTAMP), QUARTER) AS q_diff8, + DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2023-04-15' AS TIMESTAMP), QUARTER) AS q_diff9, + DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2024-01-15' AS TIMESTAMP), QUARTER) AS q_diff10, + DATEDIFF(CAST('2023-04-01' AS TIMESTAMP), CAST('2023-03-31' AS TIMESTAMP), QUARTER) AS q_diff11, + DATEDIFF(CAST('2024-01-01' AS TIMESTAMP), CAST('2023-12-31' AS TIMESTAMP), QUARTER) AS q_diff12 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/rank_a_oracle.sql b/tests/test_sql_refsols/rank_a_oracle.sql new file mode 100644 index 000000000..9a7f14d7c --- /dev/null +++ b/tests/test_sql_refsols/rank_a_oracle.sql @@ -0,0 +1,4 @@ +SELECT + c_custkey AS id, + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC) AS rk +FROM TPCH.CUSTOMER diff --git a/tests/test_sql_refsols/rank_b_oracle.sql b/tests/test_sql_refsols/rank_b_oracle.sql new file mode 100644 index 000000000..b323162a0 --- /dev/null +++ b/tests/test_sql_refsols/rank_b_oracle.sql @@ -0,0 +1,4 @@ +SELECT + o_orderkey AS order_key, + RANK() OVER (ORDER BY o_orderpriority) AS rank +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/rank_c_oracle.sql b/tests/test_sql_refsols/rank_c_oracle.sql new file mode 100644 index 000000000..8b019c54b --- /dev/null +++ b/tests/test_sql_refsols/rank_c_oracle.sql @@ -0,0 +1,4 @@ +SELECT + o_orderdate AS order_date, + DENSE_RANK() OVER (ORDER BY o_orderdate) AS rank +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/rank_nations_by_region_oracle.sql b/tests/test_sql_refsols/rank_nations_by_region_oracle.sql new file mode 100644 index 000000000..216c55810 --- /dev/null +++ b/tests/test_sql_refsols/rank_nations_by_region_oracle.sql @@ -0,0 +1,6 @@ +SELECT + NATION.n_name AS name, + RANK() OVER (ORDER BY REGION.r_name) AS rank +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql new file mode 100644 index 000000000..fcfa12355 --- /dev/null +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + c_nationkey AS C_NATIONKEY, + COUNT(*) AS N_ROWS + FROM TPCH.CUSTOMER + GROUP BY + c_nationkey +) +SELECT + NATION.n_name AS nation_name, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY _S1.N_ROWS DESC, REGION.r_name) AS rank +FROM TPCH.NATION NATION +JOIN _S1 _S1 + ON NATION.n_nationkey = _S1.C_NATIONKEY +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey +ORDER BY + 2 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql b/tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql new file mode 100644 index 000000000..4ccacb14e --- /dev/null +++ b/tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql @@ -0,0 +1,17 @@ +SELECT + PART.p_partkey AS key, + REGION.r_name AS region, + DENSE_RANK() OVER (PARTITION BY NATION.n_regionkey ORDER BY PART.p_size DESC, PART.p_container DESC, PART.p_type DESC) AS rank +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.PARTSUPP PARTSUPP + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.PART PART + ON PART.p_partkey = PARTSUPP.ps_partkey +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST +FETCH FIRST 15 ROWS ONLY diff --git a/tests/test_sql_refsols/rank_with_filters_a_oracle.sql b/tests/test_sql_refsols/rank_with_filters_a_oracle.sql new file mode 100644 index 000000000..1fbbd4d7d --- /dev/null +++ b/tests/test_sql_refsols/rank_with_filters_a_oracle.sql @@ -0,0 +1,12 @@ +WITH _T0 AS ( + SELECT + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC, c_name) AS R, + c_name AS C_NAME + FROM TPCH.CUSTOMER +) +SELECT + C_NAME AS n, + R AS r +FROM _T0 +WHERE + C_NAME LIKE '%0' AND R <= 30 diff --git a/tests/test_sql_refsols/rank_with_filters_b_oracle.sql b/tests/test_sql_refsols/rank_with_filters_b_oracle.sql new file mode 100644 index 000000000..1fbbd4d7d --- /dev/null +++ b/tests/test_sql_refsols/rank_with_filters_b_oracle.sql @@ -0,0 +1,12 @@ +WITH _T0 AS ( + SELECT + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC, c_name) AS R, + c_name AS C_NAME + FROM TPCH.CUSTOMER +) +SELECT + C_NAME AS n, + R AS r +FROM _T0 +WHERE + C_NAME LIKE '%0' AND R <= 30 diff --git a/tests/test_sql_refsols/rank_with_filters_c_oracle.sql b/tests/test_sql_refsols/rank_with_filters_c_oracle.sql new file mode 100644 index 000000000..d113d63e3 --- /dev/null +++ b/tests/test_sql_refsols/rank_with_filters_c_oracle.sql @@ -0,0 +1,22 @@ +WITH _S0 AS ( + SELECT DISTINCT + p_size AS P_SIZE + FROM TPCH.PART + ORDER BY + 1 DESC NULLS LAST + FETCH FIRST 5 ROWS ONLY +), _T AS ( + SELECT + PART.p_size AS SIZE_1, + PART.p_name AS P_NAME, + ROW_NUMBER() OVER (PARTITION BY _S0.P_SIZE ORDER BY PART.p_retailprice DESC, PART.p_partkey) AS _W + FROM _S0 _S0 + JOIN TPCH.PART PART + ON PART.p_size = _S0.P_SIZE +) +SELECT + P_NAME AS pname, + SIZE_1 AS psize +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..e91ee8eb7 --- /dev/null +++ b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql @@ -0,0 +1,70 @@ +WITH _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + NATION.n_regionkey AS N_REGIONKEY, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY NATION.n_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_5, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY NATION.n_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_6, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY NATION.n_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_7 + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +), _S3 AS ( + SELECT + N_REGIONKEY, + AVG(EXPR_5) AS AVG_EXPR_5, + AVG(EXPR_6) AS AVG_EXPR_6, + AVG(EXPR_7) AS AVG_EXPR_7, + COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS COUNT_NEGATIVE_ACCTBAL, + COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS COUNT_NON_NEGATIVE_ACCTBAL + FROM _T1 + GROUP BY + N_REGIONKEY +) +SELECT + REGION.r_name AS region_name, + _S3.COUNT_NEGATIVE_ACCTBAL AS n_red_acctbal, + _S3.COUNT_NON_NEGATIVE_ACCTBAL AS n_black_acctbal, + _S3.AVG_EXPR_7 AS median_red_acctbal, + _S3.AVG_EXPR_5 AS median_black_acctbal, + _S3.AVG_EXPR_6 AS median_overall_acctbal +FROM TPCH.REGION REGION +JOIN _S3 _S3 + ON REGION.r_regionkey = _S3.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql new file mode 100644 index 000000000..9474cda47 --- /dev/null +++ b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql @@ -0,0 +1,35 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + NATION.n_regionkey AS N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +), _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _S5 AS ( + SELECT + _T.N_REGIONKEY, + SUM(_S3.N_ROWS) AS SUM_N_ROWS + FROM _T _T + JOIN _S3 _S3 + ON _S3.O_CUSTKEY = _T.C_CUSTKEY + WHERE + _T._W = 1 + GROUP BY + _T.N_REGIONKEY +) +SELECT + REGION.r_name AS region_name, + NVL(_S5.SUM_N_ROWS, 0) AS n_orders +FROM TPCH.REGION REGION +LEFT JOIN _S5 _S5 + ON REGION.r_regionkey = _S5.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql new file mode 100644 index 000000000..d00707e28 --- /dev/null +++ b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql @@ -0,0 +1,40 @@ +WITH _T AS ( + SELECT + NATION.n_regionkey AS N_REGIONKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY ORDERS.o_orderdate, ORDERS.o_orderkey) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 +), _T_2 AS ( + SELECT + LINEITEM.l_partkey AS L_PARTKEY, + _T.N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY _T.N_REGIONKEY ORDER BY LINEITEM.l_quantity DESC, LINEITEM.l_linenumber) AS _W + FROM _T _T + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 + AND LINEITEM.l_orderkey = _T.O_ORDERKEY + WHERE + _T._W = 1 +), _S9 AS ( + SELECT + _T.N_REGIONKEY, + PART.p_name AS P_NAME + FROM _T_2 _T + JOIN TPCH.PART PART + ON PART.p_partkey = _T.L_PARTKEY + WHERE + _T._W = 1 +) +SELECT + REGION.r_name AS region_name, + _S9.P_NAME AS part_name +FROM TPCH.REGION REGION +LEFT JOIN _S9 _S9 + ON REGION.r_regionkey = _S9.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql b/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql new file mode 100644 index 000000000..89e211219 --- /dev/null +++ b/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql @@ -0,0 +1,22 @@ +WITH _S3 AS ( + SELECT + ps_suppkey AS PS_SUPPKEY, + COUNT(*) AS N_ROWS + FROM TPCH.PARTSUPP + GROUP BY + ps_suppkey +), _T AS ( + SELECT + SUPPLIER.s_name AS S_NAME, + NTILE(1000) OVER (PARTITION BY NATION.n_regionkey ORDER BY _S3.N_ROWS, SUPPLIER.s_name) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey + JOIN _S3 _S3 + ON SUPPLIER.s_suppkey = _S3.PS_SUPPKEY +) +SELECT + S_NAME AS name +FROM _T +WHERE + _W = 1000 diff --git a/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql b/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql new file mode 100644 index 000000000..2a70de0b6 --- /dev/null +++ b/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + C_CUSTKEY AS key +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/richest_customer_per_region_oracle.sql b/tests/test_sql_refsols/richest_customer_per_region_oracle.sql new file mode 100644 index 000000000..ee2c3e38b --- /dev/null +++ b/tests/test_sql_refsols/richest_customer_per_region_oracle.sql @@ -0,0 +1,21 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_name AS C_NAME, + NATION.n_name AS N_NAME, + REGION.r_name AS R_NAME, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS _W + FROM TPCH.REGION REGION + JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + R_NAME AS region_name, + N_NAME AS nation_name, + C_NAME AS customer_name, + C_ACCTBAL AS balance +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/simple_cross_11_oracle.sql b/tests/test_sql_refsols/simple_cross_11_oracle.sql new file mode 100644 index 000000000..02b789cc3 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_11_oracle.sql @@ -0,0 +1,14 @@ +WITH _S0 AS ( + SELECT + o_orderdate AS O_ORDERDATE + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM _S0 +) +SELECT + COUNT(*) AS n +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.O_ORDERDATE = _S1.MIN_O_ORDERDATE diff --git a/tests/test_sql_refsols/simple_cross_12_oracle.sql b/tests/test_sql_refsols/simple_cross_12_oracle.sql new file mode 100644 index 000000000..321a655d8 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_12_oracle.sql @@ -0,0 +1,17 @@ +WITH _S0 AS ( + SELECT DISTINCT + o_orderpriority AS O_ORDERPRIORITY + FROM TPCH.ORDERS +), _S1 AS ( + SELECT DISTINCT + c_mktsegment AS C_MKTSEGMENT + FROM TPCH.CUSTOMER +) +SELECT + _S0.O_ORDERPRIORITY AS order_priority, + _S1.C_MKTSEGMENT AS market_segment +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_13_oracle.sql b/tests/test_sql_refsols/simple_cross_13_oracle.sql new file mode 100644 index 000000000..13cd201da --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_13_oracle.sql @@ -0,0 +1,10 @@ +SELECT + 'foo' AS a, + 'bar' AS b, + 'fizz' AS c, + 'buzz' AS d, + 'foobar' AS e, + 'fizzbuzz' AS f, + 'yay' AS g +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/simple_cross_15_oracle.sql b/tests/test_sql_refsols/simple_cross_15_oracle.sql new file mode 100644 index 000000000..bfbf7ff38 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_15_oracle.sql @@ -0,0 +1,35 @@ +WITH _T1 AS ( + SELECT + r_name AS R_NAME + FROM TPCH.REGION +), _S0 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%A%' THEN 'A' ELSE '*' END AS A + FROM _T1 +), _S1 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%E%' THEN 'E' ELSE '*' END AS E + FROM _T1 +), _S3 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%I%' THEN 'I' ELSE '*' END AS I + FROM _T1 +), _S5 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%O%' THEN 'O' ELSE '*' END AS O + FROM _T1 +) +SELECT + _S0.A AS a, + _S1.E AS e, + _S3.I AS i, + _S5.O AS o +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +CROSS JOIN _S3 _S3 +CROSS JOIN _S5 _S5 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST, + 3 NULLS FIRST, + 4 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_16_oracle.sql b/tests/test_sql_refsols/simple_cross_16_oracle.sql new file mode 100644 index 000000000..bc1b82df7 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_16_oracle.sql @@ -0,0 +1,38 @@ +WITH _S0 AS ( + SELECT + c_acctbal AS C_ACCTBAL + FROM TPCH.CUSTOMER +), _S1 AS ( + SELECT + MIN(C_ACCTBAL) AS MIN_C_ACCTBAL + FROM _S0 +), _S4 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON _S0.C_ACCTBAL <= ( + _S1.MIN_C_ACCTBAL + 10.0 + ) +), _S2 AS ( + SELECT + s_acctbal AS S_ACCTBAL + FROM TPCH.SUPPLIER +), _S3 AS ( + SELECT + MAX(S_ACCTBAL) AS MAX_S_ACCTBAL + FROM _S2 +), _S5 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM _S2 _S2 + JOIN _S3 _S3 + ON _S2.S_ACCTBAL >= ( + _S3.MAX_S_ACCTBAL - 10.0 + ) +) +SELECT + _S4.N_ROWS AS n1, + _S5.N_ROWS AS n2 +FROM _S4 _S4 +CROSS JOIN _S5 _S5 diff --git a/tests/test_sql_refsols/simple_cross_1_oracle.sql b/tests/test_sql_refsols/simple_cross_1_oracle.sql new file mode 100644 index 000000000..ef278726f --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_1_oracle.sql @@ -0,0 +1,13 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME + FROM TPCH.REGION +) +SELECT + _S0.R_NAME AS r1, + _S1.R_NAME AS r2 +FROM _S0 _S0 +CROSS JOIN _S0 _S1 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_2_oracle.sql b/tests/test_sql_refsols/simple_cross_2_oracle.sql new file mode 100644 index 000000000..6c2142a43 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_2_oracle.sql @@ -0,0 +1,14 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME + FROM TPCH.REGION +) +SELECT + _S0.R_NAME AS r1, + _S1.R_NAME AS r2 +FROM _S0 _S0 +JOIN _S0 _S1 + ON _S0.R_NAME <> _S1.R_NAME +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_3_oracle.sql b/tests/test_sql_refsols/simple_cross_3_oracle.sql new file mode 100644 index 000000000..25e3ec054 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_3_oracle.sql @@ -0,0 +1,36 @@ +WITH _S1 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + ANY_VALUE(_S1.N_NAME) AS supplier_nation, + ANY_VALUE(_S5.N_NAME) AS customer_nation, + COUNT(*) AS nation_combinations +FROM TPCH.REGION REGION +JOIN _S1 _S1 + ON REGION.r_regionkey = _S1.N_REGIONKEY +JOIN TPCH.REGION REGION_2 + ON REGION_2.r_name = 'AMERICA' +JOIN _S1 _S5 + ON REGION_2.r_regionkey = _S5.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_acctbal < 0 AND CUSTOMER.c_nationkey = _S5.N_NATIONKEY +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 4 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_shipmode = 'SHIP' +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey + AND SUPPLIER.s_nationkey = _S1.N_NATIONKEY +WHERE + REGION.r_name = 'ASIA' +GROUP BY + REGION_2.r_regionkey, + _S5.N_NATIONKEY, + _S1.N_NATIONKEY, + REGION.r_regionkey diff --git a/tests/test_sql_refsols/simple_cross_5_oracle.sql b/tests/test_sql_refsols/simple_cross_5_oracle.sql new file mode 100644 index 000000000..2bc07e3f9 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_5_oracle.sql @@ -0,0 +1,79 @@ +WITH _T1 AS ( + SELECT + p_container AS P_CONTAINER, + p_size AS P_SIZE + FROM TPCH.PART + WHERE + p_container LIKE 'LG%' +), _S6 AS ( + SELECT DISTINCT + P_SIZE + FROM _T1 + ORDER BY + 1 NULLS FIRST + FETCH FIRST 10 ROWS ONLY +), _S0 AS ( + SELECT DISTINCT + P_SIZE + FROM _T1 + ORDER BY + 1 NULLS FIRST + FETCH FIRST 10 ROWS ONLY +), _T4 AS ( + SELECT + ORDERS.o_orderpriority AS O_ORDERPRIORITY, + _S0.P_SIZE, + SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY + FROM _S0 _S0 + JOIN TPCH.ORDERS ORDERS + ON EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_discount = 0 + AND LINEITEM.l_orderkey = ORDERS.o_orderkey + AND LINEITEM.l_shipmode = 'SHIP' + AND LINEITEM.l_tax = 0 + JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey + AND PART.p_container LIKE 'LG%' + AND PART.p_size = _S0.P_SIZE + GROUP BY + ORDERS.o_orderpriority, + _S0.P_SIZE +), _T AS ( + SELECT + O_ORDERPRIORITY, + P_SIZE, + SUM_L_QUANTITY, + ROW_NUMBER() OVER (PARTITION BY P_SIZE ORDER BY CASE + WHEN ( + NOT SUM_L_QUANTITY IS NULL AND SUM_L_QUANTITY > 0 + ) + THEN NVL(SUM_L_QUANTITY, 0) + ELSE NULL + END DESC) AS _W + FROM _T4 +), _S7 AS ( + SELECT + CASE + WHEN ( + NOT SUM_L_QUANTITY IS NULL AND SUM_L_QUANTITY > 0 + ) + THEN NVL(SUM_L_QUANTITY, 0) + ELSE NULL + END AS TOTAL_QTY, + O_ORDERPRIORITY, + P_SIZE + FROM _T + WHERE + _W = 1 +) +SELECT + _S6.P_SIZE AS part_size, + _S7.O_ORDERPRIORITY AS best_order_priority, + _S7.TOTAL_QTY AS best_order_priority_qty +FROM _S6 _S6 +LEFT JOIN _S7 _S7 + ON _S6.P_SIZE = _S7.P_SIZE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_6_oracle.sql b/tests/test_sql_refsols/simple_cross_6_oracle.sql new file mode 100644 index 000000000..8dcae710f --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_6_oracle.sql @@ -0,0 +1,17 @@ +WITH _T1 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY, + c_mktsegment AS C_MKTSEGMENT, + c_nationkey AS C_NATIONKEY + FROM TPCH.CUSTOMER + WHERE + c_acctbal > 9990 +) +SELECT + COUNT(*) AS n_pairs +FROM _T1 _T1 +JOIN _T1 _T2 + ON _T1.C_CUSTKEY < _T2.C_CUSTKEY + AND _T1.C_MKTSEGMENT = _T2.C_MKTSEGMENT + AND _T1.C_NATIONKEY = _T2.C_NATIONKEY diff --git a/tests/test_sql_refsols/simple_cross_7_oracle.sql b/tests/test_sql_refsols/simple_cross_7_oracle.sql new file mode 100644 index 000000000..811e73f42 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_7_oracle.sql @@ -0,0 +1,32 @@ +WITH _S3 AS ( + SELECT + PART.p_partkey AS P_PARTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.PART PART + JOIN TPCH.PART PART_2 + ON ABS(PART_2.p_retailprice - PART.p_retailprice) < 5.0 + AND PART.p_brand = PART_2.p_brand + AND PART.p_mfgr = PART_2.p_mfgr + AND PART.p_partkey < PART_2.p_partkey + AND PART_2.p_name LIKE '%tomato%' + WHERE + PART.p_brand = 'Brand#35' + AND PART.p_mfgr = 'Manufacturer#3' + AND PART.p_name LIKE '%tomato%' + GROUP BY + PART.p_partkey +) +SELECT + PART.p_partkey AS original_part_key, + NVL(_S3.N_ROWS, 0) AS n_other_parts +FROM TPCH.PART PART +LEFT JOIN _S3 _S3 + ON PART.p_partkey = _S3.P_PARTKEY +WHERE + PART.p_brand = 'Brand#35' + AND PART.p_mfgr = 'Manufacturer#3' + AND PART.p_name LIKE '%tomato%' +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_cross_8_oracle.sql b/tests/test_sql_refsols/simple_cross_8_oracle.sql new file mode 100644 index 000000000..53e6d09d3 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_8_oracle.sql @@ -0,0 +1,43 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S3 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), _S15 AS ( + SELECT + _S13.R_NAME, + SUPPLIER.s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER SUPPLIER + JOIN _S3 _S11 + ON SUPPLIER.s_nationkey = _S11.N_NATIONKEY + JOIN _S0 _S13 + ON _S11.N_REGIONKEY = _S13.R_REGIONKEY + WHERE + SUPPLIER.s_acctbal < 0 +) +SELECT + ANY_VALUE(_S0.R_NAME) AS supplier_region, + ANY_VALUE(_S1.R_NAME) AS customer_region, + COUNT(*) AS region_combinations +FROM _S0 _S0 +CROSS JOIN _S0 _S1 +JOIN _S3 _S3 + ON _S1.R_REGIONKEY = _S3.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_mktsegment = 'AUTOMOBILE' AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000007' +JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 3 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1998 + AND LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN _S15 _S15 + ON LINEITEM.l_suppkey = _S15.S_SUPPKEY AND _S0.R_NAME = _S15.R_NAME +GROUP BY + _S1.R_REGIONKEY, + _S0.R_REGIONKEY diff --git a/tests/test_sql_refsols/simple_cross_9_oracle.sql b/tests/test_sql_refsols/simple_cross_9_oracle.sql new file mode 100644 index 000000000..222c97abc --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_9_oracle.sql @@ -0,0 +1,25 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S1 AS ( + SELECT + n_name AS N_NAME, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + _S1.N_NAME AS n1, + _S5.N_NAME AS n2 +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.R_REGIONKEY = _S1.N_REGIONKEY +JOIN _S0 _S3 + ON _S0.R_NAME = _S3.R_NAME +JOIN _S1 _S5 + ON _S1.N_NAME <> _S5.N_NAME AND _S3.R_REGIONKEY = _S5.N_REGIONKEY +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_filter_oracle.sql b/tests/test_sql_refsols/simple_filter_oracle.sql new file mode 100644 index 000000000..dfa0ed0dd --- /dev/null +++ b/tests/test_sql_refsols/simple_filter_oracle.sql @@ -0,0 +1,7 @@ +SELECT + o_orderdate AS order_date, + o_orderkey, + o_totalprice +FROM TPCH.ORDERS +WHERE + o_totalprice < 1000.0 diff --git a/tests/test_sql_refsols/simple_filter_top_five_oracle.sql b/tests/test_sql_refsols/simple_filter_top_five_oracle.sql new file mode 100644 index 000000000..822a6cbdb --- /dev/null +++ b/tests/test_sql_refsols/simple_filter_top_five_oracle.sql @@ -0,0 +1,8 @@ +SELECT + o_orderkey AS key +FROM TPCH.ORDERS +WHERE + o_totalprice < 1000.0 +ORDER BY + 1 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql new file mode 100644 index 000000000..fecf9d3d9 --- /dev/null +++ b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql @@ -0,0 +1,25 @@ +SELECT + 1 AS i1, + CAST(2.2 AS INT) AS i2, + CAST('3' AS INT) AS i3, + CAST('4.3' AS INT) AS i4, + CAST('-5.888' AS INT) AS i5, + CAST(-6.0 AS INT) AS i6, + 1.0 AS f1, + 2.2 AS f2, + CAST('3' AS DOUBLE PRECISION) AS f3, + CAST('4.3' AS DOUBLE PRECISION) AS f4, + CAST('-5.888' AS DOUBLE PRECISION) AS f5, + -6.0 AS f6, + 0.0 AS f7, + CAST(1 AS CLOB) AS s1, + CAST(2.2 AS CLOB) AS s2, + CAST('3' AS CLOB) AS s3, + CAST('4.3' AS CLOB) AS s4, + CAST('-5.888' AS CLOB) AS s5, + CAST(-6.1 AS CLOB) AS s6, + CAST(0.1 AS CLOB) AS s7, + CAST('0.0' AS CLOB) AS s8, + CAST('abc def' AS CLOB) AS s9 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/simple_range_1_oracle.sql b/tests/test_sql_refsols/simple_range_1_oracle.sql new file mode 100644 index 000000000..e3dc5a95d --- /dev/null +++ b/tests/test_sql_refsols/simple_range_1_oracle.sql @@ -0,0 +1,13 @@ +SELECT + COLUMN1 AS value +FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS SIMPLE_RANGE(VALUE) diff --git a/tests/test_sql_refsols/simple_range_2_oracle.sql b/tests/test_sql_refsols/simple_range_2_oracle.sql new file mode 100644 index 000000000..c28da3cb0 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_2_oracle.sql @@ -0,0 +1,15 @@ +SELECT + COLUMN1 AS value +FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS SIMPLE_RANGE(VALUE) +ORDER BY + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/simple_range_3_oracle.sql b/tests/test_sql_refsols/simple_range_3_oracle.sql new file mode 100644 index 000000000..f4e33756e --- /dev/null +++ b/tests/test_sql_refsols/simple_range_3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COLUMN1 AS foo +FROM (VALUES + (15), + (16), + (17), + (18), + (19)) AS T1(FOO) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_range_4_oracle.sql b/tests/test_sql_refsols/simple_range_4_oracle.sql new file mode 100644 index 000000000..9afff215a --- /dev/null +++ b/tests/test_sql_refsols/simple_range_4_oracle.sql @@ -0,0 +1,15 @@ +SELECT + COLUMN1 AS N +FROM (VALUES + (10), + (9), + (8), + (7), + (6), + (5), + (4), + (3), + (2), + (1)) AS T2(N) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_range_5_oracle.sql b/tests/test_sql_refsols/simple_range_5_oracle.sql new file mode 100644 index 000000000..e4f7b84dd --- /dev/null +++ b/tests/test_sql_refsols/simple_range_5_oracle.sql @@ -0,0 +1,4 @@ +SELECT + CAST(NULL AS INT) AS x +WHERE + FALSE diff --git a/tests/test_sql_refsols/simple_scan_oracle.sql b/tests/test_sql_refsols/simple_scan_oracle.sql new file mode 100644 index 000000000..e0125c3c4 --- /dev/null +++ b/tests/test_sql_refsols/simple_scan_oracle.sql @@ -0,0 +1,3 @@ +SELECT + o_orderkey AS key +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/simple_scan_top_five_oracle.sql b/tests/test_sql_refsols/simple_scan_top_five_oracle.sql new file mode 100644 index 000000000..fcb9ec0a9 --- /dev/null +++ b/tests/test_sql_refsols/simple_scan_top_five_oracle.sql @@ -0,0 +1,6 @@ +SELECT + o_orderkey AS key +FROM TPCH.ORDERS +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql new file mode 100644 index 000000000..c7c17cd9d --- /dev/null +++ b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql @@ -0,0 +1,29 @@ +SELECT + LEAST(20, 10) AS s1, + LEAST(20, 20) AS s2, + LEAST(20, 10, 0) AS s3, + LEAST(20, 10, 10, -1, -2, 100, -200) AS s4, + NULL AS s5, + LEAST(20.22, 10.22, -0.34) AS s6, + LEAST( + TIME_STR_TO_TIME('2025-01-01 00:00:00'), + TIME_STR_TO_TIME('2024-01-01 00:00:00'), + TIME_STR_TO_TIME('2023-01-01 00:00:00') + ) AS s7, + LEAST('', 'alphabet soup', 'Hello World') AS s8, + NULL AS s9, + GREATEST(20, 10) AS l1, + GREATEST(20, 20) AS l2, + GREATEST(20, 10, 0) AS l3, + GREATEST(20, 10, 10, -1, -2, 100, -200, 300) AS l4, + NULL AS l5, + GREATEST(20.22, 100.22, -0.34) AS l6, + GREATEST( + TIME_STR_TO_TIME('2025-01-01 00:00:00'), + TIME_STR_TO_TIME('2024-01-01 00:00:00'), + TIME_STR_TO_TIME('2023-01-01 00:00:00') + ) AS l7, + GREATEST('', 'alphabet soup', 'Hello World') AS l8, + NULL AS l9 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/simple_var_std_oracle.sql b/tests/test_sql_refsols/simple_var_std_oracle.sql new file mode 100644 index 000000000..a188907b7 --- /dev/null +++ b/tests/test_sql_refsols/simple_var_std_oracle.sql @@ -0,0 +1,15 @@ +SELECT + ANY_VALUE(NATION.n_name) AS name, + VARIANCE_POP(SUPPLIER.s_acctbal) AS var, + STDDEV_POP(SUPPLIER.s_acctbal) AS std, + VARIANCE(SUPPLIER.s_acctbal) AS sample_var, + STDDEV(SUPPLIER.s_acctbal) AS sample_std, + VARIANCE_POP(SUPPLIER.s_acctbal) AS pop_var, + STDDEV_POP(SUPPLIER.s_acctbal) AS pop_std +FROM TPCH.NATION NATION +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +WHERE + NATION.n_name IN ('ALGERIA', 'ARGENTINA') +GROUP BY + SUPPLIER.s_nationkey diff --git a/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql new file mode 100644 index 000000000..d8ee22aff --- /dev/null +++ b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql @@ -0,0 +1,16 @@ +SELECT + VARIANCE(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_samp_0_nnull, + VARIANCE(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_samp_1_nnull, + VARIANCE(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_samp_2_nnull, + VARIANCE_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_pop_0_nnull, + VARIANCE_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_pop_1_nnull, + VARIANCE_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_pop_2_nnull, + STDDEV(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS std_samp_0_nnull, + STDDEV(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS std_samp_1_nnull, + STDDEV(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS std_samp_2_nnull, + STDDEV_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS std_pop_0_nnull, + STDDEV_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS std_pop_1_nnull, + STDDEV_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS std_pop_2_nnull +FROM TPCH.CUSTOMER +WHERE + c_custkey IN (1, 2, 3) diff --git a/tests/test_sql_refsols/simplification_1_oracle.sql b/tests/test_sql_refsols/simplification_1_oracle.sql new file mode 100644 index 000000000..ad3f7197f --- /dev/null +++ b/tests/test_sql_refsols/simplification_1_oracle.sql @@ -0,0 +1,26 @@ +SELECT + 13 AS s00, + 0 AS s01, + COUNT(*) AS s02, + COUNT(*) + 5 AS s03, + COUNT(*) * 2 AS s04, + COUNT(*) / 8.0 AS s05, + 10 AS s06, + COUNT(*) AS s07, + ABS(COUNT(*) - 25) AS s08, + COUNT(*) + 1 AS s09, + COUNT(*) - 3 AS s10, + COUNT(*) * -1 AS s11, + COUNT(*) / 2.5 AS s12, + COUNT(*) > 10 AS s13, + COUNT(*) >= 10 AS s14, + COUNT(*) = 20 AS s15, + COUNT(*) <> 25 AS s16, + COUNT(*) < 25 AS s17, + COUNT(*) <= 25 AS s18, + COUNT(*) AS s19, + AVG(NVL(LENGTH(sbcustname), 0)) AS s20, + TRUE AS s21, + TRUE AS s22, + TRUE AS s23 +FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_2_oracle.sql b/tests/test_sql_refsols/simplification_2_oracle.sql new file mode 100644 index 000000000..9dbcca858 --- /dev/null +++ b/tests/test_sql_refsols/simplification_2_oracle.sql @@ -0,0 +1,50 @@ +SELECT + TRUE AS s00, + FALSE AS s01, + TRUE AS s02, + FALSE AS s03, + TRUE AS s04, + FALSE AS s05, + NULL AS s06, + NULL AS s07, + NULL AS s08, + NULL AS s09, + NULL AS s10, + NULL AS s11, + FALSE AS s12, + TRUE AS s13, + FALSE AS s14, + FALSE AS s15, + TRUE AS s16, + TRUE AS s17, + TRUE AS s18, + FALSE AS s19, + TRUE AS s20, + FALSE AS s21, + TRUE AS s22, + FALSE AS s23, + FALSE AS s24, + TRUE AS s25, + TRUE AS s26, + FALSE AS s27, + TRUE AS s28, + FALSE AS s29, + 8 AS s30, + 'alphabet' AS s31, + 'SOUP' AS s32, + TRUE AS s33, + FALSE AS s34, + FALSE AS s35, + TRUE AS s36, + 3.0 AS s37, + NULL AS s38, + NULL AS s39, + NULL AS s40, + NULL AS s41, + NULL AS s42, + NULL AS s43, + NULL AS s44, + NULL AS s45, + NULL AS s46, + NVL(MAX(sbcustname), '') LIKE '%r%' AS s47 +FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_3_oracle.sql b/tests/test_sql_refsols/simplification_3_oracle.sql new file mode 100644 index 000000000..222dd74fb --- /dev/null +++ b/tests/test_sql_refsols/simplification_3_oracle.sql @@ -0,0 +1,95 @@ +WITH _T2 AS ( + SELECT + ABS(CAST(sbcustpostalcode AS INT)) AS EXPR_13, + ROW_NUMBER() OVER (ORDER BY sbcustname) AS RANK, + AVG(CAST(ABS(NVL(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER () AS RAVG1, + NVL( + AVG(CAST(ABS(NVL(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), + 0.1 + ) AS RAVG2, + COUNT(CAST(sbcustpostalcode AS INT)) OVER () AS RCNT1, + NVL( + COUNT(CAST(sbcustpostalcode AS INT)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 0.1 + ) AS RCNT2, + COUNT(*) OVER () AS RSIZ1, + NVL( + COUNT(*) OVER (ORDER BY sbcustname ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING), + 0.1 + ) AS RSIZ2, + SUM(ABS(NVL(CAST(sbcustpostalcode AS INT), 0))) OVER () AS RSUM1, + NVL( + SUM(ABS(NVL(CAST(sbcustpostalcode AS INT), 0))) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 0.1 + ) AS RSUM2 + FROM MAIN.SBCUSTOMER +), _T1 AS ( + SELECT + RANK, + RAVG1, + RAVG2, + RCNT1, + RCNT2, + RSIZ1, + RSIZ2, + RSUM1, + RSUM2, + CASE + WHEN FLOOR(0.75 * COUNT(EXPR_13) OVER ()) < ROW_NUMBER() OVER (ORDER BY EXPR_13 DESC NULLS LAST) + THEN EXPR_13 + ELSE NULL + END AS EXPR_15, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY EXPR_13 DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(EXPR_13) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN EXPR_13 + ELSE NULL + END AS EXPR_16 + FROM _T2 +) +SELECT + TRUE AS s00, + TRUE AS s01, + FALSE AS s02, + FALSE AS s03, + FALSE AS s04, + FALSE AS s05, + COUNT(*) >= 3 AS s06, + FALSE AS s07, + COUNT(*) <= 6 AS s08, + FALSE AS s09, + 91 AS s10, + 0 AS s11, + 50 AS s12, + 35 AS s13, + 25.0 AS s14, + ABS(COUNT(*) * -0.75) AS s15, + 10 AS s16, + COUNT(*) AS s17, + COUNT(*) AS s18, + FALSE AS s19, + TRUE AS s20, + FALSE AS s21, + TRUE AS s22, + FALSE AS s23, + TRUE AS s24, + MAX(EXPR_15) AS s25, + AVG(EXPR_16) AS s26, + MIN(RANK) AS s27, + MAX(RANK) AS s28, + ANY_VALUE(RSUM1) AS s29, + ROUND(SUM(RSUM2), 2) AS s30, + ANY_VALUE(RAVG1) AS s31, + ROUND(SUM(RAVG2), 2) AS s32, + ANY_VALUE(RCNT1) AS s33, + ROUND(SUM(RCNT2), 2) AS s34, + ANY_VALUE(RSIZ1) AS s35, + ROUND(SUM(RSIZ2), 2) AS s36 +FROM _T1 diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql new file mode 100644 index 000000000..c455e3934 --- /dev/null +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -0,0 +1,119 @@ +WITH _T AS ( + SELECT + sbtxdatetime AS SBTXDATETIME, + ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS _W, + ROW_NUMBER() OVER (ORDER BY sbtxdatetime DESC) AS _W_2 + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +) +SELECT + SBTXDATETIME AS date_time, + DATE_SUB(TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'WEEK'), 8, WEEK) AS s00, + FALSE AS s01, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (1, 2, 3) AS s02, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (4, 5, 6) AS s03, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (7, 8, 9) AS s04, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (10, 11, 12) AS s05, + FALSE AS s06, + FALSE AS s07, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 4 AS s08, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 7 AS s09, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 10 AS s10, + TRUE AS s11, + FALSE AS s12, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 3 AS s13, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 6 AS s14, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 9 AS s15, + TRUE AS s16, + TRUE AS s17, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 3 AS s18, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 6 AS s19, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 9 AS s20, + FALSE AS s21, + TRUE AS s22, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 4 AS s23, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 7 AS s24, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 10 AS s25, + FALSE AS s26, + TRUE AS s27, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (1, 2, 3) AS s28, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (4, 5, 6) AS s29, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (7, 8, 9) AS s30, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (10, 11, 12) AS s31, + TRUE AS s32, + 2024 AS s33, + 3 AS s34, + 8 AS s35, + 13 AS s36, + 12 AS s37, + 45 AS s38, + 59 AS s39, + 2020 AS s40, + 1 AS s41, + 1 AS s42, + 31 AS s43, + 0 AS s44, + 0 AS s45, + 0 AS s46, + 2023 AS s47, + 3 AS s48, + 7 AS s49, + 4 AS s50, + 6 AS s51, + 55 AS s52, + 0 AS s53, + 1999 AS s54, + 4 AS s55, + 12 AS s56, + 31 AS s57, + 23 AS s58, + 59 AS s59, + 58 AS s60, + FALSE AS s61, + FALSE AS s62, + FALSE AS s63, + TRUE AS s64, + TRUE AS s65, + TRUE AS s66, + FALSE AS s67, + FALSE AS s68, + FALSE AS s69, + TRUE AS s70, + TRUE AS s71, + TRUE AS s72, + FALSE AS s73, + FALSE AS s74, + TRUE AS s75, + TRUE AS s76, + FALSE AS s77, + TRUE AS s78, + FALSE AS s79, + TRUE AS s80, + TRUE AS s81, + FALSE AS s82, + TRUE AS s83, + FALSE AS s84, + FALSE AS s85, + TRUE AS s86, + FALSE AS s87, + FALSE AS s88, + TRUE AS s89, + TRUE AS s90, + FALSE AS s91, + TRUE AS s92, + FALSE AS s93, + FALSE AS s94, + TRUE AS s95, + TRUE AS s96, + TO_DATE('2025-02-28', 'YYYY-MM-DD') AS s97, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s98, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s99, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s100, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s101, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s102, + TO_DATE('2025-01-06', 'YYYY-MM-DD') AS s103, + TO_DATE('2025-01-06', 'YYYY-MM-DD') AS s104 +FROM _T +WHERE + _W = 1 OR _W_2 = 1 diff --git a/tests/test_sql_refsols/singular1_oracle.sql b/tests/test_sql_refsols/singular1_oracle.sql new file mode 100644 index 000000000..111125469 --- /dev/null +++ b/tests/test_sql_refsols/singular1_oracle.sql @@ -0,0 +1,14 @@ +WITH _S1 AS ( + SELECT + n_name AS N_NAME, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + WHERE + n_nationkey = 4 +) +SELECT + REGION.r_name AS name, + _S1.N_NAME AS nation_4_name +FROM TPCH.REGION REGION +LEFT JOIN _S1 _S1 + ON REGION.r_regionkey = _S1.N_REGIONKEY diff --git a/tests/test_sql_refsols/singular2_oracle.sql b/tests/test_sql_refsols/singular2_oracle.sql new file mode 100644 index 000000000..295390f8d --- /dev/null +++ b/tests/test_sql_refsols/singular2_oracle.sql @@ -0,0 +1,16 @@ +WITH _S3 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_orderkey AS O_ORDERKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_orderkey = 454791 + WHERE + CUSTOMER.c_custkey = 1 +) +SELECT + NATION.n_name AS name, + _S3.O_ORDERKEY AS okey +FROM TPCH.NATION NATION +LEFT JOIN _S3 _S3 + ON NATION.n_nationkey = _S3.C_NATIONKEY diff --git a/tests/test_sql_refsols/singular3_oracle.sql b/tests/test_sql_refsols/singular3_oracle.sql new file mode 100644 index 000000000..f56d232d2 --- /dev/null +++ b/tests/test_sql_refsols/singular3_oracle.sql @@ -0,0 +1,29 @@ +WITH _S0 AS ( + SELECT + c_custkey AS C_CUSTKEY, + c_name AS C_NAME + FROM TPCH.CUSTOMER + ORDER BY + 2 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS _W + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + O_CUSTKEY, + O_ORDERDATE + FROM _T + WHERE + _W = 1 +) +SELECT + _S0.C_NAME AS name +FROM _S0 _S0 +LEFT JOIN _S1 _S1 + ON _S0.C_CUSTKEY = _S1.O_CUSTKEY +ORDER BY + _S1.O_ORDERDATE diff --git a/tests/test_sql_refsols/singular4_oracle.sql b/tests/test_sql_refsols/singular4_oracle.sql new file mode 100644 index 000000000..679675cac --- /dev/null +++ b/tests/test_sql_refsols/singular4_oracle.sql @@ -0,0 +1,26 @@ +WITH _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS _W + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' +), _S1 AS ( + SELECT + O_CUSTKEY, + O_ORDERDATE + FROM _T + WHERE + _W = 1 +) +SELECT + CUSTOMER.c_name AS name +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +WHERE + CUSTOMER.c_nationkey = 6 +ORDER BY + NVL(_S1.O_ORDERDATE, TO_DATE('2000-01-01', 'YYYY-MM-DD')) +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular5_oracle.sql b/tests/test_sql_refsols/singular5_oracle.sql new file mode 100644 index 000000000..63c7d6a08 --- /dev/null +++ b/tests/test_sql_refsols/singular5_oracle.sql @@ -0,0 +1,49 @@ +WITH _T3 AS ( + SELECT + p_brand AS P_BRAND, + p_container AS P_CONTAINER, + p_partkey AS P_PARTKEY + FROM TPCH.PART + WHERE + p_brand = 'Brand#13' +), _T AS ( + SELECT + LINEITEM.l_shipdate AS L_SHIPDATE, + _T7.P_PARTKEY, + ROW_NUMBER() OVER (PARTITION BY _T7.P_CONTAINER ORDER BY LINEITEM.l_extendedprice DESC, LINEITEM.l_shipdate) AS _W + FROM _T3 _T7 + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = _T7.P_PARTKEY + AND LINEITEM.l_shipmode = 'RAIL' + AND LINEITEM.l_tax = 0 +), _S3 AS ( + SELECT + P_PARTKEY, + ANY_VALUE(L_SHIPDATE) AS ANYTHING_L_SHIPDATE, + COUNT(*) AS N_ROWS + FROM _T + WHERE + _W = 1 + GROUP BY + P_PARTKEY +), _T1 AS ( + SELECT + _T3.P_CONTAINER, + MAX(_S3.ANYTHING_L_SHIPDATE) AS MAX_ANYTHING_L_SHIPDATE, + SUM(_S3.N_ROWS) AS SUM_N_ROWS + FROM _T3 _T3 + LEFT JOIN _S3 _S3 + ON _S3.P_PARTKEY = _T3.P_PARTKEY + GROUP BY + _T3.P_CONTAINER +) +SELECT + P_CONTAINER AS container, + MAX_ANYTHING_L_SHIPDATE AS highest_price_ship_date +FROM _T1 +WHERE + SUM_N_ROWS <> 0 +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular6_oracle.sql b/tests/test_sql_refsols/singular6_oracle.sql new file mode 100644 index 000000000..ea0c68aed --- /dev/null +++ b/tests/test_sql_refsols/singular6_oracle.sql @@ -0,0 +1,31 @@ +WITH _T AS ( + SELECT + LINEITEM.l_receiptdate AS L_RECEIPTDATE, + LINEITEM.l_suppkey AS L_SUPPKEY, + ORDERS.o_custkey AS O_CUSTKEY, + ROW_NUMBER() OVER (PARTITION BY ORDERS.o_custkey ORDER BY LINEITEM.l_receiptdate, LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) DESC) AS _W + FROM TPCH.ORDERS ORDERS + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey + WHERE + ORDERS.o_clerk = 'Clerk#000000017' +) +SELECT + CUSTOMER.c_name AS name, + _T.L_RECEIPTDATE AS receipt_date, + NATION.n_name AS nation_name +FROM TPCH.CUSTOMER CUSTOMER +JOIN _T _T + ON CUSTOMER.c_custkey = _T.O_CUSTKEY AND _T._W = 1 +JOIN TPCH.SUPPLIER SUPPLIER + ON SUPPLIER.s_suppkey = _T.L_SUPPKEY +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +WHERE + CUSTOMER.c_nationkey = 4 +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular7_oracle.sql b/tests/test_sql_refsols/singular7_oracle.sql new file mode 100644 index 000000000..7764a3836 --- /dev/null +++ b/tests/test_sql_refsols/singular7_oracle.sql @@ -0,0 +1,49 @@ +WITH _S3 AS ( + SELECT + l_partkey AS L_PARTKEY, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + WHERE + EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 +), _T4 AS ( + SELECT + PARTSUPP.ps_suppkey AS PS_SUPPKEY, + ANY_VALUE(PART.p_name) AS ANYTHING_P_NAME, + COUNT(_S3.L_SUPPKEY) AS COUNT_L_SUPPKEY + FROM TPCH.PARTSUPP PARTSUPP + JOIN TPCH.PART PART + ON PART.p_brand = 'Brand#13' AND PART.p_partkey = PARTSUPP.ps_partkey + LEFT JOIN _S3 _S3 + ON PARTSUPP.ps_partkey = _S3.L_PARTKEY AND PARTSUPP.ps_suppkey = _S3.L_SUPPKEY + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +), _T AS ( + SELECT + PS_SUPPKEY, + ANYTHING_P_NAME, + COUNT_L_SUPPKEY, + ROW_NUMBER() OVER (PARTITION BY PS_SUPPKEY ORDER BY NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) DESC, ANYTHING_P_NAME) AS _W + FROM _T4 +), _S5 AS ( + SELECT + NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) AS N_ORDERS, + ANYTHING_P_NAME, + PS_SUPPKEY + FROM _T + WHERE + _W = 1 +) +SELECT + SUPPLIER.s_name AS supplier_name, + _S5.ANYTHING_P_NAME AS part_name, + _S5.N_ORDERS AS n_orders +FROM TPCH.SUPPLIER SUPPLIER +LEFT JOIN _S5 _S5 + ON SUPPLIER.s_suppkey = _S5.PS_SUPPKEY +WHERE + SUPPLIER.s_nationkey = 20 +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql new file mode 100644 index 000000000..d41b0d971 --- /dev/null +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -0,0 +1,50 @@ +SELECT + o_orderkey AS key, + LISTAGG( + '_', + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(DAY FROM CAST(o_orderdate AS DATETIME)) + ) AS a, + LISTAGG( + ':', + CASE + WHEN DAY_OF_WEEK(o_orderdate) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(o_orderdate) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(o_orderdate) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(o_orderdate) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(o_orderdate) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(o_orderdate) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(o_orderdate) = 6 + THEN 'Saturday' + END, + DAY_OF_WEEK(o_orderdate) + ) AS b, + DATE_SUB(DATE_ADD(TRUNC(CAST(o_orderdate AS TIMESTAMP), 'YEAR'), 6, 'MONTH'), 13, DAY) AS c, + DATE_ADD(DATE_ADD(TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER'), 1, 'YEAR'), 25, 'HOUR') AS d, + TIME_STR_TO_TIME('2025-01-01 12:35:00') AS e, + TIME_STR_TO_TIME('2025-07-22 12:00:00') AS f, + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, + LISTAGG(';', 12, 20, 6) AS h, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), YEAR) AS i, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), QUARTER) AS j, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), MONTH) AS k, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), WEEK) AS l, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), DAY) AS m, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), HOUR) AS n, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), MINUTE) AS o, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), SECOND) AS p, + TRUNC(CAST(o_orderdate AS TIMESTAMP), 'WEEK') AS q +FROM TPCH.ORDERS +WHERE + o_clerk LIKE '%5' AND o_comment LIKE '%fo%' AND o_orderpriority LIKE '3%' +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/smoke_d_oracle.sql b/tests/test_sql_refsols/smoke_d_oracle.sql new file mode 100644 index 000000000..4d35b673c --- /dev/null +++ b/tests/test_sql_refsols/smoke_d_oracle.sql @@ -0,0 +1,29 @@ +SELECT + CUSTOMER.c_custkey AS key, + ROW_NUMBER() OVER (ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS a, + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS b, + RANK() OVER (ORDER BY CUSTOMER.c_mktsegment) AS c, + DENSE_RANK() OVER (ORDER BY CUSTOMER.c_mktsegment) AS d, + NTILE(100) OVER (ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS e, + NTILE(12) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS f, + LAG(CUSTOMER.c_custkey, 1) OVER (ORDER BY CUSTOMER.c_custkey) AS g, + LAG(CUSTOMER.c_custkey, 2, -1) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS h, + LEAD(CUSTOMER.c_custkey, 1) OVER (ORDER BY CUSTOMER.c_custkey) AS i, + LEAD(CUSTOMER.c_custkey, 6000) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS j, + SUM(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) AS k, + SUM(CUSTOMER.c_acctbal) OVER (ORDER BY CUSTOMER.c_custkey ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS l, + ROUND(AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER (), 2) AS m, + ROUND( + AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), + 2 + ) AS n, + COUNT(CASE WHEN CUSTOMER.c_acctbal > 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER () AS o, + COUNT(*) OVER () AS p +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +ORDER BY + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql new file mode 100644 index 000000000..040bd90a6 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 2 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql new file mode 100644 index 000000000..eabd3e5ac --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 2 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql new file mode 100644 index 000000000..1fc16f17f --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 6 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql new file mode 100644 index 000000000..b4d67c626 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 6 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql new file mode 100644 index 000000000..584872c0b --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 1 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql new file mode 100644 index 000000000..e9836ebc8 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 1 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql new file mode 100644 index 000000000..f7f489a92 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql @@ -0,0 +1,24 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + DAY_OF_WEEK(sbtxdatetime) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql new file mode 100644 index 000000000..d4f0b58ab --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql @@ -0,0 +1,24 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + DAY_OF_WEEK(sbtxdatetime) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql new file mode 100644 index 000000000..9d515872c --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 3 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql new file mode 100644 index 000000000..955c36257 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 3 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql new file mode 100644 index 000000000..0c10a5870 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 5 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql new file mode 100644 index 000000000..2cc7da32c --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 5 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql new file mode 100644 index 000000000..66d595c70 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 4 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql new file mode 100644 index 000000000..74b1fee96 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 4 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/string_format_specifiers_oracle.sql b/tests/test_sql_refsols/string_format_specifiers_oracle.sql new file mode 100644 index 000000000..3b50033b2 --- /dev/null +++ b/tests/test_sql_refsols/string_format_specifiers_oracle.sql @@ -0,0 +1,18 @@ +SELECT + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'YYYY') AS d1, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'YY') AS d2, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MM') AS d3, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'Mon') AS d4, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MMMM') AS d5, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DD') AS d6, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DY') AS d7, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DYDY') AS d8, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'HH24') AS d9, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'HH12') AS d10, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MI') AS d11, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'SS') AS d12, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'P.M.') AS d13, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), '.FF') AS d14, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'TZH:TZM') AS d15 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/string_functions_oracle.sql b/tests/test_sql_refsols/string_functions_oracle.sql new file mode 100644 index 000000000..86bedce30 --- /dev/null +++ b/tests/test_sql_refsols/string_functions_oracle.sql @@ -0,0 +1,30 @@ +SELECT + LOWER(CUSTOMER.c_name) AS lowercase_name, + UPPER(CUSTOMER.c_name) AS uppercase_name, + LENGTH(CUSTOMER.c_name) AS name_length, + CUSTOMER.c_name LIKE 'A%' AS starts_with_A, + CUSTOMER.c_name LIKE '%z' AS ends_with_z, + CUSTOMER.c_name LIKE '%sub%' AS contains_sub, + CUSTOMER.c_name LIKE '%test%' AS matches_like, + LISTAGG('::', CUSTOMER.c_name, NATION.n_name) AS joined_string, + CASE + WHEN LENGTH(CUSTOMER.c_name) >= 20 + THEN SUBSTR(CUSTOMER.c_name, 1, 20) + ELSE SUBSTR(CONCAT('********************', CUSTOMER.c_name), -20) + END AS lpad_name, + SUBSTR(CONCAT(CUSTOMER.c_name, '--------------------'), 1, 20) AS rpad_name, + TRIM(CUSTOMER.c_name) AS stripped, + TRIM('aeiou' FROM CUSTOMER.c_name) AS stripped_vowels, + REPLACE(CUSTOMER.c_name, 'Corp', 'Inc') AS replaced_name, + REPLACE(CUSTOMER.c_name, 'Ltd', '') AS removed_substr, + CASE + WHEN LENGTH('e') = 0 + THEN 0 + ELSE CAST(( + LENGTH(CUSTOMER.c_name) - LENGTH(REPLACE(CUSTOMER.c_name, 'e', '')) + ) / LENGTH('e') AS INT) + END AS count_e, + INSTR(CUSTOMER.c_name, 'Alex') AS idx_Alex +FROM TPCH.CUSTOMER CUSTOMER +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey diff --git a/tests/test_sql_refsols/supplier_best_part_oracle.sql b/tests/test_sql_refsols/supplier_best_part_oracle.sql new file mode 100644 index 000000000..369d48ea3 --- /dev/null +++ b/tests/test_sql_refsols/supplier_best_part_oracle.sql @@ -0,0 +1,37 @@ +WITH _S2 AS ( + SELECT + l_partkey AS L_PARTKEY, + l_suppkey AS L_SUPPKEY, + COUNT(*) AS N_ROWS, + SUM(l_quantity) AS SUM_L_QUANTITY + FROM TPCH.LINEITEM + WHERE + EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_tax = 0 + GROUP BY + l_partkey, + l_suppkey +), _T AS ( + SELECT + _S2.L_SUPPKEY, + _S2.N_ROWS, + PART.p_name AS P_NAME, + _S2.SUM_L_QUANTITY, + ROW_NUMBER() OVER (PARTITION BY _S2.L_SUPPKEY ORDER BY NVL(_S2.SUM_L_QUANTITY, 0) DESC) AS _W + FROM _S2 _S2 + JOIN TPCH.PART PART + ON PART.p_partkey = _S2.L_PARTKEY +) +SELECT + SUPPLIER.s_name AS supplier_name, + _T.P_NAME AS part_name, + NVL(_T.SUM_L_QUANTITY, 0) AS total_quantity, + _T.N_ROWS AS n_shipments +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_name = 'FRANCE' AND NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN _T _T + ON SUPPLIER.s_suppkey = _T.L_SUPPKEY AND _T._W = 1 +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql new file mode 100644 index 000000000..be7ec1a8b --- /dev/null +++ b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql @@ -0,0 +1,46 @@ +WITH _S7 AS ( + SELECT + LINEITEM.l_quantity AS L_QUANTITY, + LINEITEM.l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM LINEITEM + JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey + AND PART.p_container LIKE 'LG%' + AND PART.p_name LIKE '%tomato%' + WHERE + EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) < 7 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 + AND LINEITEM.l_shipmode = 'SHIP' +), _T0 AS ( + SELECT + ANY_VALUE(NATION.n_name) AS ANYTHING_N_NAME, + ANY_VALUE(SUPPLIER.s_name) AS ANYTHING_S_NAME, + ANY_VALUE(SUPPLIER.s_nationkey) AS ANYTHING_S_NATIONKEY, + SUM(_S7.L_QUANTITY) AS SUM_L_QUANTITY + FROM TPCH.NATION NATION + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' + JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey + AND SUPPLIER.s_acctbal >= 8000.0 + AND SUPPLIER.s_comment LIKE '%careful%' + LEFT JOIN _S7 _S7 + ON SUPPLIER.s_suppkey = _S7.L_SUPPKEY + GROUP BY + SUPPLIER.s_suppkey +) +SELECT + ANYTHING_S_NAME AS supplier_name, + ANYTHING_N_NAME AS nation_name, + NVL(SUM_L_QUANTITY, 0) AS supplier_quantity, + ( + 100.0 * NVL(SUM_L_QUANTITY, 0) + ) / CASE + WHEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) > 0 + THEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) + ELSE NULL + END AS national_qty_pct +FROM _T0 +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql b/tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql new file mode 100644 index 000000000..e9d4f949f --- /dev/null +++ b/tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql @@ -0,0 +1,12 @@ +SELECT + SUPPLIER.s_name AS name, + REGION.r_name AS region_name, + SUPPLIER.s_acctbal - LAG(SUPPLIER.s_acctbal, 1) OVER (PARTITION BY NATION.n_regionkey ORDER BY SUPPLIER.s_acctbal) AS acctbal_delta +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql b/tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql new file mode 100644 index 000000000..1d86c4628 --- /dev/null +++ b/tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql @@ -0,0 +1,13 @@ +SELECT + CONDITIONS.description AS condition_description +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.CONDITIONS CONDITIONS + ON CONDITIONS.patient = PATIENTS.patient +WHERE + PATIENTS.ethnicity = 'italian' AND PATIENTS.gender = 'F' +GROUP BY + CONDITIONS.description +ORDER BY + COUNT(*) DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql new file mode 100644 index 000000000..6968355a0 --- /dev/null +++ b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql @@ -0,0 +1,29 @@ +WITH _S7 AS ( + SELECT + INCIDENTS.in_device_id AS IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS INCIDENTS + JOIN MAIN.ERRORS ERRORS + ON ERRORS.er_id = INCIDENTS.in_error_id AND ERRORS.er_name = 'Battery Failure' + GROUP BY + INCIDENTS.in_device_id +) +SELECT + COUNTRIES.co_name AS country_name, + PRODUCTS.pr_name AS product_name, + ROUND(NVL(SUM(_S7.N_ROWS), 0) / COUNT(*), 2) AS ir +FROM MAIN.COUNTRIES COUNTRIES +JOIN MAIN.DEVICES DEVICES + ON COUNTRIES.co_id = DEVICES.de_production_country_id +JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id +LEFT JOIN _S7 _S7 + ON DEVICES.de_id = _S7.IN_DEVICE_ID +GROUP BY + COUNTRIES.co_name, + PRODUCTS.pr_name +ORDER BY + 3 DESC NULLS LAST, + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql b/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql new file mode 100644 index 000000000..a392b1a3c --- /dev/null +++ b/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql @@ -0,0 +1,12 @@ +WITH _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.COUNTRIES +) +SELECT + COUNTRIES.co_name AS name, + _S1.N_ROWS AS n_other_countries +FROM MAIN.COUNTRIES COUNTRIES +CROSS JOIN _S1 _S1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql new file mode 100644 index 000000000..3fc67dd77 --- /dev/null +++ b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql @@ -0,0 +1,45 @@ +WITH _S0 AS ( + SELECT + co_id AS CO_ID, + co_name AS CO_NAME + FROM MAIN.COUNTRIES +), _S2 AS ( + SELECT + co_id AS CO_ID + FROM MAIN.COUNTRIES +), _T1 AS ( + SELECT + ANY_VALUE(_S3.CO_ID) AS ANYTHING__ID_3, + ANY_VALUE(_S2.CO_ID) AS ANYTHING_CO_ID, + COUNT(INCIDENTS.in_device_id) AS COUNT_IN_DEVICE_ID + FROM _S2 _S2 + CROSS JOIN _S2 _S3 + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_production_country_id = _S2.CO_ID + AND DEVICES.de_purchase_country_id = _S3.CO_ID + LEFT JOIN MAIN.INCIDENTS INCIDENTS + ON DEVICES.de_id = INCIDENTS.in_device_id + GROUP BY + DEVICES.de_id +), _S9 AS ( + SELECT + ANYTHING__ID_3, + ANYTHING_CO_ID, + COUNT(*) AS N_ROWS, + SUM(COUNT_IN_DEVICE_ID) AS SUM_N_ROWS + FROM _T1 + GROUP BY + ANYTHING__ID_3, + ANYTHING_CO_ID +) +SELECT + _S0.CO_NAME AS factory_country, + _S1.CO_NAME AS purchase_country, + ROUND(NVL(_S9.SUM_N_ROWS, 0) / NVL(_S9.N_ROWS, 0), 2) AS ir +FROM _S0 _S0 +CROSS JOIN _S0 _S1 +LEFT JOIN _S9 _S9 + ON _S0.CO_ID = _S9.ANYTHING_CO_ID AND _S1.CO_ID = _S9.ANYTHING__ID_3 +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql new file mode 100644 index 000000000..015d0f98f --- /dev/null +++ b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql @@ -0,0 +1,72 @@ +WITH _T2 AS ( + SELECT + in_device_id AS IN_DEVICE_ID + FROM MAIN.INCIDENTS +), _S1 AS ( + SELECT + IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + IN_DEVICE_ID +), _S3 AS ( + SELECT + DEVICES.de_production_country_id AS DE_PRODUCTION_COUNTRY_ID, + COUNT(*) AS N_ROWS, + SUM(_S1.N_ROWS) AS SUM_N_ROWS + FROM MAIN.DEVICES DEVICES + LEFT JOIN _S1 _S1 + ON DEVICES.de_id = _S1.IN_DEVICE_ID + GROUP BY + DEVICES.de_production_country_id +), _S5 AS ( + SELECT + IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + IN_DEVICE_ID +), _S7 AS ( + SELECT + DEVICES.de_purchase_country_id AS DE_PURCHASE_COUNTRY_ID, + COUNT(*) AS N_ROWS, + SUM(_S5.N_ROWS) AS SUM_N_ROWS + FROM MAIN.DEVICES DEVICES + LEFT JOIN _S5 _S5 + ON DEVICES.de_id = _S5.IN_DEVICE_ID + GROUP BY + DEVICES.de_purchase_country_id +), _T5 AS ( + SELECT + ANY_VALUE(USERS.us_country_id) AS ANYTHING_US_COUNTRY_ID, + COUNT(_S11.IN_DEVICE_ID) AS COUNT_IN_DEVICE_ID + FROM MAIN.USERS USERS + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_owner_id = USERS.us_id + LEFT JOIN _T2 _S11 + ON DEVICES.de_id = _S11.IN_DEVICE_ID + GROUP BY + DEVICES.de_id +), _S13 AS ( + SELECT + ANYTHING_US_COUNTRY_ID, + COUNT(*) AS N_ROWS, + SUM(COUNT_IN_DEVICE_ID) AS SUM_N_ROWS + FROM _T5 + GROUP BY + ANYTHING_US_COUNTRY_ID +) +SELECT + COUNTRIES.co_name AS country_name, + ROUND(NVL(_S3.SUM_N_ROWS, 0) / _S3.N_ROWS, 2) AS made_ir, + ROUND(NVL(_S7.SUM_N_ROWS, 0) / _S7.N_ROWS, 2) AS sold_ir, + ROUND(NVL(_S13.SUM_N_ROWS, 0) / NVL(_S13.N_ROWS, 0), 2) AS user_ir +FROM MAIN.COUNTRIES COUNTRIES +JOIN _S3 _S3 + ON COUNTRIES.co_id = _S3.DE_PRODUCTION_COUNTRY_ID +JOIN _S7 _S7 + ON COUNTRIES.co_id = _S7.DE_PURCHASE_COUNTRY_ID +LEFT JOIN _S13 _S13 + ON COUNTRIES.co_id = _S13.ANYTHING_US_COUNTRY_ID +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql new file mode 100644 index 000000000..453472e15 --- /dev/null +++ b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql @@ -0,0 +1,22 @@ +WITH _S5 AS ( + SELECT + INCIDENTS.in_error_id AS IN_ERROR_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS INCIDENTS + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id + JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'Sun-Set' + GROUP BY + INCIDENTS.in_error_id +) +SELECT + ERRORS.er_name AS error, + ROUND(( + 100.0 * NVL(_S5.N_ROWS, 0) + ) / SUM(NVL(_S5.N_ROWS, 0)) OVER (), 2) AS pct +FROM MAIN.ERRORS ERRORS +LEFT JOIN _S5 _S5 + ON ERRORS.er_id = _S5.IN_ERROR_ID +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql new file mode 100644 index 000000000..bd6ad7122 --- /dev/null +++ b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql @@ -0,0 +1,28 @@ +WITH _T2 AS ( + SELECT + ANY_VALUE(DEVICES.de_production_country_id) AS ANYTHING_DE_PRODUCTION_COUNTRY_ID, + COUNT(INCIDENTS.in_device_id) AS COUNT_IN_DEVICE_ID + FROM MAIN.DEVICES DEVICES + JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'Sun-Set' + LEFT JOIN MAIN.INCIDENTS INCIDENTS + ON DEVICES.de_id = INCIDENTS.in_device_id + GROUP BY + DEVICES.de_id +), _S5 AS ( + SELECT + NVL(SUM(COUNT_IN_DEVICE_ID), 0) AS SUM_N_INCIDENTS, + ANYTHING_DE_PRODUCTION_COUNTRY_ID, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + ANYTHING_DE_PRODUCTION_COUNTRY_ID +) +SELECT + COUNTRIES.co_name AS country, + ROUND(NVL(_S5.SUM_N_INCIDENTS, 0) / NVL(_S5.N_ROWS, 0), 2) AS ir +FROM MAIN.COUNTRIES COUNTRIES +LEFT JOIN _S5 _S5 + ON COUNTRIES.co_id = _S5.ANYTHING_DE_PRODUCTION_COUNTRY_ID +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql new file mode 100644 index 000000000..d95ee89cb --- /dev/null +++ b/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql @@ -0,0 +1,13 @@ +WITH _S0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS +), _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.DEVICES +) +SELECT + ROUND(_S0.N_ROWS / _S1.N_ROWS, 2) AS ir +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql new file mode 100644 index 000000000..b3fa5f7ca --- /dev/null +++ b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql @@ -0,0 +1,17 @@ +SELECT + CALENDAR.ca_dt AS start_of_period, + COUNT(*) AS n_purchases +FROM MAIN.CALENDAR CALENDAR +JOIN MAIN.CALENDAR CALENDAR_2 + ON CALENDAR.ca_dt <= CALENDAR_2.ca_dt + AND CALENDAR_2.ca_dt < DATE_ADD(CAST(CALENDAR.ca_dt AS TIMESTAMP), 5, 'DAY') +JOIN MAIN.DEVICES DEVICES + ON CALENDAR_2.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') +WHERE + EXTRACT(YEAR FROM CAST(CALENDAR.ca_dt AS DATETIME)) = 2024 +GROUP BY + CALENDAR.ca_dt +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql new file mode 100644 index 000000000..ddcd91706 --- /dev/null +++ b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql @@ -0,0 +1,41 @@ +WITH _S0 AS ( + SELECT + de_product_id AS DE_PRODUCT_ID, + COUNT(*) AS N_ROWS + FROM MAIN.DEVICES + GROUP BY + de_product_id +), _S1 AS ( + SELECT + pr_id AS PR_ID, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS +), _S6 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S1.PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + SUM(_S0.N_ROWS) AS SUM_N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON _S0.DE_PRODUCT_ID = _S1.PR_ID + GROUP BY + EXTRACT(YEAR FROM CAST(_S1.PR_RELEASE AS DATETIME)) +), _S7 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S3.PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + COUNT(*) AS N_ROWS + FROM MAIN.DEVICES DEVICES + JOIN _S1 _S3 + ON DEVICES.de_product_id = _S3.PR_ID + JOIN MAIN.INCIDENTS INCIDENTS + ON DEVICES.de_id = INCIDENTS.in_device_id + GROUP BY + EXTRACT(YEAR FROM CAST(_S3.PR_RELEASE AS DATETIME)) +) +SELECT + _S6.YEAR_PR_RELEASE AS year, + ROUND(NVL(_S7.N_ROWS, 0) / _S6.SUM_N_ROWS, 2) AS ir +FROM _S6 _S6 +LEFT JOIN _S7 _S7 + ON _S6.YEAR_PR_RELEASE = _S7.YEAR_PR_RELEASE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql new file mode 100644 index 000000000..84a771042 --- /dev/null +++ b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql @@ -0,0 +1,20 @@ +WITH _S3 AS ( + SELECT + in_device_id AS IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS + GROUP BY + in_device_id +) +SELECT + PRODUCTS.pr_brand AS brand, + ROUND(NVL(SUM(_S3.N_ROWS), 0) / COUNT(*), 2) AS ir +FROM MAIN.DEVICES DEVICES +JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id +LEFT JOIN _S3 _S3 + ON DEVICES.de_id = _S3.IN_DEVICE_ID +GROUP BY + PRODUCTS.pr_brand +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql new file mode 100644 index 000000000..7e5e503b8 --- /dev/null +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -0,0 +1,70 @@ +WITH _T2 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR + WHERE + EXTRACT(YEAR FROM CAST(ca_dt AS DATETIME)) IN (2020, 2021) +), _T5 AS ( + SELECT + co_id AS CO_ID, + co_name AS CO_NAME + FROM MAIN.COUNTRIES + WHERE + co_name = 'CN' +), _S7 AS ( + SELECT + _T4.CA_DT, + COUNT(*) AS N_ROWS + FROM _T2 _T4 + JOIN MAIN.CALENDAR CALENDAR + ON CALENDAR.ca_dt >= DATE_SUB(CAST(_T4.CA_DT AS TIMESTAMP), 6, MONTH) + JOIN MAIN.DEVICES DEVICES + ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN _T5 _T5 + ON DEVICES.de_production_country_id = _T5.CO_ID + GROUP BY + _T4.CA_DT +), _S15 AS ( + SELECT + _T7.CA_DT, + COUNT(*) AS N_ROWS + FROM _T2 _T7 + JOIN MAIN.INCIDENTS INCIDENTS + ON _T7.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id + JOIN _T5 _T8 + ON DEVICES.de_production_country_id = _T8.CO_ID + GROUP BY + _T7.CA_DT +), _T0 AS ( + SELECT + EXTRACT(MONTH FROM CAST(_T2.CA_DT AS DATETIME)) AS MONTH_CA_DT, + EXTRACT(YEAR FROM CAST(_T2.CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM(_S7.N_ROWS) AS SUM_EXPR_3, + SUM(_S15.N_ROWS) AS SUM_N_ROWS + FROM _T2 _T2 + LEFT JOIN _S7 _S7 + ON _S7.CA_DT = _T2.CA_DT + LEFT JOIN _S15 _S15 + ON _S15.CA_DT = _T2.CA_DT + GROUP BY + EXTRACT(MONTH FROM CAST(_T2.CA_DT AS DATETIME)), + EXTRACT(YEAR FROM CAST(_T2.CA_DT AS DATETIME)) +) +SELECT + LISTAGG( + '-', + YEAR_CA_DT, + CASE + WHEN LENGTH(MONTH_CA_DT) >= 2 + THEN SUBSTR(MONTH_CA_DT, 1, 2) + ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) + END + ) AS month, + ROUND(( + 1000000.0 * NVL(SUM_N_ROWS, 0) + ) / NVL(SUM_EXPR_3, 0), 2) AS ir +FROM _T0 +ORDER BY + MONTH_CA_DT NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql new file mode 100644 index 000000000..17ed6ecf1 --- /dev/null +++ b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql @@ -0,0 +1,29 @@ +WITH _S1 AS ( + SELECT + in_device_id AS IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS + GROUP BY + in_device_id +), _S3 AS ( + SELECT + DEVICES.de_product_id AS DE_PRODUCT_ID, + COUNT(*) AS N_ROWS, + SUM(_S1.N_ROWS) AS SUM_N_ROWS + FROM MAIN.DEVICES DEVICES + LEFT JOIN _S1 _S1 + ON DEVICES.de_id = _S1.IN_DEVICE_ID + GROUP BY + DEVICES.de_product_id +) +SELECT + PRODUCTS.pr_name AS product, + PRODUCTS.pr_brand AS product_brand, + PRODUCTS.pr_type AS product_type, + ROUND(NVL(_S3.SUM_N_ROWS, 0) / _S3.N_ROWS, 2) AS ir +FROM MAIN.PRODUCTS PRODUCTS +JOIN _S3 _S3 + ON PRODUCTS.pr_id = _S3.DE_PRODUCT_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql new file mode 100644 index 000000000..f53d9460f --- /dev/null +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql @@ -0,0 +1,83 @@ +WITH _S14 AS ( + SELECT + ANY_VALUE(pr_release) AS ANYTHING_PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'GoldCopper-Star' +), _S6 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _T5 AS ( + SELECT + pr_id AS PR_ID, + pr_name AS PR_NAME + FROM MAIN.PRODUCTS + WHERE + pr_name = 'GoldCopper-Star' +), _S7 AS ( + SELECT + _S0.CA_DT, + COUNT(*) AS N_ROWS + FROM _S6 _S0 + JOIN MAIN.INCIDENTS INCIDENTS + ON _S0.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id + JOIN _T5 _T5 + ON DEVICES.de_product_id = _T5.PR_ID + GROUP BY + _S0.CA_DT +), _S13 AS ( + SELECT + _S8.CA_DT, + COUNT(*) AS N_ROWS + FROM _S6 _S8 + JOIN MAIN.DEVICES DEVICES + ON _S8.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN _T5 _T7 + ON DEVICES.de_product_id = _T7.PR_ID + GROUP BY + _S8.CA_DT +), _S15 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S6.CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM(_S7.N_ROWS) AS SUM_EXPR_4, + SUM(_S13.N_ROWS) AS SUM_N_ROWS + FROM _S6 _S6 + LEFT JOIN _S7 _S7 + ON _S6.CA_DT = _S7.CA_DT + LEFT JOIN _S13 _S13 + ON _S13.CA_DT = _S6.CA_DT + GROUP BY + EXTRACT(YEAR FROM CAST(_S6.CA_DT AS DATETIME)) +) +SELECT + _S15.YEAR_CA_DT - EXTRACT(YEAR FROM CAST(_S14.ANYTHING_PR_RELEASE AS DATETIME)) AS years_since_release, + ROUND( + SUM(NVL(_S15.SUM_EXPR_4, 0)) OVER (ORDER BY _S15.YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S15.SUM_N_ROWS, 0)) OVER (ORDER BY _S15.YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS cum_ir, + ROUND( + ( + 100.0 * ( + NVL(_S15.SUM_N_ROWS, 0) - LAG(NVL(_S15.SUM_N_ROWS, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT) + ) + ) / LAG(NVL(_S15.SUM_N_ROWS, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT), + 2 + ) AS pct_bought_change, + ROUND( + ( + 100.0 * ( + NVL(_S15.SUM_EXPR_4, 0) - LAG(NVL(_S15.SUM_EXPR_4, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT) + ) + ) / LAG(NVL(_S15.SUM_EXPR_4, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT), + 2 + ) AS pct_incident_change, + NVL(_S15.SUM_N_ROWS, 0) AS bought, + NVL(_S15.SUM_EXPR_4, 0) AS incidents +FROM _S14 _S14 +JOIN _S15 _S15 + ON _S15.YEAR_CA_DT >= EXTRACT(YEAR FROM CAST(_S14.ANYTHING_PR_RELEASE AS DATETIME)) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql new file mode 100644 index 000000000..175af7a5c --- /dev/null +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql @@ -0,0 +1,64 @@ +WITH _S2 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _S3 AS ( + SELECT + _S0.CA_DT, + COUNT(*) AS N_ROWS + FROM _S2 _S0 + JOIN MAIN.DEVICES DEVICES + ON _S0.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + GROUP BY + _S0.CA_DT +), _S7 AS ( + SELECT + _S4.CA_DT, + COUNT(*) AS N_ROWS + FROM _S2 _S4 + JOIN MAIN.INCIDENTS INCIDENTS + ON _S4.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + GROUP BY + _S4.CA_DT +), _T1 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S2.CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM(_S3.N_ROWS) AS SUM_EXPR_3, + SUM(_S7.N_ROWS) AS SUM_N_ROWS + FROM _S2 _S2 + LEFT JOIN _S3 _S3 + ON _S2.CA_DT = _S3.CA_DT + LEFT JOIN _S7 _S7 + ON _S2.CA_DT = _S7.CA_DT + GROUP BY + EXTRACT(YEAR FROM CAST(_S2.CA_DT AS DATETIME)) +) +SELECT + YEAR_CA_DT AS yr, + ROUND( + SUM(NVL(SUM_N_ROWS, 0)) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(SUM_EXPR_3) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS cum_ir, + ROUND( + ( + 100.0 * ( + SUM_EXPR_3 - LAG(SUM_EXPR_3, 1) OVER (ORDER BY YEAR_CA_DT) + ) + ) / LAG(SUM_EXPR_3, 1) OVER (ORDER BY YEAR_CA_DT), + 2 + ) AS pct_bought_change, + ROUND( + ( + 100.0 * ( + NVL(SUM_N_ROWS, 0) - LAG(NVL(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT) + ) + ) / LAG(NVL(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT), + 2 + ) AS pct_incident_change, + SUM_EXPR_3 AS bought, + NVL(SUM_N_ROWS, 0) AS incidents +FROM _T1 +WHERE + NOT SUM_EXPR_3 IS NULL AND SUM_EXPR_3 <> 0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/time_threshold_reached_oracle.sql b/tests/test_sql_refsols/time_threshold_reached_oracle.sql new file mode 100644 index 000000000..3d399735d --- /dev/null +++ b/tests/test_sql_refsols/time_threshold_reached_oracle.sql @@ -0,0 +1,24 @@ +WITH _T3 AS ( + SELECT + sbtxdatetime AS SBTXDATETIME, + ( + 100.0 * SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) + ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY')) AS PCT_OF_DAY + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +), _T AS ( + SELECT + SBTXDATETIME, + ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'DAY') ORDER BY PCT_OF_DAY) AS _W + FROM _T3 + WHERE + PCT_OF_DAY >= 50.0 +) +SELECT + SBTXDATETIME AS date_time +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/top_customers_by_orders_oracle.sql b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql new file mode 100644 index 000000000..f42e449d6 --- /dev/null +++ b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +) +SELECT + CUSTOMER.c_custkey AS customer_key, + NVL(_S1.N_ROWS, 0) AS n_orders +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql b/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql new file mode 100644 index 000000000..93cc2f7a8 --- /dev/null +++ b/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql @@ -0,0 +1,34 @@ +WITH _S2 AS ( + SELECT + l_linenumber AS L_LINENUMBER, + l_orderkey AS L_ORDERKEY, + l_partkey AS L_PARTKEY, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST + FETCH FIRST 7 ROWS ONLY +), _S0 AS ( + SELECT + ps_partkey AS PS_PARTKEY, + ps_suppkey AS PS_SUPPKEY + FROM TPCH.PARTSUPP +) +SELECT + _S2.L_ORDERKEY AS order_key, + _S2.L_LINENUMBER AS line_number, + PART.p_size AS part_size, + SUPPLIER.s_nationkey AS supplier_nation +FROM _S2 _S2 +JOIN _S0 _S0 + ON _S0.PS_PARTKEY = _S2.L_PARTKEY AND _S0.PS_SUPPKEY = _S2.L_SUPPKEY +JOIN TPCH.PART PART + ON PART.p_partkey = _S0.PS_PARTKEY +JOIN _S0 _S4 + ON _S2.L_PARTKEY = _S4.PS_PARTKEY AND _S2.L_SUPPKEY = _S4.PS_SUPPKEY +JOIN TPCH.SUPPLIER SUPPLIER + ON SUPPLIER.s_suppkey = _S4.PS_SUPPKEY +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql b/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql new file mode 100644 index 000000000..2ba9d5bfe --- /dev/null +++ b/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql @@ -0,0 +1,28 @@ +WITH _S1 AS ( + SELECT + ps_partkey AS PS_PARTKEY, + ps_suppkey AS PS_SUPPKEY + FROM TPCH.PARTSUPP +) +SELECT + LINEITEM.l_orderkey AS order_key, + LINEITEM.l_linenumber AS line_number, + PART.p_size AS part_size, + NATION.n_nationkey AS supplier_nation +FROM TPCH.PART PART +JOIN _S1 _S1 + ON PART.p_partkey = _S1.PS_PARTKEY +CROSS JOIN TPCH.NATION NATION +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN _S1 _S7 + ON SUPPLIER.s_suppkey = _S7.PS_SUPPKEY +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = PART.p_partkey + AND LINEITEM.l_partkey = _S7.PS_PARTKEY + AND LINEITEM.l_suppkey = _S1.PS_SUPPKEY + AND LINEITEM.l_suppkey = _S7.PS_SUPPKEY +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST +FETCH FIRST 7 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q10_oracle.sql b/tests/test_sql_refsols/tpch_q10_oracle.sql new file mode 100644 index 000000000..36805543d --- /dev/null +++ b/tests/test_sql_refsols/tpch_q10_oracle.sql @@ -0,0 +1,33 @@ +WITH _S3 AS ( + SELECT + ORDERS.o_custkey AS O_CUSTKEY, + SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )) AS SUM_EXPR + FROM TPCH.ORDERS ORDERS + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_returnflag = 'R' + WHERE + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (10, 11, 12) + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1993 + GROUP BY + ORDERS.o_custkey +) +SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + CUSTOMER.c_name AS C_NAME, + NVL(_S3.SUM_EXPR, 0) AS REVENUE, + CUSTOMER.c_acctbal AS C_ACCTBAL, + NATION.n_name AS N_NAME, + CUSTOMER.c_address AS C_ADDRESS, + CUSTOMER.c_phone AS C_PHONE, + CUSTOMER.c_comment AS C_COMMENT +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 20 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q11_oracle.sql b/tests/test_sql_refsols/tpch_q11_oracle.sql new file mode 100644 index 000000000..97d323b64 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q11_oracle.sql @@ -0,0 +1,43 @@ +WITH _S0 AS ( + SELECT + s_nationkey AS S_NATIONKEY, + s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER +), _T2 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY + FROM TPCH.NATION + WHERE + n_name = 'GERMANY' +), _S8 AS ( + SELECT + SUM(PARTSUPP.ps_supplycost * PARTSUPP.ps_availqty) AS SUM_METRIC + FROM TPCH.PARTSUPP PARTSUPP + JOIN _S0 _S0 + ON PARTSUPP.ps_suppkey = _S0.S_SUPPKEY + JOIN _T2 _T2 + ON _S0.S_NATIONKEY = _T2.N_NATIONKEY +), _S9 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUM(PARTSUPP.ps_supplycost * PARTSUPP.ps_availqty) AS SUM_EXPR + FROM TPCH.PARTSUPP PARTSUPP + JOIN _S0 _S4 + ON PARTSUPP.ps_suppkey = _S4.S_SUPPKEY + JOIN _T2 _T4 + ON _S4.S_NATIONKEY = _T4.N_NATIONKEY + GROUP BY + PARTSUPP.ps_partkey +) +SELECT + _S9.PS_PARTKEY, + NVL(_S9.SUM_EXPR, 0) AS VALUE +FROM _S8 _S8 +JOIN _S9 _S9 + ON ( + NVL(_S8.SUM_METRIC, 0) * 0.0001 + ) < NVL(_S9.SUM_EXPR, 0) +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q12_oracle.sql b/tests/test_sql_refsols/tpch_q12_oracle.sql new file mode 100644 index 000000000..26b980c89 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q12_oracle.sql @@ -0,0 +1,18 @@ +SELECT + LINEITEM.l_shipmode AS L_SHIPMODE, + NVL(SUM(ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS HIGH_LINE_COUNT, + NVL(SUM(NOT ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS LOW_LINE_COUNT +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.ORDERS ORDERS + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +WHERE + EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1994 + AND LINEITEM.l_commitdate < LINEITEM.l_receiptdate + AND LINEITEM.l_commitdate > LINEITEM.l_shipdate + AND ( + LINEITEM.l_shipmode = 'MAIL' OR LINEITEM.l_shipmode = 'SHIP' + ) +GROUP BY + LINEITEM.l_shipmode +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q13_oracle.sql b/tests/test_sql_refsols/tpch_q13_oracle.sql new file mode 100644 index 000000000..299744cfc --- /dev/null +++ b/tests/test_sql_refsols/tpch_q13_oracle.sql @@ -0,0 +1,22 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + WHERE + NOT o_comment LIKE '%special%requests%' + GROUP BY + o_custkey +) +SELECT + NVL(_S1.N_ROWS, 0) AS C_COUNT, + COUNT(*) AS CUSTDIST +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +GROUP BY + NVL(_S1.N_ROWS, 0) +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q14_oracle.sql b/tests/test_sql_refsols/tpch_q14_oracle.sql new file mode 100644 index 000000000..c624de595 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q14_oracle.sql @@ -0,0 +1,23 @@ +SELECT + ( + 100.0 * NVL( + SUM( + CASE + WHEN PART.p_type LIKE 'PROMO%' + THEN LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) + ELSE 0 + END + ), + 0 + ) + ) / NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS PROMO_REVENUE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey +WHERE + EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 9 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 diff --git a/tests/test_sql_refsols/tpch_q15_oracle.sql b/tests/test_sql_refsols/tpch_q15_oracle.sql new file mode 100644 index 000000000..a684e9527 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q15_oracle.sql @@ -0,0 +1,45 @@ +WITH _T3 AS ( + SELECT + l_discount AS L_DISCOUNT, + l_extendedprice AS L_EXTENDEDPRICE, + l_shipdate AS L_SHIPDATE, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + WHERE + l_shipdate < TO_DATE('1996-04-01', 'YYYY-MM-DD') + AND l_shipdate >= TO_DATE('1996-01-01', 'YYYY-MM-DD') +), _T1 AS ( + SELECT + SUM(L_EXTENDEDPRICE * ( + 1 - L_DISCOUNT + )) AS SUM_EXPR + FROM _T3 + GROUP BY + L_SUPPKEY +), _S0 AS ( + SELECT + MAX(NVL(SUM_EXPR, 0)) AS MAX_TOTAL_REVENUE + FROM _T1 +), _S3 AS ( + SELECT + L_SUPPKEY, + SUM(L_EXTENDEDPRICE * ( + 1 - L_DISCOUNT + )) AS SUM_EXPR + FROM _T3 + GROUP BY + L_SUPPKEY +) +SELECT + SUPPLIER.s_suppkey AS S_SUPPKEY, + SUPPLIER.s_name AS S_NAME, + SUPPLIER.s_address AS S_ADDRESS, + SUPPLIER.s_phone AS S_PHONE, + NVL(_S3.SUM_EXPR, 0) AS TOTAL_REVENUE +FROM _S0 _S0 +CROSS JOIN TPCH.SUPPLIER SUPPLIER +JOIN _S3 _S3 + ON SUPPLIER.s_suppkey = _S3.L_SUPPKEY + AND _S0.MAX_TOTAL_REVENUE = NVL(_S3.SUM_EXPR, 0) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q16_oracle.sql b/tests/test_sql_refsols/tpch_q16_oracle.sql new file mode 100644 index 000000000..29deb419f --- /dev/null +++ b/tests/test_sql_refsols/tpch_q16_oracle.sql @@ -0,0 +1,24 @@ +SELECT + PART.p_brand AS P_BRAND, + PART.p_type AS P_TYPE, + PART.p_size AS P_SIZE, + COUNT(DISTINCT PARTSUPP.ps_suppkey) AS SUPPLIER_COUNT +FROM TPCH.PARTSUPP PARTSUPP +JOIN TPCH.SUPPLIER SUPPLIER + ON NOT SUPPLIER.s_comment LIKE '%Customer%Complaints%' + AND PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.PART PART + ON NOT PART.p_type LIKE 'MEDIUM POLISHED%%' + AND PART.p_brand <> 'BRAND#45' + AND PART.p_partkey = PARTSUPP.ps_partkey + AND PART.p_size IN (49, 14, 23, 45, 19, 3, 36, 9) +GROUP BY + PART.p_brand, + PART.p_size, + PART.p_type +ORDER BY + 4 DESC NULLS LAST, + 1 NULLS FIRST, + 2 NULLS FIRST, + 3 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q17_oracle.sql b/tests/test_sql_refsols/tpch_q17_oracle.sql new file mode 100644 index 000000000..553a5444e --- /dev/null +++ b/tests/test_sql_refsols/tpch_q17_oracle.sql @@ -0,0 +1,18 @@ +WITH _T AS ( + SELECT + LINEITEM.l_extendedprice AS L_EXTENDEDPRICE, + LINEITEM.l_quantity AS L_QUANTITY, + AVG(CAST(LINEITEM.l_quantity AS DOUBLE PRECISION)) OVER (PARTITION BY LINEITEM.l_partkey) AS _W + FROM TPCH.PART PART + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = PART.p_partkey + WHERE + PART.p_brand = 'Brand#23' AND PART.p_container = 'MED BOX' +) +SELECT + NVL(SUM(L_EXTENDEDPRICE), 0) / 7.0 AS AVG_YEARLY +FROM _T +WHERE + L_QUANTITY < ( + 0.2 * _W + ) diff --git a/tests/test_sql_refsols/tpch_q18_oracle.sql b/tests/test_sql_refsols/tpch_q18_oracle.sql new file mode 100644 index 000000000..56cc887f6 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q18_oracle.sql @@ -0,0 +1,26 @@ +WITH _T1 AS ( + SELECT + l_orderkey AS L_ORDERKEY, + SUM(l_quantity) AS SUM_L_QUANTITY + FROM TPCH.LINEITEM + GROUP BY + l_orderkey +) +SELECT + CUSTOMER.c_name AS C_NAME, + CUSTOMER.c_custkey AS C_CUSTKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ORDERS.o_orderdate AS O_ORDERDATE, + ORDERS.o_totalprice AS O_TOTALPRICE, + _T1.SUM_L_QUANTITY AS TOTAL_QUANTITY +FROM TPCH.ORDERS ORDERS +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey +JOIN _T1 _T1 + ON NOT _T1.SUM_L_QUANTITY IS NULL + AND ORDERS.o_orderkey = _T1.L_ORDERKEY + AND _T1.SUM_L_QUANTITY > 300 +ORDER BY + 5 DESC NULLS LAST, + 4 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q19_oracle.sql b/tests/test_sql_refsols/tpch_q19_oracle.sql new file mode 100644 index 000000000..8d61bd47f --- /dev/null +++ b/tests/test_sql_refsols/tpch_q19_oracle.sql @@ -0,0 +1,36 @@ +SELECT + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON ( + ( + LINEITEM.l_quantity <= 11 + AND LINEITEM.l_quantity >= 1 + AND PART.p_brand = 'Brand#12' + AND PART.p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') + AND PART.p_size <= 5 + AND PART.p_size >= 1 + ) + OR ( + LINEITEM.l_quantity <= 20 + AND LINEITEM.l_quantity >= 10 + AND PART.p_brand = 'Brand#23' + AND PART.p_container IN ('MED BAG', 'MED BOX', 'MED PACK', 'MED PKG') + AND PART.p_size <= 10 + AND PART.p_size >= 1 + ) + OR ( + LINEITEM.l_quantity <= 30 + AND LINEITEM.l_quantity >= 20 + AND PART.p_brand = 'Brand#34' + AND PART.p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') + AND PART.p_size <= 15 + AND PART.p_size >= 1 + ) + ) + AND LINEITEM.l_partkey = PART.p_partkey +WHERE + LINEITEM.l_shipinstruct = 'DELIVER IN PERSON' + AND LINEITEM.l_shipmode IN ('AIR', 'AIR REG') diff --git a/tests/test_sql_refsols/tpch_q1_oracle.sql b/tests/test_sql_refsols/tpch_q1_oracle.sql new file mode 100644 index 000000000..cd723794a --- /dev/null +++ b/tests/test_sql_refsols/tpch_q1_oracle.sql @@ -0,0 +1,26 @@ +SELECT + l_returnflag AS L_RETURNFLAG, + l_linestatus AS L_LINESTATUS, + NVL(SUM(l_quantity), 0) AS SUM_QTY, + NVL(SUM(l_extendedprice), 0) AS SUM_BASE_PRICE, + NVL(SUM(l_extendedprice * ( + 1 - l_discount + )), 0) AS SUM_DISC_PRICE, + NVL(SUM(l_extendedprice * ( + 1 - l_discount + ) * ( + 1 + l_tax + )), 0) AS SUM_CHARGE, + AVG(l_quantity) AS AVG_QTY, + AVG(l_extendedprice) AS AVG_PRICE, + AVG(l_discount) AS AVG_DISC, + COUNT(*) AS COUNT_ORDER +FROM TPCH.LINEITEM +WHERE + l_shipdate <= TO_DATE('1998-12-01', 'YYYY-MM-DD') +GROUP BY + l_linestatus, + l_returnflag +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q20_oracle.sql b/tests/test_sql_refsols/tpch_q20_oracle.sql new file mode 100644 index 000000000..b331574c2 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q20_oracle.sql @@ -0,0 +1,31 @@ +WITH _S5 AS ( + SELECT + LINEITEM.l_partkey AS L_PARTKEY, + SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY + FROM TPCH.PART PART + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1994 + AND LINEITEM.l_partkey = PART.p_partkey + WHERE + PART.p_name LIKE 'forest%' + GROUP BY + LINEITEM.l_partkey +) +SELECT + ANY_VALUE(SUPPLIER.s_name) AS S_NAME, + ANY_VALUE(SUPPLIER.s_address) AS S_ADDRESS +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_name = 'CANADA' AND NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.PARTSUPP PARTSUPP + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +JOIN _S5 _S5 + ON PARTSUPP.ps_availqty > ( + 0.5 * NVL(_S5.SUM_L_QUANTITY, 0) + ) + AND PARTSUPP.ps_partkey = _S5.L_PARTKEY +GROUP BY + PARTSUPP.ps_suppkey +ORDER BY + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q21_oracle.sql b/tests/test_sql_refsols/tpch_q21_oracle.sql new file mode 100644 index 000000000..691c66c38 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q21_oracle.sql @@ -0,0 +1,55 @@ +WITH _T5 AS ( + SELECT + l_commitdate AS L_COMMITDATE, + l_linenumber AS L_LINENUMBER, + l_orderkey AS L_ORDERKEY, + l_receiptdate AS L_RECEIPTDATE, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + WHERE + l_commitdate < l_receiptdate +), _T3 AS ( + SELECT + _T5.L_LINENUMBER, + _T5.L_ORDERKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ANY_VALUE(_T5.L_SUPPKEY) AS ANYTHING_L_SUPPKEY, + ANY_VALUE(ORDERS.o_orderstatus) AS ANYTHING_O_ORDERSTATUS + FROM _T5 _T5 + JOIN TPCH.ORDERS ORDERS + ON ORDERS.o_orderkey = _T5.L_ORDERKEY + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_suppkey <> _T5.L_SUPPKEY + GROUP BY + _T5.L_LINENUMBER, + _T5.L_ORDERKEY, + ORDERS.o_orderkey +), _S11 AS ( + SELECT + _T3.ANYTHING_L_SUPPKEY + FROM _T3 _T3 + JOIN _T5 _T6 + ON _T3.L_LINENUMBER = _T6.L_LINENUMBER + AND _T3.L_ORDERKEY = _T6.L_ORDERKEY + AND _T3.O_ORDERKEY = _T6.L_ORDERKEY + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate + AND LINEITEM.l_orderkey = _T6.L_ORDERKEY + AND LINEITEM.l_suppkey <> _T6.L_SUPPKEY + WHERE + _T3.ANYTHING_O_ORDERSTATUS = 'F' +) +SELECT + ANY_VALUE(SUPPLIER.s_name) AS S_NAME, + NVL(NULLIF(COUNT(_S11.ANYTHING_L_SUPPKEY), 0), 0) AS NUMWAIT +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_name = 'SAUDI ARABIA' AND NATION.n_nationkey = SUPPLIER.s_nationkey +LEFT JOIN _S11 _S11 + ON SUPPLIER.s_suppkey = _S11.ANYTHING_L_SUPPKEY +GROUP BY + SUPPLIER.s_suppkey +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q2_oracle.sql b/tests/test_sql_refsols/tpch_q2_oracle.sql new file mode 100644 index 000000000..cc7b59fcd --- /dev/null +++ b/tests/test_sql_refsols/tpch_q2_oracle.sql @@ -0,0 +1,41 @@ +WITH _T AS ( + SELECT + NATION.n_name AS N_NAME, + PART.p_mfgr AS P_MFGR, + PART.p_partkey AS P_PARTKEY, + SUPPLIER.s_acctbal AS S_ACCTBAL, + SUPPLIER.s_address AS S_ADDRESS, + SUPPLIER.s_comment AS S_COMMENT, + SUPPLIER.s_name AS S_NAME, + SUPPLIER.s_phone AS S_PHONE, + RANK() OVER (PARTITION BY PARTSUPP.ps_partkey ORDER BY PARTSUPP.ps_supplycost) AS _W + FROM TPCH.PART PART + JOIN TPCH.PARTSUPP PARTSUPP + ON PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.SUPPLIER SUPPLIER + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey + JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'EUROPE' + WHERE + PART.p_size = 15 AND PART.p_type LIKE '%BRASS' +) +SELECT + S_ACCTBAL, + S_NAME, + N_NAME, + P_PARTKEY, + P_MFGR, + S_ADDRESS, + S_PHONE, + S_COMMENT +FROM _T +WHERE + _W = 1 +ORDER BY + 1 DESC NULLS LAST, + 3 NULLS FIRST, + 2 NULLS FIRST, + 4 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q3_oracle.sql b/tests/test_sql_refsols/tpch_q3_oracle.sql new file mode 100644 index 000000000..d4595b0ac --- /dev/null +++ b/tests/test_sql_refsols/tpch_q3_oracle.sql @@ -0,0 +1,24 @@ +SELECT + LINEITEM.l_orderkey AS L_ORDERKEY, + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE, + ORDERS.o_orderdate AS O_ORDERDATE, + ORDERS.o_shippriority AS O_SHIPPRIORITY +FROM TPCH.ORDERS ORDERS +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey + AND LINEITEM.l_shipdate > TO_DATE('1995-03-15', 'YYYY-MM-DD') +WHERE + ORDERS.o_orderdate < TO_DATE('1995-03-15', 'YYYY-MM-DD') +GROUP BY + LINEITEM.l_orderkey, + ORDERS.o_orderdate, + ORDERS.o_shippriority +ORDER BY + 2 DESC NULLS LAST, + 3 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q4_oracle.sql b/tests/test_sql_refsols/tpch_q4_oracle.sql new file mode 100644 index 000000000..3dba2c4f5 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q4_oracle.sql @@ -0,0 +1,14 @@ +SELECT + ORDERS.o_orderpriority AS O_ORDERPRIORITY, + COUNT(*) AS ORDER_COUNT +FROM TPCH.ORDERS ORDERS +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate + AND LINEITEM.l_orderkey = ORDERS.o_orderkey +WHERE + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (7, 8, 9) + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1993 +GROUP BY + ORDERS.o_orderpriority +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q5_oracle.sql b/tests/test_sql_refsols/tpch_q5_oracle.sql new file mode 100644 index 000000000..0054cdbc7 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q5_oracle.sql @@ -0,0 +1,30 @@ +WITH _S11 AS ( + SELECT + NATION.n_name AS N_NAME, + SUPPLIER.s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER SUPPLIER + JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +) +SELECT + ANY_VALUE(NATION.n_name) AS N_NAME, + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND ORDERS.o_orderdate < TO_DATE('1995-01-01', 'YYYY-MM-DD') + AND ORDERS.o_orderdate >= TO_DATE('1994-01-01', 'YYYY-MM-DD') +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN _S11 _S11 + ON LINEITEM.l_suppkey = _S11.S_SUPPKEY AND NATION.n_name = _S11.N_NAME +GROUP BY + NATION.n_nationkey +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/tpch_q6_oracle.sql b/tests/test_sql_refsols/tpch_q6_oracle.sql new file mode 100644 index 000000000..80f156bc9 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + NVL(SUM(l_extendedprice * l_discount), 0) AS REVENUE +FROM TPCH.LINEITEM +WHERE + l_discount <= 0.07 + AND l_discount >= 0.05 + AND l_quantity < 24 + AND l_shipdate < TO_DATE('1995-01-01', 'YYYY-MM-DD') + AND l_shipdate >= TO_DATE('1994-01-01', 'YYYY-MM-DD') diff --git a/tests/test_sql_refsols/tpch_q7_oracle.sql b/tests/test_sql_refsols/tpch_q7_oracle.sql new file mode 100644 index 000000000..765fcc3ea --- /dev/null +++ b/tests/test_sql_refsols/tpch_q7_oracle.sql @@ -0,0 +1,46 @@ +WITH _S9 AS ( + SELECT + NATION.n_name AS N_NAME, + ORDERS.o_orderkey AS O_ORDERKEY + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey + AND ( + NATION.n_name = 'FRANCE' OR NATION.n_name = 'GERMANY' + ) +) +SELECT + NATION.n_name AS SUPP_NATION, + _S9.N_NAME AS CUST_NATION, + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) AS L_YEAR, + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN _S9 _S9 + ON LINEITEM.l_orderkey = _S9.O_ORDERKEY + AND ( + NATION.n_name = 'FRANCE' OR NATION.n_name = 'GERMANY' + ) + AND ( + NATION.n_name = 'FRANCE' OR _S9.N_NAME = 'FRANCE' + ) + AND ( + NATION.n_name = 'GERMANY' OR _S9.N_NAME = 'GERMANY' + ) +WHERE + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) +GROUP BY + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)), + _S9.N_NAME, + NATION.n_name +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST, + 3 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q8_oracle.sql b/tests/test_sql_refsols/tpch_q8_oracle.sql new file mode 100644 index 000000000..4bf2f76b9 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q8_oracle.sql @@ -0,0 +1,34 @@ +SELECT + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS O_YEAR, + NVL( + SUM( + CASE + WHEN NATION_2.n_name = 'BRAZIL' + THEN LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) + ELSE 0 + END + ), + 0 + ) / NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS MKT_SHARE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey AND PART.p_type = 'ECONOMY ANODIZED STEEL' +JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (1995, 1996) + AND LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AMERICA' +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.NATION NATION_2 + ON NATION_2.n_nationkey = SUPPLIER.s_nationkey +GROUP BY + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) diff --git a/tests/test_sql_refsols/tpch_q9_oracle.sql b/tests/test_sql_refsols/tpch_q9_oracle.sql new file mode 100644 index 000000000..f8bb56e29 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q9_oracle.sql @@ -0,0 +1,30 @@ +SELECT + NATION.n_name AS NATION, + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS O_YEAR, + NVL( + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) - PARTSUPP.ps_supplycost * LINEITEM.l_quantity + ), + 0 + ) AS AMOUNT +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey AND PART.p_name LIKE '%green%' +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.ORDERS ORDERS + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN TPCH.PARTSUPP PARTSUPP + ON LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey +GROUP BY + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)), + NATION.n_name +ORDER BY + 1 NULLS FIRST, + 2 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/triple_partition_oracle.sql b/tests/test_sql_refsols/triple_partition_oracle.sql new file mode 100644 index 000000000..e6f47e422 --- /dev/null +++ b/tests/test_sql_refsols/triple_partition_oracle.sql @@ -0,0 +1,72 @@ +WITH _S3 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), _S5 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S14 AS ( + SELECT + ORDERS.o_custkey AS O_CUSTKEY, + PART.p_type AS P_TYPE, + _S5.R_NAME, + COUNT(*) AS N_ROWS + FROM TPCH.PART PART + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 6 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 + AND LINEITEM.l_partkey = PART.p_partkey + JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey + JOIN _S3 _S3 + ON SUPPLIER.s_nationkey = _S3.N_NATIONKEY + JOIN _S5 _S5 + ON _S3.N_REGIONKEY = _S5.R_REGIONKEY + JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + AND LINEITEM.l_orderkey = ORDERS.o_orderkey + WHERE + PART.p_container LIKE 'SM%' + GROUP BY + ORDERS.o_custkey, + PART.p_type, + _S5.R_NAME +), _T2 AS ( + SELECT + _S13.R_NAME AS CUST_REGION, + _S14.R_NAME, + SUM(_S14.N_ROWS) AS SUM_N_ROWS + FROM _S14 _S14 + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = _S14.O_CUSTKEY + JOIN _S3 _S11 + ON CUSTOMER.c_nationkey = _S11.N_NATIONKEY + JOIN _S5 _S13 + ON _S11.N_REGIONKEY = _S13.R_REGIONKEY + GROUP BY + _S13.R_NAME, + _S14.P_TYPE, + _S14.R_NAME +), _T1 AS ( + SELECT + R_NAME, + MAX(SUM_N_ROWS) AS MAX_SUM_N_ROWS, + SUM(SUM_N_ROWS) AS SUM_SUM_N_ROWS + FROM _T2 + GROUP BY + CUST_REGION, + R_NAME +) +SELECT + R_NAME AS region, + AVG(( + 100.0 * MAX_SUM_N_ROWS + ) / SUM_SUM_N_ROWS) AS avgpct +FROM _T1 +GROUP BY + R_NAME +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_1_oracle.sql b/tests/test_sql_refsols/user_range_collection_1_oracle.sql new file mode 100644 index 000000000..d59e1e4ab --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_1_oracle.sql @@ -0,0 +1,36 @@ +WITH _S1 AS ( + SELECT + p_size AS P_SIZE, + COUNT(*) AS N_ROWS + FROM TPCH.PART + WHERE + p_name LIKE '%turquoise%' + GROUP BY + p_size +) +SELECT + COLUMN1 AS part_size, + NVL(_S1.N_ROWS, 0) AS n_parts +FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56), + (61), + (66), + (71), + (76), + (81), + (86), + (91), + (96)) AS SIZES(PART_SIZE) +LEFT JOIN _S1 _S1 + ON COLUMN1 = _S1.P_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_2_oracle.sql b/tests/test_sql_refsols/user_range_collection_2_oracle.sql new file mode 100644 index 000000000..6a404df08 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -0,0 +1,547 @@ +WITH _S0 AS ( + SELECT + COLUMN1 AS X + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A(X) +), _S1 AS ( + SELECT + COLUMN1 AS Y + FROM (VALUES + (0), + (2), + (4), + (6), + (8), + (10), + (12), + (14), + (16), + (18), + (20), + (22), + (24), + (26), + (28), + (30), + (32), + (34), + (36), + (38), + (40), + (42), + (44), + (46), + (48), + (50), + (52), + (54), + (56), + (58), + (60), + (62), + (64), + (66), + (68), + (70), + (72), + (74), + (76), + (78), + (80), + (82), + (84), + (86), + (88), + (90), + (92), + (94), + (96), + (98), + (100), + (102), + (104), + (106), + (108), + (110), + (112), + (114), + (116), + (118), + (120), + (122), + (124), + (126), + (128), + (130), + (132), + (134), + (136), + (138), + (140), + (142), + (144), + (146), + (148), + (150), + (152), + (154), + (156), + (158), + (160), + (162), + (164), + (166), + (168), + (170), + (172), + (174), + (176), + (178), + (180), + (182), + (184), + (186), + (188), + (190), + (192), + (194), + (196), + (198), + (200), + (202), + (204), + (206), + (208), + (210), + (212), + (214), + (216), + (218), + (220), + (222), + (224), + (226), + (228), + (230), + (232), + (234), + (236), + (238), + (240), + (242), + (244), + (246), + (248), + (250), + (252), + (254), + (256), + (258), + (260), + (262), + (264), + (266), + (268), + (270), + (272), + (274), + (276), + (278), + (280), + (282), + (284), + (286), + (288), + (290), + (292), + (294), + (296), + (298), + (300), + (302), + (304), + (306), + (308), + (310), + (312), + (314), + (316), + (318), + (320), + (322), + (324), + (326), + (328), + (330), + (332), + (334), + (336), + (338), + (340), + (342), + (344), + (346), + (348), + (350), + (352), + (354), + (356), + (358), + (360), + (362), + (364), + (366), + (368), + (370), + (372), + (374), + (376), + (378), + (380), + (382), + (384), + (386), + (388), + (390), + (392), + (394), + (396), + (398), + (400), + (402), + (404), + (406), + (408), + (410), + (412), + (414), + (416), + (418), + (420), + (422), + (424), + (426), + (428), + (430), + (432), + (434), + (436), + (438), + (440), + (442), + (444), + (446), + (448), + (450), + (452), + (454), + (456), + (458), + (460), + (462), + (464), + (466), + (468), + (470), + (472), + (474), + (476), + (478), + (480), + (482), + (484), + (486), + (488), + (490), + (492), + (494), + (496), + (498), + (500), + (502), + (504), + (506), + (508), + (510), + (512), + (514), + (516), + (518), + (520), + (522), + (524), + (526), + (528), + (530), + (532), + (534), + (536), + (538), + (540), + (542), + (544), + (546), + (548), + (550), + (552), + (554), + (556), + (558), + (560), + (562), + (564), + (566), + (568), + (570), + (572), + (574), + (576), + (578), + (580), + (582), + (584), + (586), + (588), + (590), + (592), + (594), + (596), + (598), + (600), + (602), + (604), + (606), + (608), + (610), + (612), + (614), + (616), + (618), + (620), + (622), + (624), + (626), + (628), + (630), + (632), + (634), + (636), + (638), + (640), + (642), + (644), + (646), + (648), + (650), + (652), + (654), + (656), + (658), + (660), + (662), + (664), + (666), + (668), + (670), + (672), + (674), + (676), + (678), + (680), + (682), + (684), + (686), + (688), + (690), + (692), + (694), + (696), + (698), + (700), + (702), + (704), + (706), + (708), + (710), + (712), + (714), + (716), + (718), + (720), + (722), + (724), + (726), + (728), + (730), + (732), + (734), + (736), + (738), + (740), + (742), + (744), + (746), + (748), + (750), + (752), + (754), + (756), + (758), + (760), + (762), + (764), + (766), + (768), + (770), + (772), + (774), + (776), + (778), + (780), + (782), + (784), + (786), + (788), + (790), + (792), + (794), + (796), + (798), + (800), + (802), + (804), + (806), + (808), + (810), + (812), + (814), + (816), + (818), + (820), + (822), + (824), + (826), + (828), + (830), + (832), + (834), + (836), + (838), + (840), + (842), + (844), + (846), + (848), + (850), + (852), + (854), + (856), + (858), + (860), + (862), + (864), + (866), + (868), + (870), + (872), + (874), + (876), + (878), + (880), + (882), + (884), + (886), + (888), + (890), + (892), + (894), + (896), + (898), + (900), + (902), + (904), + (906), + (908), + (910), + (912), + (914), + (916), + (918), + (920), + (922), + (924), + (926), + (928), + (930), + (932), + (934), + (936), + (938), + (940), + (942), + (944), + (946), + (948), + (950), + (952), + (954), + (956), + (958), + (960), + (962), + (964), + (966), + (968), + (970), + (972), + (974), + (976), + (978), + (980), + (982), + (984), + (986), + (988), + (990), + (992), + (994), + (996), + (998), + (1000)) AS B(Y) +), _S4 AS ( + SELECT + _S0.X, + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON CAST(_S1.Y AS CLOB) LIKE CONCAT(CAST(_S0.X AS CLOB), '%') + GROUP BY + _S0.X +), _S5 AS ( + SELECT + _S2.X, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + JOIN _S1 _S3 + ON CAST(_S3.Y AS CLOB) LIKE CONCAT('%', CAST(_S2.X AS CLOB)) + GROUP BY + _S2.X +) +SELECT + _S4.X AS x, + _S4.N_ROWS AS n_prefix, + _S5.N_ROWS AS n_suffix +FROM _S4 _S4 +JOIN _S5 _S5 + ON _S4.X = _S5.X +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_3_oracle.sql b/tests/test_sql_refsols/user_range_collection_3_oracle.sql new file mode 100644 index 000000000..6a404df08 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -0,0 +1,547 @@ +WITH _S0 AS ( + SELECT + COLUMN1 AS X + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A(X) +), _S1 AS ( + SELECT + COLUMN1 AS Y + FROM (VALUES + (0), + (2), + (4), + (6), + (8), + (10), + (12), + (14), + (16), + (18), + (20), + (22), + (24), + (26), + (28), + (30), + (32), + (34), + (36), + (38), + (40), + (42), + (44), + (46), + (48), + (50), + (52), + (54), + (56), + (58), + (60), + (62), + (64), + (66), + (68), + (70), + (72), + (74), + (76), + (78), + (80), + (82), + (84), + (86), + (88), + (90), + (92), + (94), + (96), + (98), + (100), + (102), + (104), + (106), + (108), + (110), + (112), + (114), + (116), + (118), + (120), + (122), + (124), + (126), + (128), + (130), + (132), + (134), + (136), + (138), + (140), + (142), + (144), + (146), + (148), + (150), + (152), + (154), + (156), + (158), + (160), + (162), + (164), + (166), + (168), + (170), + (172), + (174), + (176), + (178), + (180), + (182), + (184), + (186), + (188), + (190), + (192), + (194), + (196), + (198), + (200), + (202), + (204), + (206), + (208), + (210), + (212), + (214), + (216), + (218), + (220), + (222), + (224), + (226), + (228), + (230), + (232), + (234), + (236), + (238), + (240), + (242), + (244), + (246), + (248), + (250), + (252), + (254), + (256), + (258), + (260), + (262), + (264), + (266), + (268), + (270), + (272), + (274), + (276), + (278), + (280), + (282), + (284), + (286), + (288), + (290), + (292), + (294), + (296), + (298), + (300), + (302), + (304), + (306), + (308), + (310), + (312), + (314), + (316), + (318), + (320), + (322), + (324), + (326), + (328), + (330), + (332), + (334), + (336), + (338), + (340), + (342), + (344), + (346), + (348), + (350), + (352), + (354), + (356), + (358), + (360), + (362), + (364), + (366), + (368), + (370), + (372), + (374), + (376), + (378), + (380), + (382), + (384), + (386), + (388), + (390), + (392), + (394), + (396), + (398), + (400), + (402), + (404), + (406), + (408), + (410), + (412), + (414), + (416), + (418), + (420), + (422), + (424), + (426), + (428), + (430), + (432), + (434), + (436), + (438), + (440), + (442), + (444), + (446), + (448), + (450), + (452), + (454), + (456), + (458), + (460), + (462), + (464), + (466), + (468), + (470), + (472), + (474), + (476), + (478), + (480), + (482), + (484), + (486), + (488), + (490), + (492), + (494), + (496), + (498), + (500), + (502), + (504), + (506), + (508), + (510), + (512), + (514), + (516), + (518), + (520), + (522), + (524), + (526), + (528), + (530), + (532), + (534), + (536), + (538), + (540), + (542), + (544), + (546), + (548), + (550), + (552), + (554), + (556), + (558), + (560), + (562), + (564), + (566), + (568), + (570), + (572), + (574), + (576), + (578), + (580), + (582), + (584), + (586), + (588), + (590), + (592), + (594), + (596), + (598), + (600), + (602), + (604), + (606), + (608), + (610), + (612), + (614), + (616), + (618), + (620), + (622), + (624), + (626), + (628), + (630), + (632), + (634), + (636), + (638), + (640), + (642), + (644), + (646), + (648), + (650), + (652), + (654), + (656), + (658), + (660), + (662), + (664), + (666), + (668), + (670), + (672), + (674), + (676), + (678), + (680), + (682), + (684), + (686), + (688), + (690), + (692), + (694), + (696), + (698), + (700), + (702), + (704), + (706), + (708), + (710), + (712), + (714), + (716), + (718), + (720), + (722), + (724), + (726), + (728), + (730), + (732), + (734), + (736), + (738), + (740), + (742), + (744), + (746), + (748), + (750), + (752), + (754), + (756), + (758), + (760), + (762), + (764), + (766), + (768), + (770), + (772), + (774), + (776), + (778), + (780), + (782), + (784), + (786), + (788), + (790), + (792), + (794), + (796), + (798), + (800), + (802), + (804), + (806), + (808), + (810), + (812), + (814), + (816), + (818), + (820), + (822), + (824), + (826), + (828), + (830), + (832), + (834), + (836), + (838), + (840), + (842), + (844), + (846), + (848), + (850), + (852), + (854), + (856), + (858), + (860), + (862), + (864), + (866), + (868), + (870), + (872), + (874), + (876), + (878), + (880), + (882), + (884), + (886), + (888), + (890), + (892), + (894), + (896), + (898), + (900), + (902), + (904), + (906), + (908), + (910), + (912), + (914), + (916), + (918), + (920), + (922), + (924), + (926), + (928), + (930), + (932), + (934), + (936), + (938), + (940), + (942), + (944), + (946), + (948), + (950), + (952), + (954), + (956), + (958), + (960), + (962), + (964), + (966), + (968), + (970), + (972), + (974), + (976), + (978), + (980), + (982), + (984), + (986), + (988), + (990), + (992), + (994), + (996), + (998), + (1000)) AS B(Y) +), _S4 AS ( + SELECT + _S0.X, + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON CAST(_S1.Y AS CLOB) LIKE CONCAT(CAST(_S0.X AS CLOB), '%') + GROUP BY + _S0.X +), _S5 AS ( + SELECT + _S2.X, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + JOIN _S1 _S3 + ON CAST(_S3.Y AS CLOB) LIKE CONCAT('%', CAST(_S2.X AS CLOB)) + GROUP BY + _S2.X +) +SELECT + _S4.X AS x, + _S4.N_ROWS AS n_prefix, + _S5.N_ROWS AS n_suffix +FROM _S4 _S4 +JOIN _S5 _S5 + ON _S4.X = _S5.X +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_4_oracle.sql b/tests/test_sql_refsols/user_range_collection_4_oracle.sql new file mode 100644 index 000000000..917651b58 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_4_oracle.sql @@ -0,0 +1,32 @@ +WITH _T AS ( + SELECT + PART.p_name AS P_NAME, + PART.p_retailprice AS P_RETAILPRICE, + COLUMN1 AS PART_SIZE, + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY PART.p_retailprice) AS _W + FROM (VALUES + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9), + (10)) AS SIZES(PART_SIZE) + JOIN TPCH.PART PART + ON COLUMN1 = PART.p_size + AND PART.p_container LIKE '%SM DRUM%' + AND PART.p_name LIKE '%azure%' + AND PART.p_type LIKE '%PLATED%' +) +SELECT + PART_SIZE AS part_size, + P_NAME AS name, + P_RETAILPRICE AS retail_price +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_5_oracle.sql b/tests/test_sql_refsols/user_range_collection_5_oracle.sql new file mode 100644 index 000000000..c00aa9e8a --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -0,0 +1,36 @@ +WITH _S2 AS ( + SELECT + COLUMN1 AS PART_SIZE + FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56)) AS SIZES(PART_SIZE) +), _S3 AS ( + SELECT + _S0.PART_SIZE, + COUNT(*) AS N_ROWS + FROM _S2 _S0 + JOIN TPCH.PART PART + ON PART.p_name LIKE '%almond%' + AND PART.p_size <= ( + _S0.PART_SIZE + 4 + ) + AND PART.p_size >= _S0.PART_SIZE + GROUP BY + _S0.PART_SIZE +) +SELECT + _S2.PART_SIZE AS part_size, + NVL(_S3.N_ROWS, 0) AS n_parts +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.PART_SIZE = _S3.PART_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_6_oracle.sql b/tests/test_sql_refsols/user_range_collection_6_oracle.sql new file mode 100644 index 000000000..3970ed5f9 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_6_oracle.sql @@ -0,0 +1,33 @@ +WITH _S5 AS ( + SELECT + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + COUNT(DISTINCT ORDERS.o_custkey) AS NDISTINCT_O_CUSTKEY + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'AUTOMOBILE' + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'JAPAN' + WHERE + ORDERS.o_clerk = 'Clerk#000000925' + GROUP BY + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) +) +SELECT + COLUMN1 AS year, + NVL(_S5.NDISTINCT_O_CUSTKEY, 0) AS n_orders +FROM (VALUES + (1990), + (1991), + (1992), + (1993), + (1994), + (1995), + (1996), + (1997), + (1998), + (1999), + (2000)) AS YEARS(YEAR) +LEFT JOIN _S5 _S5 + ON COLUMN1 = _S5.YEAR_O_ORDERDATE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql b/tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql new file mode 100644 index 000000000..f7961c8cb --- /dev/null +++ b/tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql @@ -0,0 +1,7 @@ +SELECT + FOOTNOTES.description AS footnote_description +FROM MAIN.COUNTRY COUNTRY +JOIN MAIN.FOOTNOTES FOOTNOTES + ON COUNTRY.countrycode = FOOTNOTES.countrycode AND FOOTNOTES.year = 'YR2012' +WHERE + COUNTRY.shortname = 'Albania' diff --git a/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql new file mode 100644 index 000000000..b14a8b8b9 --- /dev/null +++ b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNTRY.countrycode AS country_code +FROM MAIN.COUNTRY COUNTRY +JOIN MAIN.COUNTRYNOTES COUNTRYNOTES + ON COUNTRY.countrycode = COUNTRYNOTES.countrycode + AND COUNTRYNOTES.seriescode = 'DT.DOD.DECT.CD' +WHERE + COUNTRY.incomegroup = 'Low income' diff --git a/tests/test_sql_refsols/wealthiest_supplier_oracle.sql b/tests/test_sql_refsols/wealthiest_supplier_oracle.sql new file mode 100644 index 000000000..90f4b244b --- /dev/null +++ b/tests/test_sql_refsols/wealthiest_supplier_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + s_acctbal AS S_ACCTBAL, + s_name AS S_NAME, + ROW_NUMBER() OVER (ORDER BY s_acctbal DESC, s_name) AS _W + FROM TPCH.SUPPLIER +) +SELECT + S_NAME AS name, + S_ACCTBAL AS account_balance +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/week_offset_oracle.sql b/tests/test_sql_refsols/week_offset_oracle.sql new file mode 100644 index 000000000..62d73f30b --- /dev/null +++ b/tests/test_sql_refsols/week_offset_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxdatetime AS date_time, + DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'WEEK') AS week_adj1, + DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, WEEK) AS week_adj2, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'HOUR'), 2, 'WEEK') AS week_adj3, + DATE_ADD(DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, SECOND), 2, 'WEEK') AS week_adj4, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'DAY'), 2, 'WEEK') AS week_adj5, + DATE_ADD(DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, MINUTE), 2, 'WEEK') AS week_adj6, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'MONTH'), 2, 'WEEK') AS week_adj7, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'YEAR'), 2, 'WEEK') AS week_adj8 +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/window_filter_order_10_oracle.sql b/tests/test_sql_refsols/window_filter_order_10_oracle.sql new file mode 100644 index 000000000..8396bf098 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_10_oracle.sql @@ -0,0 +1,17 @@ +WITH _T AS ( + SELECT + ORDERS.o_totalprice AS O_TOTALPRICE, + AVG(CAST(NULL AS INT)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' + WHERE + ORDERS.o_clerk = 'Clerk#000000001' +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + O_TOTALPRICE < ( + 0.05 * _W + ) diff --git a/tests/test_sql_refsols/window_filter_order_1_oracle.sql b/tests/test_sql_refsols/window_filter_order_1_oracle.sql new file mode 100644 index 000000000..ea21ffd40 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_1_oracle.sql @@ -0,0 +1,27 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +), _T2 AS ( + SELECT + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + COUNT_O_CUSTKEY, + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_2_oracle.sql b/tests/test_sql_refsols/window_filter_order_2_oracle.sql new file mode 100644 index 000000000..ea21ffd40 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_2_oracle.sql @@ -0,0 +1,27 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +), _T2 AS ( + SELECT + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + COUNT_O_CUSTKEY, + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_3_oracle.sql b/tests/test_sql_refsols/window_filter_order_3_oracle.sql new file mode 100644 index 000000000..ea21ffd40 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_3_oracle.sql @@ -0,0 +1,27 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +), _T2 AS ( + SELECT + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + COUNT_O_CUSTKEY, + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_4_oracle.sql b/tests/test_sql_refsols/window_filter_order_4_oracle.sql new file mode 100644 index 000000000..ad1bb5f16 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_4_oracle.sql @@ -0,0 +1,22 @@ +WITH _T2 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + GROUP BY + ORDERS.o_custkey +), _T AS ( + SELECT + N_ROWS, + AVG(CAST(N_ROWS AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + N_ROWS < _W diff --git a/tests/test_sql_refsols/window_filter_order_5_oracle.sql b/tests/test_sql_refsols/window_filter_order_5_oracle.sql new file mode 100644 index 000000000..ce69c4193 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_5_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + 1 AS EXPR_0, + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY + FROM TPCH.CUSTOMER + WHERE + c_mktsegment = 'BUILDING' +), _T AS ( + SELECT + _S1.C_ACCTBAL, + _S1.EXPR_0, + AVG(CAST(NVL(_S1.C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S1 _S1 + ON ORDERS.o_custkey = _S1.C_CUSTKEY + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NOT EXPR_0 IS NULL AND C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_6_oracle.sql b/tests/test_sql_refsols/window_filter_order_6_oracle.sql new file mode 100644 index 000000000..ce69c4193 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_6_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + 1 AS EXPR_0, + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY + FROM TPCH.CUSTOMER + WHERE + c_mktsegment = 'BUILDING' +), _T AS ( + SELECT + _S1.C_ACCTBAL, + _S1.EXPR_0, + AVG(CAST(NVL(_S1.C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S1 _S1 + ON ORDERS.o_custkey = _S1.C_CUSTKEY + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NOT EXPR_0 IS NULL AND C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_7_oracle.sql b/tests/test_sql_refsols/window_filter_order_7_oracle.sql new file mode 100644 index 000000000..2029ce75a --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_7_oracle.sql @@ -0,0 +1,15 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_8_oracle.sql b/tests/test_sql_refsols/window_filter_order_8_oracle.sql new file mode 100644 index 000000000..ef696f888 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_8_oracle.sql @@ -0,0 +1,30 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 + AND EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 +), _T2 AS ( + SELECT + ANY_VALUE(CUSTOMER.c_acctbal) AS ANYTHING_C_ACCTBAL, + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'FRANCE' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + ANYTHING_C_ACCTBAL, + COUNT_O_CUSTKEY, + SUM(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) IS NULL AND ANYTHING_C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_9_oracle.sql b/tests/test_sql_refsols/window_filter_order_9_oracle.sql new file mode 100644 index 000000000..2113cdbbd --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_9_oracle.sql @@ -0,0 +1,30 @@ +WITH _S3 AS ( + SELECT + 1 AS EXPR_0, + NVL(SUM(ORDERS.o_totalprice), 0) AS TOTAL_SPENT, + CUSTOMER.c_custkey AS C_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + WHERE + CUSTOMER.c_mktsegment = 'BUILDING' + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + _S3.EXPR_0, + ORDERS.o_totalprice AS O_TOTALPRICE, + AVG(CAST(_S3.TOTAL_SPENT AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S3 _S3 + ON ORDERS.o_custkey = _S3.C_CUSTKEY + WHERE + ORDERS.o_clerk = 'Clerk#000000001' +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + EXPR_0 IS NULL AND O_TOTALPRICE < ( + 0.05 * _W + ) diff --git a/tests/test_sql_refsols/window_functions_oracle.sql b/tests/test_sql_refsols/window_functions_oracle.sql new file mode 100644 index 000000000..d38b2e6e1 --- /dev/null +++ b/tests/test_sql_refsols/window_functions_oracle.sql @@ -0,0 +1,13 @@ +SELECT + DENSE_RANK() OVER (ORDER BY CUSTOMER.c_acctbal DESC) AS rank_value, + NTILE(10) OVER (ORDER BY CUSTOMER.c_acctbal) AS precentile_value, + LAG(CUSTOMER.c_acctbal, 2, 0.0) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal) AS two_prev_value, + LEAD(CUSTOMER.c_acctbal, 2) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal) AS two_next_value, + SUM(CUSTOMER.c_acctbal) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS relsum_value, + SUM(CUSTOMER.c_acctbal) OVER (ORDER BY CUSTOMER.c_acctbal ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS relsum_value2, + CUSTOMER.c_acctbal / AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER (ORDER BY CUSTOMER.c_acctbal ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS relavg_value, + CUSTOMER.c_acctbal / COUNT(CASE WHEN CUSTOMER.c_acctbal > 0.0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER () AS relcount_value, + CUSTOMER.c_acctbal / COUNT(*) OVER () AS relsize_value +FROM TPCH.NATION NATION +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey diff --git a/tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql b/tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql new file mode 100644 index 000000000..9498ddfa2 --- /dev/null +++ b/tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxid AS transaction_id, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS w1, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS w2, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w3, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w4, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS w5, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS w6, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 3 PRECEDING AND 5 FOLLOWING) AS w7, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 3 PRECEDING AND 5 FOLLOWING) AS w8 +FROM MAIN.SBTRANSACTION +ORDER BY + sbtxdatetime NULLS FIRST +FETCH FIRST 8 ROWS ONLY diff --git a/tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql b/tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql new file mode 100644 index 000000000..5b76a6850 --- /dev/null +++ b/tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxid AS transaction_id, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND 4 FOLLOWING) AS w1, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND 4 FOLLOWING) AS w2, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w3, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w4, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) AS w5, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) AS w6, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 5 PRECEDING AND 1 PRECEDING) AS w7, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 5 PRECEDING AND 1 PRECEDING) AS w8 +FROM MAIN.SBTRANSACTION +ORDER BY + sbtxdatetime NULLS FIRST +FETCH FIRST 8 ROWS ONLY diff --git a/tests/test_sql_refsols/year_month_nation_orders_oracle.sql b/tests/test_sql_refsols/year_month_nation_orders_oracle.sql new file mode 100644 index 000000000..da9a6a46a --- /dev/null +++ b/tests/test_sql_refsols/year_month_nation_orders_oracle.sql @@ -0,0 +1,21 @@ +SELECT + NATION.n_name AS nation_name, + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS order_year, + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS order_month, + COUNT(*) AS n_orders +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_orderpriority = '1-URGENT' +WHERE + REGION.r_name IN ('ASIA', 'AFRICA') +GROUP BY + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)), + NATION.n_name +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql new file mode 100644 index 000000000..4e0924cbc --- /dev/null +++ b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql @@ -0,0 +1,17 @@ +WITH _T0 AS ( + SELECT + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) +) +SELECT + YEAR_O_ORDERDATE AS year, + N_ROWS AS current_year_orders, + ( + 100.0 * CAST(N_ROWS - LAG(N_ROWS, 1) OVER (ORDER BY YEAR_O_ORDERDATE) AS DOUBLE PRECISION) + ) / LAG(N_ROWS, 1) OVER (ORDER BY YEAR_O_ORDERDATE) AS pct_change +FROM _T0 +ORDER BY + 1 NULLS FIRST From 69478a6a30da643893c5e0df056e503415efad92 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Feb 2026 09:35:47 -0600 Subject: [PATCH 08/48] WIP: slice and get_part --- .../oracle_transform_bindings.py | 261 +++++++++++++++++- .../get_part_multiple_oracle.sql | 212 ++++++++++++++ 2 files changed, 471 insertions(+), 2 deletions(-) create mode 100644 tests/test_sql_refsols/get_part_multiple_oracle.sql diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index 159b7caf3..95174cc8c 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -26,7 +26,6 @@ class OracleTransformBindings(BaseTransformBindings): pydop.SMALLEST: "LEAST", pydop.STRIP: "TRIM", pydop.FIND: "INSTR", - pydop.SLICE: "SUBSTR", pydop.JOIN_STRINGS: "LISTAGG", pydop.PERCENTILE: "PERCENTILE_CONT", } @@ -46,5 +45,263 @@ def convert_call_to_sqlglot( return sqlglot_expressions.Anonymous( this=self.PYDOP_TO_ORACLE_FUNC[operator], expressions=args ) - return super().convert_call_to_sqlglot(operator, args, types) + + def convert_slice( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + """ + Convert a PyDough slice operation to a SQLGlot expression. + MySQL uses the SUBSTRING function for slicing. + + Outline of the logic: + - If the start index is None, it defaults to 1 (1-based indexing). + - If the stop index is None, it defaults to the length of the string. + - a = start index + - b = stop index + match (a, b): + case (None, None): + return SUBSTRING(x, 1) + case (+a, None): + return SUBSTRING(x, a + 1) + case (-a, None): + return SUBSTRING(x, a) + case (None, +b): + return SUBSTRING(x, 1, b) + case (None, -b): + return SUBSTRING(x, 1, LENGTH(x) + b) + case (+a, +b): + return SUBSTRING(x, a + 1, GREATEST(b - a, 0)) + case (-a, -b): + return SUBSTRING(x, a, GREATEST(b - a, 0)) + case (+a, -b): + return SUBSTRING(x, a + 1, GREATEST(LENGTH(x) + b - a, 0)) + case (-a, +b): + return SUBSTRING(x, a, b - GREATEST(LENGTH(x) + a, 0)) + """ + + assert len(args) == 4 + string_expr, start, stop, step = args + + start_idx: int | None = None + if not isinstance(start, sqlglot_expressions.Null): + if isinstance(start, sqlglot_expressions.Literal): + try: + start_idx = int(start.this) + except ValueError: + raise ValueError( + "SLICE function currently only supports the start index being integer literal or absent." + ) + else: + raise ValueError( + "SLICE function currently only supports the start index being integer literal or absent." + ) + + stop_idx: int | None = None + if not isinstance(stop, sqlglot_expressions.Null): + if isinstance(stop, sqlglot_expressions.Literal): + try: + stop_idx = int(stop.this) + except ValueError: + raise ValueError( + "SLICE function currently only supports the stop index being integer literal or absent." + ) + else: + raise ValueError( + "SLICE function currently only supports the stop index being integer literal or absent." + ) + + step_idx: int | None = None + if not isinstance(step, sqlglot_expressions.Null): + if isinstance(step, sqlglot_expressions.Literal): + try: + step_idx = int(step.this) + if step_idx != 1: + raise ValueError( + "SLICE function currently only supports the step being integer literal 1 or absent." + ) + except ValueError: + raise ValueError( + "SLICE function currently only supports the step being integer literal 1 or absent." + ) + else: + raise ValueError( + "SLICE function currently only supports the step being integer literal 1 or absent." + ) + + # SQLGlot expressions for 0 and 1 and empty string + sql_one: SQLGlotExpression = sqlglot_expressions.Literal.number(1) + sql_zero: SQLGlotExpression = sqlglot_expressions.Literal.number(0) + expr_length: SQLGlotExpression = sqlglot_expressions.Length(this=string_expr) + one_index_start: SQLGlotExpression = sqlglot_expressions.Add( + this=start, expression=sql_one + ) + # length adjustment + length: SQLGlotExpression = None + + match (start_idx, stop_idx): + case (None, end_idx) if end_idx is not None and end_idx >= 0: + length = stop + + case (None, end_idx) if end_idx is not None and end_idx < 0: + length = sqlglot_expressions.Add(this=expr_length, expression=stop) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx >= 0 + and end_idx >= 0 + ): + length = sqlglot_expressions.Greatest( + this=sqlglot_expressions.Sub(this=stop, expression=start), + expressions=[sql_zero], + ) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx < 0 + and end_idx < 0 + ): + length = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.LT( + this=expr_length, + expression=sqlglot_expressions.Abs(this=start), + ), + true=sqlglot_expressions.Add( + this=expr_length, expression=stop + ), + ) + ], + default=sqlglot_expressions.Greatest( + this=sqlglot_expressions.Sub(this=stop, expression=start), + expressions=[sql_zero], + ), + ) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx >= 0 + and end_idx < 0 + ): + length = sqlglot_expressions.Greatest( + this=sqlglot_expressions.Sub( + this=sqlglot_expressions.Add(this=expr_length, expression=stop), + expression=start, + ), + expressions=[sql_zero], + ) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx < 0 + and end_idx >= 0 + ): + length = sqlglot_expressions.Sub( + this=stop, + expression=sqlglot_expressions.Greatest( + this=sqlglot_expressions.Add( + this=expr_length, expression=start + ), + expressions=[sql_zero], + ), + ) + + # start adjustment + if start_idx is not None and start_idx >= 0: + start = one_index_start + elif start_idx is not None and start_idx < 0: + start = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.GT( + this=expr_length, + expression=sqlglot_expressions.Abs(this=start), + ), + true=start, + ) + ], + default=sql_one, + ) + + elif start_idx is None: + start = sql_one + + result: SQLGlotExpression = sqlglot_expressions.Substring( + this=string_expr, start=start, length=length + ) + return result + + def convert_get_part( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + """ + GETPART(str, delim, idx) -> + REGEXP_SUBSTR( + str, + '[^' || delim || ']+', + 1, + CASE + WHEN idx = 0 THEN 1 + WHEN idx > 0 THEN idx + ELSE (REGEXP_COUNT(str, delim) + 1) + idx + 1 + END + ) + """ + + assert len(args) == 3 + + string_expr, delimiter_expr, index_expr = args + literal_0: SQLGlotExpression = sqlglot_expressions.Literal.number(0) + literal_1: SQLGlotExpression = sqlglot_expressions.Literal.number(1) + regex_1: SQLGlotExpression = sqlglot_expressions.Literal.string("[^") + regex_2: SQLGlotExpression = sqlglot_expressions.Literal.string("]+") + + case_expr: SQLGlotExpression = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.EQ(this=index_expr, expression=literal_0), + true=literal_1, + ), + sqlglot_expressions.If( + this=sqlglot_expressions.GT(this=index_expr, expression=literal_0), + true=index_expr, + ), + ], + default=sqlglot_expressions.Add( + this=sqlglot_expressions.Add( + this=sqlglot_expressions.Paren( + this=sqlglot_expressions.Add( + this=sqlglot_expressions.Anonymous( + this="REGEXP_COUNT", + expressions=[string_expr, delimiter_expr], + ), + expression=literal_1, + ) + ), + expression=index_expr, + ), + expression=literal_1, + ), + ) + + result: SQLGlotExpression = sqlglot_expressions.Anonymous( + this="REGEXP_SUBSTR", + expressions=[ + string_expr, + sqlglot_expressions.DPipe( + this=sqlglot_expressions.DPipe( + this=regex_1, expression=delimiter_expr, safe=True + ), + expression=regex_2, + safe=True, + ), + literal_1, + case_expr, + ], + ) + return result diff --git a/tests/test_sql_refsols/get_part_multiple_oracle.sql b/tests/test_sql_refsols/get_part_multiple_oracle.sql new file mode 100644 index 000000000..67d366df4 --- /dev/null +++ b/tests/test_sql_refsols/get_part_multiple_oracle.sql @@ -0,0 +1,212 @@ +SELECT + CAST(SUBSTR(sbcustid, 2) AS INT) AS _expr0, + REGEXP_SUBSTR( + sbcustname, + '[^ ]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, ' ') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p1, + REGEXP_SUBSTR( + sbcustname, + '[^ ]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, ' ') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p2, + REGEXP_SUBSTR( + sbcustemail, + '[^.]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustemail, '.') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p3, + REGEXP_SUBSTR( + sbcustemail, + '[^.]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustemail, '.') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p4, + REGEXP_SUBSTR( + sbcustphone, + '[^-]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustphone, '-') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p5, + REGEXP_SUBSTR( + sbcustphone, + '[^-]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustphone, '-') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p6, + REGEXP_SUBSTR( + sbcustpostalcode, + '[^00]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustpostalcode, '00') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p7, + REGEXP_SUBSTR( + sbcustpostalcode, + '[^00]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustpostalcode, '00') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p8, + REGEXP_SUBSTR( + sbcustname, + '[^!]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '!') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p9, + REGEXP_SUBSTR( + sbcustname, + '[^@]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '@') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p10, + REGEXP_SUBSTR( + sbcustname, + '[^aa]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, 'aa') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p11, + REGEXP_SUBSTR( + sbcustname, + '[^#$*]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '#$*') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p12, + REGEXP_SUBSTR( + sbcustname, + '[^]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p13, + REGEXP_SUBSTR( + '', + '[^ ]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT('', ' ') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p14, + REGEXP_SUBSTR(sbcustname, '[^ ]+', 1, 1) AS p15, + REGEXP_SUBSTR( + sbcuststate, + '[^' || sbcuststate || ']+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcuststate, sbcuststate) + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p16, + REGEXP_SUBSTR( + REGEXP_SUBSTR(sbcustphone, '[^-]+', 1, 1), + '[^5]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(REGEXP_SUBSTR(sbcustphone, '[^-]+', 1, 1), '5') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p17, + REGEXP_SUBSTR( + sbcustpostalcode, + '[^0]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustpostalcode, '0') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p18 +FROM MAIN.SBCUSTOMER +WHERE + CAST(SUBSTR(sbcustid, 2) AS INT) <= 4 +ORDER BY + 1 NULLS FIRST From 17d4a9533dc6f065538724b5e616592c9073410f Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 11 Feb 2026 11:47:18 -0600 Subject: [PATCH 09/48] adding oracle refsol files --- .../extract_colors_oracle.sql | 283 +----------------- .../function_sampler_oracle.sql | 21 ++ .../get_part_single_oracle.sql | 46 +-- .../has_cross_correlated_oracle.sql | 5 + .../has_cross_correlated_singular_oracle.sql | 5 + tests/test_sql_refsols/menu_5556_oracle.sql | 28 ++ .../nation_window_aggs_oracle.sql | 12 + .../redundant_has_nested_oracle.sql | 7 + .../redundant_has_not_on_singular_oracle.sql | 7 + ...dundant_has_on_plural_lineitems_oracle.sql | 5 + .../redundant_has_on_plural_oracle.sql | 5 + .../test_sql_refsols/redundant_has_oracle.sql | 7 + .../redundant_has_singular_chain_oracle.sql | 7 + .../region_nation_window_aggs_oracle.sql | 12 + .../simple_cross_10_oracle.sql | 26 ++ .../simple_cross_14_oracle.sql | 19 ++ .../simple_cross_4_oracle.sql | 24 ++ .../simplification_4_oracle.sql | 4 +- tests/test_sql_refsols/smoke_a_oracle.sql | 45 +++ tests/test_sql_refsols/smoke_c_oracle.sql | 45 +++ tests/test_sql_refsols/tpch_q22_oracle.sql | 22 ++ .../unary_and_slicing_operators_oracle.sql | 13 + 22 files changed, 324 insertions(+), 324 deletions(-) create mode 100644 tests/test_sql_refsols/function_sampler_oracle.sql create mode 100644 tests/test_sql_refsols/has_cross_correlated_oracle.sql create mode 100644 tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql create mode 100644 tests/test_sql_refsols/menu_5556_oracle.sql create mode 100644 tests/test_sql_refsols/nation_window_aggs_oracle.sql create mode 100644 tests/test_sql_refsols/redundant_has_nested_oracle.sql create mode 100644 tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql create mode 100644 tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql create mode 100644 tests/test_sql_refsols/redundant_has_on_plural_oracle.sql create mode 100644 tests/test_sql_refsols/redundant_has_oracle.sql create mode 100644 tests/test_sql_refsols/redundant_has_singular_chain_oracle.sql create mode 100644 tests/test_sql_refsols/region_nation_window_aggs_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_10_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_14_oracle.sql create mode 100644 tests/test_sql_refsols/simple_cross_4_oracle.sql create mode 100644 tests/test_sql_refsols/smoke_a_oracle.sql create mode 100644 tests/test_sql_refsols/smoke_c_oracle.sql create mode 100644 tests/test_sql_refsols/tpch_q22_oracle.sql create mode 100644 tests/test_sql_refsols/unary_and_slicing_operators_oracle.sql diff --git a/tests/test_sql_refsols/extract_colors_oracle.sql b/tests/test_sql_refsols/extract_colors_oracle.sql index 89b70ac66..e5e2ab57e 100644 --- a/tests/test_sql_refsols/extract_colors_oracle.sql +++ b/tests/test_sql_refsols/extract_colors_oracle.sql @@ -1,282 +1,11 @@ -WITH _S0 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - P_NAME AS REST, - ' ' AS DELIM, - 1 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S0 - WHERE - rest <> '' -), _S1 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S0 -), _S2 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - P_NAME AS REST, - ' ' AS DELIM, - 2 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S2 - WHERE - rest <> '' -), _S3 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S2 -), _S4 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - P_NAME AS REST, - ' ' AS DELIM, - 3 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S4 - WHERE - rest <> '' -), _S5 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S4 -), _S6 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - P_NAME AS REST, - ' ' AS DELIM, - 4 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S6 - WHERE - rest <> '' -), _S7 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S6 -), _S8 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - P_NAME AS REST, - ' ' AS DELIM, - 5 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S8 - WHERE - rest <> '' -), _S9 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S8 -), _S10 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - P_NAME AS REST, - ' ' AS DELIM, - 6 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S10 - WHERE - rest <> '' -), _S11 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S10 -) SELECT p_partkey AS key, - UPPER( - ( - SELECT - _S0.PART - FROM _S0 _S0 - CROSS JOIN _S1 _S1 - WHERE - _S0.PART_INDEX <> 0 - AND _S0.PART_INDEX = CASE - WHEN _S0.IDX > 0 - THEN _S0.IDX - WHEN _S0.IDX < 0 - THEN _S1.TOTAL_PARTS + _S0.IDX + 1 - ELSE 1 - END - ) - ) AS c1, - UPPER( - ( - SELECT - _S2.PART - FROM _S2 _S2 - CROSS JOIN _S3 _S3 - WHERE - _S2.PART_INDEX <> 0 - AND _S2.PART_INDEX = CASE - WHEN _S2.IDX > 0 - THEN _S2.IDX - WHEN _S2.IDX < 0 - THEN _S3.TOTAL_PARTS + _S2.IDX + 1 - ELSE 1 - END - ) - ) AS c2, - UPPER( - ( - SELECT - _S4.PART - FROM _S4 _S4 - CROSS JOIN _S5 _S5 - WHERE - _S4.PART_INDEX <> 0 - AND _S4.PART_INDEX = CASE - WHEN _S4.IDX > 0 - THEN _S4.IDX - WHEN _S4.IDX < 0 - THEN _S5.TOTAL_PARTS + _S4.IDX + 1 - ELSE 1 - END - ) - ) AS c3, - UPPER( - ( - SELECT - _S6.PART - FROM _S6 _S6 - CROSS JOIN _S7 _S7 - WHERE - _S6.PART_INDEX <> 0 - AND _S6.PART_INDEX = CASE - WHEN _S6.IDX > 0 - THEN _S6.IDX - WHEN _S6.IDX < 0 - THEN _S7.TOTAL_PARTS + _S6.IDX + 1 - ELSE 1 - END - ) - ) AS c4, - UPPER( - ( - SELECT - _S8.PART - FROM _S8 _S8 - CROSS JOIN _S9 _S9 - WHERE - _S8.PART_INDEX <> 0 - AND _S8.PART_INDEX = CASE - WHEN _S8.IDX > 0 - THEN _S8.IDX - WHEN _S8.IDX < 0 - THEN _S9.TOTAL_PARTS + _S8.IDX + 1 - ELSE 1 - END - ) - ) AS c5, - UPPER( - ( - SELECT - _S10.PART - FROM _S10 _S10 - CROSS JOIN _S11 _S11 - WHERE - _S10.PART_INDEX <> 0 - AND _S10.PART_INDEX = CASE - WHEN _S10.IDX > 0 - THEN _S10.IDX - WHEN _S10.IDX < 0 - THEN _S11.TOTAL_PARTS + _S10.IDX + 1 - ELSE 1 - END - ) - ) AS c6 + UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 1)) AS c1, + UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 2)) AS c2, + UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 3)) AS c3, + UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 4)) AS c4, + UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 5)) AS c5, + UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 6)) AS c6 FROM TPCH.PART ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/function_sampler_oracle.sql b/tests/test_sql_refsols/function_sampler_oracle.sql new file mode 100644 index 000000000..81a99a23d --- /dev/null +++ b/tests/test_sql_refsols/function_sampler_oracle.sql @@ -0,0 +1,21 @@ +SELECT + LISTAGG('-', REGION.r_name, NATION.n_name, SUBSTR(CUSTOMER.c_name, 17)) AS a, + ROUND(CUSTOMER.c_acctbal, 1) AS b, + CASE WHEN SUBSTR(CUSTOMER.c_phone, 1, 1) = '3' THEN CUSTOMER.c_name ELSE NULL END AS c, + NOT CASE + WHEN SUBSTR(CUSTOMER.c_phone, 2, GREATEST(1, 0)) = '1' + THEN CUSTOMER.c_name + ELSE NULL + END IS NULL AS d, + CASE WHEN SUBSTR(CUSTOMER.c_phone, 15) = '7' THEN CUSTOMER.c_name ELSE NULL END IS NULL AS e, + ROUND(CUSTOMER.c_acctbal, 0) AS f +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_acctbal <= 100.0 + AND CUSTOMER.c_acctbal >= 0.0 + AND CUSTOMER.c_nationkey = NATION.n_nationkey +ORDER BY + CUSTOMER.c_address NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/get_part_single_oracle.sql b/tests/test_sql_refsols/get_part_single_oracle.sql index 5b24c77cb..79ed97cbd 100644 --- a/tests/test_sql_refsols/get_part_single_oracle.sql +++ b/tests/test_sql_refsols/get_part_single_oracle.sql @@ -1,49 +1,5 @@ -WITH _S0 AS ( - SELECT - 0 AS PART_INDEX, - '' AS PART, - SBCUSTNAME AS REST, - ' ' AS DELIM, - -1 AS IDX - UNION ALL - SELECT - part_index + 1 AS PART_INDEX, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN rest - ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) - END AS PART, - CASE - WHEN INSTR(rest, delim) = 0 OR delim = '' - THEN '' - ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) - END AS REST, - delim AS DELIM, - idx AS IDX - FROM _S0 - WHERE - rest <> '' -), _S1 AS ( - SELECT - COUNT(*) - 1 AS TOTAL_PARTS - FROM _S0 -) SELECT - ( - SELECT - _S0.PART - FROM _S0 _S0 - CROSS JOIN _S1 _S1 - WHERE - _S0.PART_INDEX <> 0 - AND _S0.PART_INDEX = CASE - WHEN _S0.IDX > 0 - THEN _S0.IDX - WHEN _S0.IDX < 0 - THEN _S1.TOTAL_PARTS + _S0.IDX + 1 - ELSE 1 - END - ) AS last_name + REGEXP_SUBSTR(sbcustname, '[^ ]+', 1, REGEXP_COUNT(sbcustname, ' ') + 1) AS last_name FROM MAIN.SBCUSTOMER WHERE sbcustname = 'Alex Rodriguez' diff --git a/tests/test_sql_refsols/has_cross_correlated_oracle.sql b/tests/test_sql_refsols/has_cross_correlated_oracle.sql new file mode 100644 index 000000000..09fe1f50d --- /dev/null +++ b/tests/test_sql_refsols/has_cross_correlated_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(DISTINCT CUSTOMER.c_custkey) AS n +FROM TPCH.CUSTOMER CUSTOMER +JOIN TPCH.SUPPLIER SUPPLIER + ON CUSTOMER.c_nationkey = SUPPLIER.s_nationkey diff --git a/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql b/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql new file mode 100644 index 000000000..14638501b --- /dev/null +++ b/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS n +FROM TPCH.CUSTOMER CUSTOMER +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey diff --git a/tests/test_sql_refsols/menu_5556_oracle.sql b/tests/test_sql_refsols/menu_5556_oracle.sql new file mode 100644 index 000000000..52047c5f0 --- /dev/null +++ b/tests/test_sql_refsols/menu_5556_oracle.sql @@ -0,0 +1,28 @@ +WITH _S3 AS ( + SELECT + 1 AS N_ROWS, + id AS ID + FROM MAIN.DISH + WHERE + LOWER(name) = 'baked apples with cream' +), _T1 AS ( + SELECT + MENUPAGE.menu_id AS MENU_ID, + MAX(MENUITEM.price) AS MAX_PRICE, + SUM(_S3.N_ROWS) AS SUM_N_ROWS + FROM MAIN.MENUPAGE MENUPAGE + JOIN MAIN.MENUITEM MENUITEM + ON MENUITEM.menu_page_id = MENUPAGE.id + LEFT JOIN _S3 _S3 + ON MENUITEM.dish_id = _S3.ID + GROUP BY + MENUPAGE.menu_id +) +SELECT + MENU.sponsor +FROM MAIN.MENU MENU +JOIN _T1 _T1 + ON MENU.id = _T1.MENU_ID AND _T1.SUM_N_ROWS <> 0 +ORDER BY + _T1.MAX_PRICE DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/nation_window_aggs_oracle.sql b/tests/test_sql_refsols/nation_window_aggs_oracle.sql new file mode 100644 index 000000000..c86716948 --- /dev/null +++ b/tests/test_sql_refsols/nation_window_aggs_oracle.sql @@ -0,0 +1,12 @@ +SELECT + n_name AS nation_name, + SUM(n_nationkey) OVER () AS key_sum, + AVG(CAST(n_nationkey AS DOUBLE PRECISION)) OVER () AS key_avg, + COUNT(CASE WHEN LENGTH(n_comment) < 75 THEN n_comment ELSE NULL END) OVER () AS n_short_comment, + COUNT(*) OVER () AS n_nations +FROM TPCH.NATION +WHERE + NOT SUBSTR(n_name, 1, 1) IN ('A', 'E', 'I', 'O', 'U') +ORDER BY + n_regionkey NULLS FIRST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/redundant_has_nested_oracle.sql b/tests/test_sql_refsols/redundant_has_nested_oracle.sql new file mode 100644 index 000000000..528d1a050 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_nested_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' diff --git a/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql b/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql new file mode 100644 index 000000000..528d1a050 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' diff --git a/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql new file mode 100644 index 000000000..316b95c4d --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS n +FROM TPCH.ORDERS ORDERS +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_quantity > 49 diff --git a/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql b/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql new file mode 100644 index 000000000..73e454239 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS n +FROM TPCH.CUSTOMER CUSTOMER +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_totalprice > 400000 diff --git a/tests/test_sql_refsols/redundant_has_oracle.sql b/tests/test_sql_refsols/redundant_has_oracle.sql new file mode 100644 index 000000000..63a5b0ab9 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS n +FROM TPCH.CUSTOMER CUSTOMER +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' diff --git a/tests/test_sql_refsols/redundant_has_singular_chain_oracle.sql b/tests/test_sql_refsols/redundant_has_singular_chain_oracle.sql new file mode 100644 index 000000000..fab919a50 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_singular_chain_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'EUROPE' diff --git a/tests/test_sql_refsols/region_nation_window_aggs_oracle.sql b/tests/test_sql_refsols/region_nation_window_aggs_oracle.sql new file mode 100644 index 000000000..72ef1540d --- /dev/null +++ b/tests/test_sql_refsols/region_nation_window_aggs_oracle.sql @@ -0,0 +1,12 @@ +SELECT + n_name AS nation_name, + SUM(n_nationkey) OVER (PARTITION BY n_regionkey) AS key_sum, + AVG(CAST(n_nationkey AS DOUBLE PRECISION)) OVER (PARTITION BY n_regionkey) AS key_avg, + COUNT(CASE WHEN LENGTH(n_comment) < 75 THEN n_comment ELSE NULL END) OVER (PARTITION BY n_regionkey) AS n_short_comment, + COUNT(*) OVER (PARTITION BY n_regionkey) AS n_nations +FROM TPCH.NATION +WHERE + NOT SUBSTR(n_name, 1, 1) IN ('A', 'E', 'I', 'O', 'U') +ORDER BY + n_regionkey NULLS FIRST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_10_oracle.sql b/tests/test_sql_refsols/simple_cross_10_oracle.sql new file mode 100644 index 000000000..5f99c59f3 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_10_oracle.sql @@ -0,0 +1,26 @@ +WITH _S4 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S5 AS ( + SELECT + _S0.R_REGIONKEY, + COUNT(*) AS N_ROWS + FROM _S4 _S0 + JOIN _S4 _S1 + ON _S0.R_NAME <> _S1.R_NAME + JOIN TPCH.NATION NATION + ON NATION.n_regionkey = _S1.R_REGIONKEY + AND SUBSTR(NATION.n_name, 1, 1) = SUBSTR(_S0.R_NAME, 1, 1) + GROUP BY + _S0.R_REGIONKEY +) +SELECT + _S4.R_NAME AS region_name, + NVL(_S5.N_ROWS, 0) AS n_other_nations +FROM _S4 _S4 +LEFT JOIN _S5 _S5 + ON _S4.R_REGIONKEY = _S5.R_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_14_oracle.sql b/tests/test_sql_refsols/simple_cross_14_oracle.sql new file mode 100644 index 000000000..6f424b217 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_14_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + n_regionkey AS N_REGIONKEY, + COUNT(*) AS N_ROWS + FROM TPCH.NATION + WHERE + SUBSTR(n_name, 1, 1) IN ('A', 'B', 'C') + GROUP BY + n_regionkey +) +SELECT + REGION.r_name AS region_name, + 'foo' AS x, + NVL(_S1.N_ROWS, 0) AS n +FROM TPCH.REGION REGION +LEFT JOIN _S1 _S1 + ON REGION.r_regionkey = _S1.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_4_oracle.sql b/tests/test_sql_refsols/simple_cross_4_oracle.sql new file mode 100644 index 000000000..57a293c02 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_4_oracle.sql @@ -0,0 +1,24 @@ +WITH _S2 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S3 AS ( + SELECT + _S0.R_REGIONKEY, + COUNT(*) AS N_ROWS + FROM _S2 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_name <> _S0.R_NAME + AND SUBSTR(REGION.r_name, 1, 1) = SUBSTR(_S0.R_NAME, 1, 1) + GROUP BY + _S0.R_REGIONKEY +) +SELECT + _S2.R_NAME AS region_name, + NVL(_S3.N_ROWS, 0) AS n_other_regions +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.R_REGIONKEY = _S3.R_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql index c455e3934..3f14753b2 100644 --- a/tests/test_sql_refsols/simplification_4_oracle.sql +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -1,8 +1,8 @@ WITH _T AS ( SELECT sbtxdatetime AS SBTXDATETIME, - ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS _W, - ROW_NUMBER() OVER (ORDER BY sbtxdatetime DESC) AS _W_2 + ROW_NUMBER() OVER (ORDER BY sbtxdatetime DESC) AS _W, + ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS _W_2 FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 diff --git a/tests/test_sql_refsols/smoke_a_oracle.sql b/tests/test_sql_refsols/smoke_a_oracle.sql new file mode 100644 index 000000000..c16c6f71e --- /dev/null +++ b/tests/test_sql_refsols/smoke_a_oracle.sql @@ -0,0 +1,45 @@ +SELECT + p_partkey AS key, + CAST(LISTAGG( + '', + SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), + SUBSTR(p_brand, 8), + SUBSTR( + p_brand, + CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END, + CASE + WHEN ABS(-2) > LENGTH(p_brand) + THEN LENGTH(p_brand) + -1 + ELSE GREATEST(1, 0) + END + ) + ) AS INT) AS a, + UPPER( + LEAST( + REGEXP_SUBSTR(p_name, '[^ ]+', 1, 2), + REGEXP_SUBSTR(p_name, '[^ ]+', 1, REGEXP_COUNT(p_name, ' ') + 1) + ) + ) AS b, + TRIM('o' FROM SUBSTR(p_name, 1, 2)) AS c, + CASE + WHEN LENGTH(CAST(p_size AS CLOB)) >= 3 + THEN SUBSTR(CAST(p_size AS CLOB), 1, 3) + ELSE SUBSTR(CONCAT('000', CAST(p_size AS CLOB)), -3) + END AS d, + SUBSTR(CONCAT(CAST(p_size AS CLOB), '000'), 1, 3) AS e, + REPLACE(p_mfgr, 'Manufacturer#', 'm') AS f, + REPLACE(LOWER(p_container), ' ', '') AS g, + CASE + WHEN LENGTH('o') = 0 + THEN 0 + ELSE CAST(( + LENGTH(p_name) - LENGTH(REPLACE(p_name, 'o', '')) + ) / LENGTH('o') AS INT) + END + ( + INSTR(p_name, 'o') / 100.0 + ) AS h, + ROUND(POWER(GREATEST(p_size, 10), 0.5), 3) AS i +FROM TPCH.PART +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/smoke_c_oracle.sql b/tests/test_sql_refsols/smoke_c_oracle.sql new file mode 100644 index 000000000..cbd04a49e --- /dev/null +++ b/tests/test_sql_refsols/smoke_c_oracle.sql @@ -0,0 +1,45 @@ +WITH _T1 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + c_mktsegment AS C_MKTSEGMENT, + c_name AS C_NAME, + CASE + WHEN FLOOR(0.8 * COUNT(c_acctbal) OVER ()) < ROW_NUMBER() OVER (ORDER BY c_acctbal DESC NULLS LAST) + THEN c_acctbal + ELSE NULL + END AS EXPR_30, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(c_acctbal) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN c_acctbal + ELSE NULL + END AS EXPR_31 + FROM TPCH.CUSTOMER +) +SELECT + COUNT(*) AS a, + NVL(SUM(FLOOR(C_ACCTBAL)), 0) AS b, + NVL(SUM(CEIL(C_ACCTBAL)), 0) AS c, + COUNT(DISTINCT C_MKTSEGMENT) AS d, + ROUND(AVG(ABS(C_ACCTBAL)), 4) AS e, + MIN(C_ACCTBAL) AS f, + MAX(C_ACCTBAL) AS g, + ANY_VALUE(SUBSTR(C_NAME, 1, 1)) AS h, + COUNT(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END) AS i, + CEIL(VARIANCE_POP(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END)) AS j, + ROUND(VARIANCE(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END), 4) AS k, + FLOOR(STDDEV_POP(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END)) AS l, + ROUND(STDDEV(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END), 4) AS m, + ROUND(AVG(NVL(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END, 0)), 2) AS n, + SUM(NOT CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS o, + SUM(CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS p, + MAX(EXPR_30) AS q, + AVG(EXPR_31) AS r +FROM _T1 diff --git a/tests/test_sql_refsols/tpch_q22_oracle.sql b/tests/test_sql_refsols/tpch_q22_oracle.sql new file mode 100644 index 000000000..46aabefd2 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q22_oracle.sql @@ -0,0 +1,22 @@ +WITH _S0 AS ( + SELECT + AVG(c_acctbal) AS AVG_C_ACCTBAL + FROM TPCH.CUSTOMER + WHERE + c_acctbal > 0.0 + AND SUBSTR(c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') +) +SELECT + SUBSTR(CUSTOMER.c_phone, 1, 2) AS CNTRY_CODE, + COUNT(*) AS NUM_CUSTS, + NVL(SUM(CUSTOMER.c_acctbal), 0) AS TOTACCTBAL +FROM _S0 _S0 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_acctbal > _S0.AVG_C_ACCTBAL + AND SUBSTR(CUSTOMER.c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey +GROUP BY + SUBSTR(CUSTOMER.c_phone, 1, 2) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/unary_and_slicing_operators_oracle.sql b/tests/test_sql_refsols/unary_and_slicing_operators_oracle.sql new file mode 100644 index 000000000..de0f7a40a --- /dev/null +++ b/tests/test_sql_refsols/unary_and_slicing_operators_oracle.sql @@ -0,0 +1,13 @@ +SELECT + SUBSTR(c_phone, 1, 3) AS country_code, + SUBSTR(c_name, 2) AS name_without_first_char, + SUBSTR(c_phone, CASE WHEN ABS(-1) < LENGTH(c_phone) THEN -1 ELSE 1 END) AS last_digit, + SUBSTR(c_name, 2, GREATEST(LENGTH(c_name) + -1 - 1, 0)) AS name_without_start_and_end_char, + SUBSTR(c_phone, 1, LENGTH(c_phone) + -5) AS phone_without_last_5_chars, + SUBSTR( + c_name, + CASE WHEN ABS(-2) < LENGTH(c_name) THEN -2 ELSE 1 END, + CASE WHEN ABS(-2) > LENGTH(c_name) THEN LENGTH(c_name) + -1 ELSE GREATEST(1, 0) END + ) AS name_second_to_last_char, + c_acctbal >= 0 AS is_not_in_debt +FROM TPCH.CUSTOMER From 17334ad88d072bb4af3d4d68768189b789898ac5 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 13 Feb 2026 11:16:48 -0600 Subject: [PATCH 10/48] quote identifiers starting with underscore, quote alias of quoted columns --- pydough/sqlglot/execute_relational.py | 32 + pydough/sqlglot/sqlglot_helpers.py | 12 + tests/conftest.py | 18 +- ...graph.json => custom_datasets_graphs.json} | 0 .../oracle_custom_datasets_graphs.json | 2213 +++++++++++++++++ tests/test_pipeline_oracle.py | 4 +- .../test_sql_refsols/agg_partition_oracle.sql | 4 +- .../agg_simplification_1_oracle.sql | 8 +- .../aggregation_analytics_1_oracle.sql | 19 +- .../aggregation_analytics_2_oracle.sql | 8 +- .../aggregation_analytics_3_oracle.sql | 8 +- .../aggregation_functions_oracle.sql | 16 +- ...rnative_quarter_cum_ir_analysis_oracle.sql | 84 +- .../avg_acctbal_wo_debt_oracle.sql | 18 +- .../avg_gap_prev_urgent_same_clerk_oracle.sql | 4 +- .../avg_order_diff_per_customer_oracle.sql | 4 +- .../bad_child_reuse_1_oracle.sql | 14 +- .../bad_child_reuse_2_oracle.sql | 12 +- .../bad_child_reuse_3_oracle.sql | 12 +- .../bad_child_reuse_4_oracle.sql | 16 +- .../bad_child_reuse_5_oracle.sql | 26 +- ...mparisons_and_logical_operators_oracle.sql | 10 +- .../country_x_year_analysis_oracle.sql | 68 +- .../country_x_year_combos_oracle.sql | 18 +- .../customer_largest_order_deltas_oracle.sql | 30 +- .../customer_most_recent_orders_oracle.sql | 16 +- .../datetime_current_oracle.sql | 2 +- .../datetime_relative_oracle.sql | 4 +- .../datetime_sampler_oracle.sql | 202 +- .../deep_best_analysis_oracle.sql | 101 +- .../defog_academic_gen11_oracle.sql | 10 +- .../defog_academic_gen13_oracle.sql | 14 +- .../defog_academic_gen15_oracle.sql | 4 +- .../defog_academic_gen16_oracle.sql | 8 +- .../defog_academic_gen18_oracle.sql | 8 +- .../defog_academic_gen1_oracle.sql | 6 +- .../defog_academic_gen22_oracle.sql | 12 +- .../defog_academic_gen24_oracle.sql | 6 +- .../defog_academic_gen2_oracle.sql | 8 +- .../defog_academic_gen3_oracle.sql | 2 +- .../defog_academic_gen4_oracle.sql | 8 +- .../defog_academic_gen7_oracle.sql | 8 +- .../defog_broker_adv10_oracle.sql | 14 +- .../defog_broker_adv14_oracle.sql | 8 +- .../defog_broker_adv16_oracle.sql | 10 +- .../defog_broker_adv1_oracle.sql | 8 +- .../defog_broker_adv2_oracle.sql | 8 +- .../defog_broker_adv3_oracle.sql | 10 +- .../defog_broker_adv4_oracle.sql | 8 +- .../defog_broker_adv5_oracle.sql | 22 +- .../defog_broker_adv6_oracle.sql | 12 +- .../defog_broker_adv7_oracle.sql | 16 +- .../defog_broker_basic10_oracle.sql | 2 +- .../defog_broker_basic1_oracle.sql | 10 +- .../defog_broker_basic3_oracle.sql | 10 +- .../defog_broker_basic4_oracle.sql | 24 +- .../defog_broker_basic5_oracle.sql | 2 +- .../defog_broker_basic6_oracle.sql | 2 +- .../defog_broker_basic9_oracle.sql | 2 +- .../defog_broker_gen3_oracle.sql | 8 +- .../defog_broker_gen4_oracle.sql | 10 +- .../defog_dealership_adv10_oracle.sql | 8 +- .../defog_dealership_adv11_oracle.sql | 8 +- .../defog_dealership_adv12_oracle.sql | 4 +- .../defog_dealership_adv15_oracle.sql | 8 +- .../defog_dealership_adv16_oracle.sql | 10 +- .../defog_dealership_adv1_oracle.sql | 2 +- .../defog_dealership_adv2_oracle.sql | 10 +- .../defog_dealership_adv3_oracle.sql | 8 +- .../defog_dealership_adv4_oracle.sql | 2 +- .../defog_dealership_adv5_oracle.sql | 12 +- .../defog_dealership_adv6_oracle.sql | 12 +- .../defog_dealership_adv7_oracle.sql | 8 +- .../defog_dealership_basic10_oracle.sql | 10 +- .../defog_dealership_basic1_oracle.sql | 4 +- .../defog_dealership_basic2_oracle.sql | 4 +- .../defog_dealership_basic3_oracle.sql | 6 +- .../defog_dealership_basic4_oracle.sql | 4 +- .../defog_dealership_basic5_oracle.sql | 10 +- .../defog_dealership_basic6_oracle.sql | 2 +- .../defog_dealership_basic8_oracle.sql | 10 +- .../defog_dealership_gen4_oracle.sql | 16 +- .../defog_dealership_gen5_oracle.sql | 12 +- .../defog_dermtreatment_adv10_oracle.sql | 8 +- .../defog_dermtreatment_adv15_oracle.sql | 8 +- .../defog_dermtreatment_adv5_oracle.sql | 8 +- .../defog_dermtreatment_adv6_oracle.sql | 10 +- .../defog_dermtreatment_adv8_oracle.sql | 4 +- .../defog_dermtreatment_adv9_oracle.sql | 16 +- .../defog_dermtreatment_basic1_oracle.sql | 14 +- .../defog_dermtreatment_basic2_oracle.sql | 60 +- .../defog_dermtreatment_basic3_oracle.sql | 10 +- .../defog_dermtreatment_basic4_oracle.sql | 14 +- .../defog_dermtreatment_gen2_oracle.sql | 18 +- .../defog_ewallet_adv14_oracle.sql | 2 +- .../defog_ewallet_adv15_oracle.sql | 8 +- .../defog_ewallet_adv6_oracle.sql | 8 +- .../defog_ewallet_adv7_oracle.sql | 10 +- .../defog_ewallet_basic10_oracle.sql | 10 +- .../defog_ewallet_gen1_oracle.sql | 6 +- .../defog_ewallet_gen2_oracle.sql | 14 +- .../defog_ewallet_gen4_oracle.sql | 34 +- .../defog_restaurants_gen11_oracle.sql | 10 +- .../defog_restaurants_gen16_oracle.sql | 4 +- .../defog_restaurants_gen18_oracle.sql | 44 +- .../defog_restaurants_gen19_oracle.sql | 8 +- .../defog_restaurants_gen20_oracle.sql | 8 +- .../defog_restaurants_gen8_oracle.sql | 30 +- .../test_sql_refsols/double_cross_oracle.sql | 44 +- .../double_partition_oracle.sql | 4 +- .../dumb_aggregation_oracle.sql | 26 +- .../epoch_culture_events_info_oracle.sql | 20 +- .../epoch_event_gap_per_era_oracle.sql | 4 +- .../epoch_first_event_per_era_oracle.sql | 8 +- .../epoch_intra_season_searches_oracle.sql | 98 +- ...t_popular_search_engine_per_tod_oracle.sql | 12 +- ...h_most_popular_topic_per_region_oracle.sql | 12 +- .../epoch_num_predawn_cold_war_oracle.sql | 18 +- ...ent_search_other_users_per_user_oracle.sql | 26 +- ...lapping_event_searches_per_user_oracle.sql | 20 +- .../epoch_pct_searches_per_tod_oracle.sql | 4 +- .../epoch_search_results_by_tod_oracle.sql | 4 +- .../epoch_unique_users_per_engine_oracle.sql | 14 +- ...ch_users_most_cold_war_searches_oracle.sql | 12 +- .../first_order_in_year_oracle.sql | 12 +- .../first_order_per_customer_oracle.sql | 12 +- .../floor_and_ceil_oracle.sql | 2 +- .../get_part_multiple_oracle.sql | 2 +- .../global_acctbal_breakdown_oracle.sql | 4 +- .../highest_priority_per_year_oracle.sql | 16 +- .../hour_minute_day_oracle.sql | 6 +- .../keywords_alias_reserved_word_ansi.sql | 4 +- .../keywords_alias_reserved_word_mysql.sql | 4 +- .../keywords_alias_reserved_word_oracle.sql | 4 +- .../keywords_alias_reserved_word_postgres.sql | 4 +- ...keywords_alias_reserved_word_snowflake.sql | 4 +- .../keywords_alias_reserved_word_sqlite.sql | 4 +- ...ords_cast_alias_and_missing_alias_ansi.sql | 6 +- ...rds_cast_alias_and_missing_alias_mysql.sql | 6 +- ...ds_cast_alias_and_missing_alias_oracle.sql | 6 +- ..._cast_alias_and_missing_alias_postgres.sql | 6 +- ...cast_alias_and_missing_alias_snowflake.sql | 6 +- ...ds_cast_alias_and_missing_alias_sqlite.sql | 6 +- .../keywords_column_alias_reserved_ansi.sql | 10 +- .../keywords_column_alias_reserved_mysql.sql | 8 +- .../keywords_column_alias_reserved_oracle.sql | 10 +- ...eywords_column_alias_reserved_postgres.sql | 10 +- ...ywords_column_alias_reserved_snowflake.sql | 10 +- .../keywords_column_alias_reserved_sqlite.sql | 8 +- ...keywords_expr_call_quoted_names_oracle.sql | 20 +- .../keywords_python_sql_reserved_ansi.sql | 8 +- .../keywords_python_sql_reserved_mysql.sql | 8 +- .../keywords_python_sql_reserved_oracle.sql | 10 +- .../keywords_python_sql_reserved_postgres.sql | 8 +- ...keywords_python_sql_reserved_snowflake.sql | 8 +- .../keywords_python_sql_reserved_sqlite.sql | 8 +- .../keywords_quoted_table_name_ansi.sql | 10 +- .../keywords_quoted_table_name_mysql.sql | 10 +- .../keywords_quoted_table_name_oracle.sql | 10 +- .../keywords_quoted_table_name_postgres.sql | 10 +- .../keywords_quoted_table_name_snowflake.sql | 10 +- .../keywords_quoted_table_name_sqlite.sql | 10 +- .../many_net_filter_4_oracle.sql | 12 +- .../many_net_filter_7_oracle.sql | 12 +- tests/test_sql_refsols/menu_5556_oracle.sql | 16 +- .../month_year_sliding_windows_oracle.sql | 42 +- .../n_orders_first_day_oracle.sql | 8 +- .../nation_acctbal_breakdown_oracle.sql | 4 +- .../nation_best_order_oracle.sql | 20 +- .../order_info_per_priority_oracle.sql | 8 +- .../orders_versus_first_orders_oracle.sql | 30 +- .../part_cross_part_a_oracle.sql | 26 +- .../part_cross_part_b_oracle.sql | 44 +- .../part_cross_part_c_oracle.sql | 44 +- .../part_reduced_size_oracle.sql | 12 +- .../parts_quantity_increase_95_96_oracle.sql | 34 +- ...percentile_customers_per_region_oracle.sql | 8 +- .../quantile_function_test_1_oracle.sql | 4 +- .../quantile_function_test_2_oracle.sql | 50 +- .../quantile_function_test_3_oracle.sql | 50 +- .../quantile_function_test_4_oracle.sql | 50 +- .../quantile_test_1_oracle.sql | 4 +- .../quantile_test_2_oracle.sql | 50 +- .../quarter_cum_ir_analysis_oracle.sql | 92 +- .../quarter_function_test_oracle.sql | 28 +- ...nations_per_region_by_customers_oracle.sql | 8 +- .../rank_with_filters_a_oracle.sql | 4 +- .../rank_with_filters_b_oracle.sql | 4 +- .../rank_with_filters_c_oracle.sql | 14 +- .../region_acctbal_breakdown_oracle.sql | 20 +- ...ion_orders_from_nations_richest_oracle.sql | 28 +- ...onal_first_order_best_line_part_oracle.sql | 32 +- .../regional_suppliers_percentile_oracle.sql | 14 +- ...richest_customer_key_per_region_oracle.sql | 8 +- .../richest_customer_per_region_oracle.sql | 8 +- .../simple_cross_10_oracle.sql | 28 +- .../simple_cross_11_oracle.sql | 12 +- .../simple_cross_12_oracle.sql | 12 +- .../simple_cross_13_oracle.sql | 2 +- .../simple_cross_14_oracle.sql | 8 +- .../simple_cross_15_oracle.sql | 34 +- .../simple_cross_16_oracle.sql | 40 +- .../simple_cross_1_oracle.sql | 10 +- .../simple_cross_2_oracle.sql | 12 +- .../simple_cross_3_oracle.sql | 22 +- .../simple_cross_4_oracle.sql | 24 +- .../simple_cross_5_oracle.sql | 44 +- .../simple_cross_6_oracle.sql | 12 +- .../simple_cross_7_oracle.sql | 8 +- .../simple_cross_8_oracle.sql | 38 +- .../simple_cross_9_oracle.sql | 22 +- .../simple_int_float_string_cast_oracle.sql | 2 +- .../simple_smallest_or_largest_oracle.sql | 2 +- .../simplification_3_oracle.sql | 8 +- .../simplification_4_oracle.sql | 10 +- tests/test_sql_refsols/singular1_oracle.sql | 8 +- tests/test_sql_refsols/singular2_oracle.sql | 8 +- tests/test_sql_refsols/singular3_oracle.sql | 22 +- tests/test_sql_refsols/singular4_oracle.sql | 16 +- tests/test_sql_refsols/singular5_oracle.sql | 36 +- tests/test_sql_refsols/singular6_oracle.sql | 12 +- tests/test_sql_refsols/singular7_oracle.sql | 30 +- tests/test_sql_refsols/smoke_c_oracle.sql | 4 +- .../string_format_specifiers_oracle.sql | 2 +- .../supplier_best_part_oracle.sql | 26 +- .../supplier_pct_national_qty_oracle.sql | 12 +- ...battery_failure_rates_anomalies_oracle.sql | 8 +- ...graph_country_cartesian_oddball_oracle.sql | 6 +- ...ph_country_combination_analysis_oracle.sql | 36 +- ..._country_incident_rate_analysis_oracle.sql | 56 +- ...or_percentages_sun_set_by_error_oracle.sql | 10 +- ...rate_sun_set_by_factory_country_oracle.sql | 12 +- ...echnograph_global_incident_rate_oracle.sql | 10 +- ...h_incident_rate_by_release_year_oracle.sql | 38 +- ...nograph_incident_rate_per_brand_oracle.sql | 8 +- ...chnograph_monthly_incident_rate_oracle.sql | 58 +- ...ograph_most_unreliable_products_oracle.sql | 16 +- ...ve_incident_rate_goldcopperstar_oracle.sql | 76 +- ...umulative_incident_rate_overall_oracle.sql | 44 +- .../time_threshold_reached_oracle.sql | 12 +- .../top_customers_by_orders_oracle.sql | 8 +- .../top_lineitems_info_1_oracle.sql | 22 +- .../top_lineitems_info_2_oracle.sql | 16 +- tests/test_sql_refsols/tpch_q10_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q11_oracle.sql | 36 +- tests/test_sql_refsols/tpch_q13_oracle.sql | 10 +- tests/test_sql_refsols/tpch_q15_oracle.sql | 24 +- tests/test_sql_refsols/tpch_q17_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q18_oracle.sql | 12 +- tests/test_sql_refsols/tpch_q20_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q21_oracle.sql | 46 +- tests/test_sql_refsols/tpch_q22_oracle.sql | 6 +- tests/test_sql_refsols/tpch_q2_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q5_oracle.sql | 6 +- tests/test_sql_refsols/tpch_q7_oracle.sql | 14 +- .../triple_partition_oracle.sql | 50 +- .../user_range_collection_1_oracle.sql | 8 +- .../user_range_collection_2_oracle.sql | 40 +- .../user_range_collection_3_oracle.sql | 40 +- .../user_range_collection_4_oracle.sql | 8 +- .../user_range_collection_5_oracle.sql | 24 +- .../user_range_collection_6_oracle.sql | 8 +- .../wealthiest_supplier_oracle.sql | 8 +- .../window_filter_order_10_oracle.sql | 8 +- .../window_filter_order_1_oracle.sql | 20 +- .../window_filter_order_2_oracle.sql | 20 +- .../window_filter_order_3_oracle.sql | 20 +- .../window_filter_order_4_oracle.sql | 12 +- .../window_filter_order_5_oracle.sql | 18 +- .../window_filter_order_6_oracle.sql | 18 +- .../window_filter_order_7_oracle.sql | 8 +- .../window_filter_order_8_oracle.sql | 20 +- .../window_filter_order_9_oracle.sql | 16 +- .../yoy_change_in_num_orders_oracle.sql | 4 +- 274 files changed, 4493 insertions(+), 2218 deletions(-) rename tests/test_metadata/{keywords_graph.json => custom_datasets_graphs.json} (100%) create mode 100644 tests/test_metadata/oracle_custom_datasets_graphs.json diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index 20981317e..de41d94ee 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -215,6 +215,10 @@ def apply_sqlglot_optimizer( # SQL. remove_tuple_row_values(glot_expr) + # Quote identifiers when required + # For Oracle add quotes to all alias starting with _ + quote_oracle_identifiers(glot_expr, dialect) + return glot_expr @@ -467,6 +471,34 @@ def remove_tuple_row_values(expr: SQLGlotExpression) -> None: remove_tuple_row_values(arg) +def quote_oracle_identifiers(expr: SQLGlotExpression, dialect: SQLGlotDialect) -> None: + """ + Add quotes to all Identifiers that start with '_'. Identifiers that start with + '_' are invalid for Oracle unless they are quoted. + + Note: This only is required for the Oracle dialect. + + Args: + expr: The SQLGlot expression to visit. + + Returns: + None (The AST is modified in place.) + """ + if dialect != OracleDialect: + return + + if isinstance(expr, (sqlglot_expressions.Identifier)): + # Identifiers starting with _ are required to be quoted for Oracle + if expr.this.startswith("_"): + new_identifier = sqlglot_expressions.Identifier(this=expr.this, quoted=True) + expr.replace(new_identifier) + + # Recursively visit the subexpressions. + for arg in expr.iter_expressions(): + if isinstance(arg, SQLGlotExpression): + quote_oracle_identifiers(arg, dialect) + + def convert_dialect_to_sqlglot(dialect: DatabaseDialect) -> SQLGlotDialect: """ Convert the given DatabaseDialect to the corresponding SQLGlotDialect. diff --git a/pydough/sqlglot/sqlglot_helpers.py b/pydough/sqlglot/sqlglot_helpers.py index 0c4111423..6326ba773 100644 --- a/pydough/sqlglot/sqlglot_helpers.py +++ b/pydough/sqlglot/sqlglot_helpers.py @@ -62,7 +62,19 @@ def set_glot_alias(expr: SQLGlotExpression, alias: str | None) -> SQLGlotExpress if old_name == alias: return expr else: + # This is needed the first time when the name has quotes in it. quoted, alias = normalize_column_name(alias) + + # When the expr is proccessed more than once the quoted value can be lost. + # In order to keep the initital quoted value through the pipeline + # this is needed. + if isinstance(expr, Identifier): + quoted = expr.quoted + elif isinstance(expr, SQLGlotAlias) and isinstance( + expr.args["alias"], Identifier + ): + quoted = expr.args["alias"].quoted + return generate_glot_alias(expr, alias, quoted=quoted) diff --git a/tests/conftest.py b/tests/conftest.py index cc7191790..fd3f36fe7 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -219,7 +219,23 @@ def get_custom_datasets_graph() -> graph_fetcher: @cache def impl(name: str) -> GraphMetadata: - path: str = f"{os.path.dirname(__file__)}/test_metadata/{name}_graph.json" + path: str = ( + f"{os.path.dirname(__file__)}/test_metadata/custom_datasets_graphs.json" + ) + return pydough.parse_json_metadata_from_file(file_path=path, graph_name=name) + + return impl + + +@pytest.fixture(scope="session") +def get_oracle_custom_datasets_graph() -> graph_fetcher: + """ + Returns the graph for the given custom dataset name for oracle. + """ + + @cache + def impl(name: str) -> GraphMetadata: + path: str = f"{os.path.dirname(__file__)}/test_metadata/oracle_custom_datasets_graphs.json" return pydough.parse_json_metadata_from_file(file_path=path, graph_name=name) return impl diff --git a/tests/test_metadata/keywords_graph.json b/tests/test_metadata/custom_datasets_graphs.json similarity index 100% rename from tests/test_metadata/keywords_graph.json rename to tests/test_metadata/custom_datasets_graphs.json diff --git a/tests/test_metadata/oracle_custom_datasets_graphs.json b/tests/test_metadata/oracle_custom_datasets_graphs.json new file mode 100644 index 000000000..a6c721079 --- /dev/null +++ b/tests/test_metadata/oracle_custom_datasets_graphs.json @@ -0,0 +1,2213 @@ +[ + { + "name": "keywords", + "version": "V2", + "collections": [ + { + "name": "quoted_table_name", + "type": "simple table", + "table path": "\"'QUOTED TABLE_NAME'\"", + "unique properties": [ + "id_" + ], + "properties": [ + { + "name": "id_", + "type": "table column", + "column name": "\"ID\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID'", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "cast_", + "type": "table column", + "column name": "\"`cast`\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'CAST'", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "quote_", + "type": "table column", + "column name": "\"= 'QUOTE'\"", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '`= \"QUOTE\"`'", + "sample values": [ + 2, + 4, + 6 + ], + "synonyms": [] + }, + { + "name": "name", + "type": "table column", + "column name": "\"`name'[\"", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '```name\"[`'", + "sample values": [ + 11, + 9, + 7 + ], + "synonyms": [] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "Column from table \"'QUOTED TABLE_NAME'\"", + "sample values": [ + "RECORD 1", + "RECORD 2", + "RECORD 3" + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "calculate_", + "type": "simple table", + "table path": "keywords.CALCULATE", + "unique properties": [ + "where_" + ], + "properties": [ + { + "name": "where_", + "type": "table column", + "column name": "\".WHERE\"", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '\".WHERE\"'", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "lower", + "type": "table column", + "column name": "LOWER", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'LOWER'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "upper", + "type": "table column", + "column name": "UPPER", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'UPPER'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "length", + "type": "table column", + "column name": "\"LENGTH\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'LENGTH'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "startswith", + "type": "table column", + "column name": "STARTSWITH", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'STARTSWITH'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "endswith", + "type": "table column", + "column name": "ENDSWITH", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ENDSWITH'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "contains", + "type": "table column", + "column name": "CONTAINS", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'CONTAINS'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "like_", + "type": "table column", + "column name": "\"LIKE\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'LIKE'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "join_strings", + "type": "table column", + "column name": "JOIN_STRINGS", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'JOIN_STRINGS'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "lpad", + "type": "table column", + "column name": "LPAD", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'LPAD'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "rpad", + "type": "table column", + "column name": "RPAD", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'RPAD'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "find", + "type": "table column", + "column name": "FIND", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'FIND'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "strip", + "type": "table column", + "column name": "STRIP", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'STRIP'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "replace_", + "type": "table column", + "column name": "REPLACE", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'REPLACE'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "strcount", + "type": "table column", + "column name": "STRCOUNT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'STRCOUNT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "getpart", + "type": "table column", + "column name": "GETPART", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'GETPART'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "datetime", + "type": "table column", + "column name": "DATETIME", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DATETIME'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "year", + "type": "table column", + "column name": "YEAR", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'YEAR'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "quarter", + "type": "table column", + "column name": "QUARTER", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'QUARTER'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "month", + "type": "table column", + "column name": "MONTH", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'MONTH'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "day", + "type": "table column", + "column name": "DAY", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DAY'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "hour", + "type": "table column", + "column name": "HOUR", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'HOUR'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "minute", + "type": "table column", + "column name": "MINUTE", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'MINUTE'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "second", + "type": "table column", + "column name": "SECOND", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'SECOND'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "datediff", + "type": "table column", + "column name": "DATEDIFF", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DATEDIFF'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "dayofweek", + "type": "table column", + "column name": "DAYOFWEEK", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DAYOFWEEK'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "dayname", + "type": "table column", + "column name": "DAYNAME", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DAYNAME'", + "sample values": [ + null + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "cast_", + "type": "simple table", + "table path": "\"CAST\"", + "unique properties": [ + "pk_field_name" + ], + "properties": [ + { + "name": "pk_field_name", + "type": "table column", + "column name": "PK_FIELD_NAME", + "data type": "numeric", + "description": "Primary key column for table CAST", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "id_", + "type": "table column", + "column name": "ID", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID' (foreign key referencing lowercase_detail.id)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "id2", + "type": "table column", + "column name": "ID2", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID2' (foreign key referencing lowercase_detail.id)", + "sample values": [ + 2, + 4, + 6 + ], + "synonyms": [] + }, + { + "name": "is_active", + "type": "table column", + "column name": "is_active", + "data type": "numeric", + "description": "Column from table CAST", + "sample values": [ + 1, + 0 + ], + "synonyms": [] + }, + { + "name": "types", + "type": "table column", + "column name": "\"types\"", + "data type": "string", + "description": "Column from table CAST", + "sample values": [ + "1_types_#438", + "2_types_#438", + "3_types_#438" + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "count", + "type": "simple table", + "table path": "\"COUNT\"", + "unique properties": [ + ["this", "class_"] + ], + "properties": [ + { + "name": "this", + "type": "table column", + "column name": "\"this\"", + "data type": "numeric", + "description": "Column from table COUNT (part of PRIMARY KEY) (foreign key referencing CAST.PK_FIELD_NAME)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "class_", + "type": "table column", + "column name": "class", + "data type": "numeric", + "description": "Column name normalized from Python reserved word 'class' (part of PRIMARY KEY)", + "sample values": [ + 1 + ], + "synonyms": [] + }, + { + "name": "import_", + "type": "table column", + "column name": "import", + "data type": "numeric", + "description": "Column name normalized from Python reserved word 'IMPORT'", + "sample values": [ + 1011, + 1021, + 1031 + ], + "synonyms": [] + }, + { + "name": "def_", + "type": "table column", + "column name": "def", + "data type": "numeric", + "description": "Column name normalized from Python reserved word 'DEF'", + "sample values": [ + 2011, + 2021, + 2031 + ], + "synonyms": [] + }, + { + "name": "pydough_percentage", + "type": "table column", + "column name": "\"%%pydough\"", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '\"%%pydough\"'", + "sample values": [ + 3011, + 3021, + 3031 + ], + "synonyms": [] + }, + { + "name": "node", + "type": "table column", + "column name": "\"node\"", + "data type": "numeric", + "description": "Column name with locals() variable 'node'", + "sample values": [ + 4011, + 4021, + 4031 + ], + "synonyms": [] + }, + { + "name": "unknown_column_6", + "type": "table column", + "column name": "\"',\"", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '\"',\"'", + "sample values": [ + 5011, + 5021, + 5031 + ], + "synonyms": [] + }, + { + "name": "unknown_column_7", + "type": "table column", + "column name": "\".\"", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '`.`'", + "sample values": [ + 6011, + 6021, + 6031 + ], + "synonyms": [] + }, + { + "name": "bool_", + "type": "table column", + "column name": "bool", + "data type": "numeric", + "description": "Column name normalized from Python reserved word 'bool'", + "sample values": [ + 7011, + 7021, + 7031 + ], + "synonyms": [] + }, + { + "name": "call", + "type": "table column", + "column name": "__call__", + "data type": "numeric", + "description": "Column name normalized from '__call__'", + "sample values": [ + 8011, + 8021, + 8031 + ], + "synonyms": [] + }, + { + "name": "int_", + "type": "table column", + "column name": "\"int\"", + "data type": "numeric", + "description": "Column name normalized from SQL and python reserved word 'int'", + "sample values": [ + 9011, + 9021, + 9031 + ], + "synonyms": [] + }, + { + "name": "float_", + "type": "table column", + "column name": "\"FLOAT\"", + "data type": "numeric", + "description": "Column name normalized from SQL and Python reserved word 'float'", + "sample values": [ + 10011, + 10021, + 10031 + ], + "synonyms": [] + }, + { + "name": "init", + "type": "table column", + "column name": "\"__init__\"", + "data type": "numeric", + "description": "Column name normalized from '__init__'", + "sample values": [ + 11011, + 11021, + 11031 + ], + "synonyms": [] + }, + { + "name": "new", + "type": "table column", + "column name": "new", + "data type": "numeric", + "description": "Column from table COUNT", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "del_", + "type": "table column", + "column name": "del", + "data type": "numeric", + "description": "Column name normalized from 'del'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "col", + "type": "table column", + "column name": "\"__col__\"", + "data type": "numeric", + "description": "Column name normalized from predicate format reserved word '__col__'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "col1", + "type": "table column", + "column name": "\"__col1__\"", + "data type": "numeric", + "description": "Column name normalized from predicate format reserved word '__col1__'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "class___20", + "type": "table column", + "column name": "__class__", + "data type": "numeric", + "description": "Column name normalized from '__class__. Normalized original name collides with class property'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "str_", + "type": "table column", + "column name": "str", + "data type": "numeric", + "description": "Column name normalized from Python reserved word 'str'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "dict_", + "type": "table column", + "column name": "dict", + "data type": "numeric", + "description": "Column name normalized from Python reserved word 'dict'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "add_", + "type": "table column", + "column name": "__add__", + "data type": "numeric", + "description": "Column name normalized from reserved word '__add__'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "mul", + "type": "table column", + "column name": "__mul__", + "data type": "numeric", + "description": "Column name normalized from reserved word '__mul__'", + "sample values": [ + null + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "mixedcase_1_1", + "type": "simple table", + "table path": "\"MixedCase_1:1\"", + "unique properties": [ + "id_" + ], + "properties": [ + { + "name": "id_", + "type": "table column", + "column name": "\"Id\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID' (foreign key referencing UPPERCASE_MASTER.ID)", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "parentheses", + "type": "table column", + "column name": "\"(parentheses)\"", + "data type": "string", + "description": "Column name normalized from unusual identifier '`(parentheses)`'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "in_", + "type": "table column", + "column name": "\"In\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'IN'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "lowercaseid", + "type": "table column", + "column name": "\"LowerCaseId\"", + "data type": "numeric", + "description": "Column from mixedcase_1_1 (foreign key referencing lowercase_detail.id)", + "sample values": [ + null + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "partition_", + "type": "simple table", + "table path": "keywords.\"PARTITION\"", + "unique properties": [ + "order_by_" + ], + "properties": [ + { + "name": "order_by_", + "type": "table column", + "column name": "ORDER_BY", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ORDER_BY'", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "calculate_", + "type": "table column", + "column name": "CALCULATE", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'CALCULATE' (foreign key referencing CALCULATE..WHERE)", + "sample values": [ + 2, + 3, + 4 + ], + "synonyms": [] + }, + { + "name": "where_", + "type": "table column", + "column name": "\"WHERE\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'WHERE' (foreign key referencing WHERE..CALCULATE)", + "sample values": [ + 5, + 1, + 2 + ], + "synonyms": [] + }, + { + "name": "top_k", + "type": "table column", + "column name": "TOP_K", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'TOP_K'", + "sample values": [ + 1 + ], + "synonyms": [] + }, + { + "name": "singular", + "type": "table column", + "column name": "SINGULAR", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'SINGULAR'", + "sample values": [ + 1 + ], + "synonyms": [] + }, + { + "name": "best", + "type": "table column", + "column name": "BEST", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'BEST'", + "sample values": [ + 1 + ], + "synonyms": [] + }, + { + "name": "cross_", + "type": "table column", + "column name": "\"CROSS\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'CROSS'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "ranking", + "type": "table column", + "column name": "RANKING", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'RANKING'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "percentile", + "type": "table column", + "column name": "PERCENTILE", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'PERCENTILE'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "prev", + "type": "table column", + "column name": "PREV", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'PREV'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "next_", + "type": "table column", + "column name": "NEXT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'NEXT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "relsum", + "type": "table column", + "column name": "RELSUM", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'RELSUM'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "relavg", + "type": "table column", + "column name": "RELAVG", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'RELAVG'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "relcount", + "type": "table column", + "column name": "RELCOUNT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'RELCOUNT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "relsize", + "type": "table column", + "column name": "RELSIZE", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'RELSIZE'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "string", + "type": "table column", + "column name": "STRING", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'STRING'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "integer", + "type": "table column", + "column name": "\"INTEGER\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'INTEGER'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "float_", + "type": "table column", + "column name": "\"FLOAT\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'FLOAT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "numeric", + "type": "table column", + "column name": "\"NUMERIC\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'NUMERIC'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "decimal", + "type": "table column", + "column name": "\"DECIMAL\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DECIMAL'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "char", + "type": "table column", + "column name": "\"CHAR\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'CHAR'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "varchar", + "type": "table column", + "column name": "\"VARCHAR\"", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'VARCHAR'", + "sample values": [ + null + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "uppercase_master", + "type": "simple table", + "table path": "\"UPPERCASE_MASTER\"", + "unique properties": [ + "id_" + ], + "properties": [ + { + "name": "id_", + "type": "table column", + "column name": "ID", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID'", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "name", + "type": "table column", + "column name": "NAME", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'NAME'", + "sample values": [ + "FIRST_RECORD", + "SECOND_RECORD", + "THIRD_RECORD" + ], + "synonyms": [] + }, + { + "name": "cast_", + "type": "table column", + "column name": "\"CAST\"", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'CAST'", + "sample values": [ + "1 CAST RESERVED WORD", + "2 CAST RESERVED WORD", + "3 CAST RESERVED WORD" + ], + "synonyms": [] + }, + { + "name": "where_", + "type": "table column", + "column name": "\"WHERE\"", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'WHERE'", + "sample values": [ + "1 WHERE RESERVED WORD", + "2 WHERE RESERVED WORD", + "3 WHERE RESERVED WORD" + ], + "synonyms": [] + }, + { + "name": "from_", + "type": "table column", + "column name": "\"FROM\"", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'FROM'", + "sample values": [ + "1 FROM RESERVED WORD", + "2 FROM RESERVED WORD", + "3 FROM RESERVED WORD" + ], + "synonyms": [] + }, + { + "name": "varchar", + "type": "table column", + "column name": "\"VARCHAR\"", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'VARCHAR'", + "sample values": [ + "1 VARCHAR RESERVED WORD", + "2 VARCHAR RESERVED WORD", + "3 VARCHAR RESERVED WORD" + ], + "synonyms": [] + }, + { + "name": "integer", + "type": "table column", + "column name": "\"INTEGER\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'INTEGER'", + "sample values": [ + "1 INTEGER RESERVED WORD", + "2 INTEGER RESERVED WORD", + "3 INTEGER RESERVED WORD" + ], + "synonyms": [] + }, + { + "name": "two_words", + "type": "table column", + "column name": "\"TWO WORDS\"", + "data type": "string", + "description": "Column name normalized from unusual identifier '`TWO WORDS`'", + "sample values": [ + "1 TWO WORDS FIELD NAME", + "2 TWO WORDS FIELD NAME", + "3 TWO WORDS FIELD NAME" + ], + "synonyms": [] + }, + { + "name": "order_by_", + "type": "table column", + "column name": "\"ORDER BY\"", + "data type": "string", + "description": "Column name normalized from unusual identifier '`ORDER BY`'", + "sample values": [ + "1 TWO WORDS RESERVED", + "2 TWO WORDS RESERVED", + "3 TWO WORDS RESERVED" + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "where_", + "type": "simple table", + "table path": "\"WHERE\"", + "unique properties": [ + "calculate_" + ], + "properties": [ + { + "name": "calculate_", + "type": "table column", + "column name": "`.CALCULATE`", + "data type": "numeric", + "description": "Column name normalized from unusual identifier '`.CALCULATE`' (foreign key referencing CALCULATE..WHERE)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "iff", + "type": "table column", + "column name": "IFF", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'IFF'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "isin", + "type": "table column", + "column name": "ISIN", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ISIN'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "default_to", + "type": "table column", + "column name": "DEFAULT_TO", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'DEFAULT_TO'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "present", + "type": "table column", + "column name": "PRESENT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'PRESENT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "absent", + "type": "table column", + "column name": "ABSENT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ABSENT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "keep_if", + "type": "table column", + "column name": "KEEP_IF", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'KEEP_IF'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "monotonic", + "type": "table column", + "column name": "MONOTONIC", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'MONOTONIC'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "abs_", + "type": "table column", + "column name": "ABS", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ABS'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "round_", + "type": "table column", + "column name": "ROUND", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ROUND'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "ceil", + "type": "table column", + "column name": "CEIL", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'CEIL'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "floor", + "type": "table column", + "column name": "FLOOR", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'FLOOR'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "power", + "type": "table column", + "column name": "POWER", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'POWER'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "sqrt", + "type": "table column", + "column name": "SQRT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'SQRT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "sign", + "type": "table column", + "column name": "SIGN", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'SIGN'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "smallest", + "type": "table column", + "column name": "SMALLEST", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'SMALLEST'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "largest", + "type": "table column", + "column name": "LARGEST", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'LARGEST'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "sum_", + "type": "table column", + "column name": "SUM", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'SUM'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "avg", + "type": "table column", + "column name": "AVG", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'AVG'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "median", + "type": "table column", + "column name": "MEDIAN", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'MEDIAN'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "min_", + "type": "table column", + "column name": "MIN", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'MIN'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "max_", + "type": "table column", + "column name": "MAX", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'MAX'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "quantile", + "type": "table column", + "column name": "QUANTILE", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'QUANTILE'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "anything", + "type": "table column", + "column name": "ANYTHING", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'ANYTHING'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "count", + "type": "table column", + "column name": "`COUNT`", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'COUNT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "ndistinct", + "type": "table column", + "column name": "NDISTINCT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'NDISTINCT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "has", + "type": "table column", + "column name": "HAS", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'HAS'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "hasnot", + "type": "table column", + "column name": "HASNOT", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'HASNOT'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "var", + "type": "table column", + "column name": "VAR", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'VAR'", + "sample values": [ + null + ], + "synonyms": [] + }, + { + "name": "std", + "type": "table column", + "column name": "STD", + "data type": "numeric", + "description": "Column name normalized from PyDough reserved word 'STD'", + "sample values": [ + null + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "detail1", + "type": "simple table", + "table path": "detail1", + "unique properties": [ + "key_" + ], + "properties": [ + { + "name": "key_", + "type": "table column", + "column name": "\"key\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'KEY' (part of PRIMARY KEY)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "id1", + "type": "table column", + "column name": "id1", + "data type": "numeric", + "description": "Column from table detail1 (part of UNIQUE constraint) (foreign key referencing master.ID1)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "id2", + "type": "table column", + "column name": "id2", + "data type": "numeric", + "description": "Column from table detail1 (part of UNIQUE constraint) (foreign key referencing master.ID2)", + "sample values": [ + 1, + 2 + ], + "synonyms": [] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "Column from table detail1", + "sample values": [ + "1 One-One AK-PK", + "2 One-Two AK-PK", + "3 Two-One AK-PK" + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "detail2", + "type": "simple table", + "table path": "detail2", + "unique properties": [ + "key_" + ], + "properties": [ + { + "name": "key_", + "type": "table column", + "column name": "\"key\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'KEY' (part of PRIMARY KEY)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "alt_key1", + "type": "table column", + "column name": "alt_key1", + "data type": "numeric", + "description": "Column from table detail2 (foreign key referencing master.ALT_KEY1)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "alt_key2", + "type": "table column", + "column name": "alt_key2", + "data type": "numeric", + "description": "Column from table detail2 (foreign key referencing master.ALT_KEY2)", + "sample values": [ + 1, + 2 + ], + "synonyms": [] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "Column from table detail2", + "sample values": [ + "1 One-One FK-PK", + "2 One-Two FK-PK", + "3 Two-One FK-PK" + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "lowercase_detail", + "type": "simple table", + "table path": "\"lowercase_detail\"", + "unique properties": [ + "id_" + ], + "properties": [ + { + "name": "id_", + "type": "table column", + "column name": "\"id\"", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID'", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "master_id", + "type": "table column", + "column name": "master_id", + "data type": "numeric", + "description": "Column from table lowercase_detail (foreign key referencing UPPERCASE_MASTER.ID)", + "sample values": [ + 1, + 3, + 4 + ], + "synonyms": [] + }, + { + "name": "two_words", + "type": "table column", + "column name": "\"two words\"", + "data type": "string", + "description": "Column name normalized from unusual identifier '`two words`'", + "sample values": [ + "1 two words field name", + "2 two words field name", + "3 two words field name" + ], + "synonyms": [] + }, + { + "name": "select_", + "type": "table column", + "column name": "\"select\"", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'SELECT'", + "sample values": [ + "1 select reserved word", + "2 select reserved word", + "3 select reserved word" + ], + "synonyms": [] + }, + { + "name": "as_", + "type": "table column", + "column name": "\"as\"", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'AS'", + "sample values": [ + "1 as reserved word", + "2 as reserved word", + "3 as reserved word" + ], + "synonyms": [] + }, + { + "name": "_0_0_and", + "type": "table column", + "column name": "\"0 = 0 and '\"", + "data type": "string", + "description": "Column name normalized from unusual identifier '`0 = 0 and '`'", + "sample values": [ + "1 \"0 = 0 and '\" field name", + "2 \"0 = 0 and '\" field name", + "3 \"0 = 0 and '\" field name" + ], + "synonyms": [] + }, + { + "name": "result", + "type": "table column", + "column name": "result", + "data type": "numeric", + "description": "Column from table lowercase_detail", + "sample values": [ + 1234.56, + 2345.67, + 3456.78 + ], + "synonyms": [] + }, + { + "name": "is_active", + "type": "table column", + "column name": "is_active", + "data type": "numeric", + "description": "Column from table lowercase_detail", + "sample values": [ + 1, + 0 + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + }, + { + "name": "master", + "type": "simple table", + "table path": "\"master\"", + "unique properties": [ + ["id1", "id2"] + ], + "properties": [ + { + "name": "id1", + "type": "table column", + "column name": "ID1", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID1' (part of PRIMARY KEY)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "id2", + "type": "table column", + "column name": "ID2", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ID2' (part of PRIMARY KEY)", + "sample values": [ + 1, + 2 + ], + "synonyms": [] + }, + { + "name": "alt_key1", + "type": "table column", + "column name": "ALT_KEY1", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ALT_KEY1' (part of UNIQUE constraint)", + "sample values": [ + 1, + 2, + 3 + ], + "synonyms": [] + }, + { + "name": "alt_key2", + "type": "table column", + "column name": "ALT_KEY2", + "data type": "numeric", + "description": "Column name normalized from SQL reserved word 'ALT_KEY2' (part of UNIQUE constraint)", + "sample values": [ + 1, + 2 + ], + "synonyms": [] + }, + { + "name": "description", + "type": "table column", + "column name": "DESCRIPTION", + "data type": "string", + "description": "Column name normalized from SQL reserved word 'DESCRIPTION'", + "sample values": [ + "One-One master row", + "One-Two master row", + "Two-One master row" + ], + "synonyms": [] + } + ], + "description": "", + "synonyms": [] + } + ], + "relationships": [ + { + "type": "simple join", + "name": "quoted_table_name", + "parent collection": "lowercase_detail", + "child collection": "quoted_table_name", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "name" + ] + }, + "description": "Relationship between lowercase_detail and quoted_table_name", + "synonyms": [] + }, + { + "type": "reverse", + "name": "lowercase_detail", + "original parent": "lowercase_detail", + "original property": "quoted_table_name", + "singular": true, + "always matches": true, + "description": "reverse for relationship between lowercase_detail and quoted_table_name", + "synonyms": [] + }, + { + "type": "simple join", + "name": "quoted_table_name_2", + "parent collection": "lowercase_detail", + "child collection": "quoted_table_name", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "quote_" + ] + }, + "description": "Relationship between lowercase_detail and quoted_table_name", + "synonyms": [] + }, + { + "type": "reverse", + "name": "lowercase_detail_2", + "original parent": "lowercase_detail", + "original property": "quoted_table_name_2", + "singular": true, + "always matches": true, + "description": "reverse for relationship between lowercase_detail and quoted_table_name", + "synonyms": [] + }, + { + "type": "simple join", + "name": "quoted_table_name_3", + "parent collection": "uppercase_master", + "child collection": "quoted_table_name", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "cast_" + ] + }, + "description": "Relationship between uppercase_master and quoted_table_name", + "synonyms": [] + }, + { + "type": "reverse", + "name": "uppercase_master", + "original parent": "uppercase_master", + "original property": "quoted_table_name_3", + "singular": true, + "always matches": true, + "description": "reverse for relationship between uppercase_master and quoted_table_name", + "synonyms": [] + }, + { + "type": "simple join", + "name": "cast_", + "parent collection": "lowercase_detail", + "child collection": "cast_", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "id2" + ] + }, + "description": "Relationship between lowercase_detail and cast_", + "synonyms": [] + }, + { + "type": "reverse", + "name": "lowercase_detail_3", + "original parent": "lowercase_detail", + "original property": "cast_", + "singular": true, + "always matches": false, + "description": "reverse for relationship between lowercase_detail and cast_", + "synonyms": [] + }, + { + "type": "simple join", + "name": "cast__2", + "parent collection": "lowercase_detail", + "child collection": "cast_", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "id_" + ] + }, + "description": "Relationship between lowercase_detail and cast_", + "synonyms": [] + }, + { + "type": "reverse", + "name": "lowercase_detail_4", + "original parent": "lowercase_detail", + "original property": "cast__2", + "singular": true, + "always matches": true, + "description": "reverse for relationship between lowercase_detail and cast_", + "synonyms": [] + }, + { + "type": "simple join", + "name": "count", + "parent collection": "cast_", + "child collection": "count", + "singular": true, + "always matches": false, + "keys": { + "pk_field_name": [ + "this" + ] + }, + "description": "Relationship between cast_ and count", + "synonyms": [] + }, + { + "type": "reverse", + "name": "cast_", + "original parent": "cast_", + "original property": "count", + "singular": true, + "always matches": true, + "description": "reverse for relationship between cast_ and count", + "synonyms": [] + }, + { + "type": "simple join", + "name": "mixedcase_1_1", + "parent collection": "lowercase_detail", + "child collection": "mixedcase_1_1", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "lowercaseid" + ] + }, + "description": "Relationship between lowercase_detail and mixedcase_1_1", + "synonyms": [] + }, + { + "type": "reverse", + "name": "lowercase_detail_5", + "original parent": "lowercase_detail", + "original property": "mixedcase_1_1", + "singular": true, + "always matches": true, + "description": "reverse for relationship between lowercase_detail and mixedcase_1_1", + "synonyms": [] + }, + { + "type": "simple join", + "name": "mixedcase_1_1_2", + "parent collection": "uppercase_master", + "child collection": "mixedcase_1_1", + "singular": true, + "always matches": false, + "keys": { + "id_": [ + "id_" + ] + }, + "description": "Relationship between uppercase_master and mixedcase_1_1", + "synonyms": [] + }, + { + "type": "reverse", + "name": "uppercase_master_2", + "original parent": "uppercase_master", + "original property": "mixedcase_1_1_2", + "singular": true, + "always matches": true, + "description": "reverse for relationship between uppercase_maste and mixedcase_1_1", + "synonyms": [] + }, + { + "type": "simple join", + "name": "partition_", + "parent collection": "where_", + "child collection": "partition_", + "singular": false, + "always matches": false, + "keys": { + "calculate_": [ + "where_" + ] + }, + "description": "Relationship between where_ and partition_", + "synonyms": [] + }, + { + "type": "reverse", + "name": "where_collection", + "original parent": "where_", + "original property": "partition_", + "singular": true, + "always matches": true, + "description": "reverse for relationship between where_ and partition_", + "synonyms": [] + }, + { + "type": "simple join", + "name": "partition__2", + "parent collection": "calculate_", + "child collection": "partition_", + "singular": false, + "always matches": false, + "keys": { + "where_": [ + "calculate_" + ] + }, + "description": "Relationship between calculate_ and partition_", + "synonyms": [] + }, + { + "type": "reverse", + "name": "calculate_collection", + "original parent": "calculate_", + "original property": "partition__2", + "singular": true, + "always matches": true, + "description": "reverse for relationship between calculate_ and partition_", + "synonyms": [] + }, + { + "type": "simple join", + "name": "where_collection", + "parent collection": "calculate_", + "child collection": "where_", + "singular": false, + "always matches": false, + "keys": { + "where_": [ + "calculate_" + ] + }, + "description": "Relationship between calculate_ and where_", + "synonyms": [] + }, + { + "type": "reverse", + "name": "calculate__2", + "original parent": "calculate_", + "original property": "where_collection", + "singular": true, + "always matches": true, + "description": "reverse for relationship between calculate_ and where_", + "synonyms": [] + }, + { + "type": "simple join", + "name": "detail1", + "parent collection": "master", + "child collection": "detail1", + "singular": true, + "always matches": false, + "keys": { + "id1": [ + "id1" + ], + "id2": [ + "id2" + ] + }, + "description": "Relationship between master and detail1", + "synonyms": [] + }, + { + "type": "reverse", + "name": "master", + "original parent": "master", + "original property": "detail1", + "singular": true, + "always matches": true, + "description": "reverse for relationship between master and detail1", + "synonyms": [] + }, + { + "type": "simple join", + "name": "detail2", + "parent collection": "master", + "child collection": "detail2", + "singular": false, + "always matches": false, + "keys": { + "id1": [ + "alt_key1" + ], + "id2": [ + "alt_key2" + ] + }, + "description": "Relationship between master and detail2", + "synonyms": [] + }, + { + "type": "reverse", + "name": "master_2", + "original parent": "master", + "original property": "detail2", + "singular": true, + "always matches": false, + "description": "reverse for relationship between master and detail2", + "synonyms": [] + }, + { + "type": "simple join", + "name": "lowercase_detail", + "parent collection": "uppercase_master", + "child collection": "lowercase_detail", + "singular": false, + "always matches": false, + "keys": { + "id_": [ + "master_id" + ] + }, + "description": "Relationship between uppercase_master and lowercase_detail", + "synonyms": [] + }, + { + "type": "reverse", + "name": "uppercase_master_3", + "original parent": "uppercase_master", + "original property": "lowercase_detail", + "singular": true, + "always matches": true, + "description": "reverse for relationship between uppercase_master and lowercase_detail", + "synonyms": [] + } + ] + } +] diff --git a/tests/test_pipeline_oracle.py b/tests/test_pipeline_oracle.py index abc910c20..6211e4221 100644 --- a/tests/test_pipeline_oracle.py +++ b/tests/test_pipeline_oracle.py @@ -268,7 +268,7 @@ def test_pipeline_e2e_oracle_defog( @pytest.mark.execute def test_pipeline_e2e_oracle_custom_datasets( custom_datasets_test_data: PyDoughPandasTest, # noqa: F811 - get_custom_datasets_graph: graph_fetcher, + get_oracle_custom_datasets_graph: graph_fetcher, oracle_conn_db_context: Callable[[str], DatabaseContext], ): """ @@ -276,7 +276,7 @@ def test_pipeline_e2e_oracle_custom_datasets( refsol DataFrame. """ custom_datasets_test_data.run_e2e_test( - get_custom_datasets_graph, + get_oracle_custom_datasets_graph, oracle_conn_db_context(custom_datasets_test_data.graph_name.lower()), coerce_types=True, ) diff --git a/tests/test_sql_refsols/agg_partition_oracle.sql b/tests/test_sql_refsols/agg_partition_oracle.sql index 4c7136a01..890272742 100644 --- a/tests/test_sql_refsols/agg_partition_oracle.sql +++ b/tests/test_sql_refsols/agg_partition_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT COUNT(*) AS N_ROWS FROM TPCH.ORDERS @@ -7,4 +7,4 @@ WITH _T0 AS ( ) SELECT MAX(N_ROWS) AS best_year -FROM _T0 +FROM "_T0" diff --git a/tests/test_sql_refsols/agg_simplification_1_oracle.sql b/tests/test_sql_refsols/agg_simplification_1_oracle.sql index aed5a4ea4..3c51f4bb7 100644 --- a/tests/test_sql_refsols/agg_simplification_1_oracle.sql +++ b/tests/test_sql_refsols/agg_simplification_1_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT sbtickerexchange AS SBTICKEREXCHANGE, CASE @@ -136,7 +136,7 @@ WITH _T1 AS ( ELSE NULL END AS EXPR_87 FROM MAIN.SBTICKER -), _T0 AS ( +), "_T0" AS ( SELECT LENGTH(CASE WHEN SBTICKEREXCHANGE <> 'NYSE Arca' THEN SBTICKEREXCHANGE ELSE NULL END) AS AUG_EXCHANGE, AVG(EXPR_72) AS AVG_EXPR_72, @@ -154,7 +154,7 @@ WITH _T1 AS ( MAX(EXPR_85) AS MAX_EXPR_85, MAX(EXPR_87) AS MAX_EXPR_87, COUNT(*) AS N_ROWS - FROM _T1 + FROM "_T1" GROUP BY LENGTH(CASE WHEN SBTICKEREXCHANGE <> 'NYSE Arca' THEN SBTICKEREXCHANGE ELSE NULL END) ) @@ -232,6 +232,6 @@ SELECT MAX_EXPR_85 AS qu6, NULL AS qu7, MAX_EXPR_87 AS qu8 -FROM _T0 +FROM "_T0" ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql index 81711b0a1..82c4b5149 100644 --- a/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql +++ b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql @@ -1,11 +1,11 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT s_name AS S_NAME, s_suppkey AS S_SUPPKEY FROM TPCH.SUPPLIER WHERE s_name = 'Supplier#000009450' -), _S11 AS ( +), "_S11" AS ( SELECT PARTSUPP.ps_partkey AS PS_PARTKEY, PARTSUPP.ps_suppkey AS PS_SUPPKEY, @@ -17,8 +17,8 @@ WITH _T1 AS ( ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost ) AS SUM_REVENUE FROM TPCH.PARTSUPP PARTSUPP - JOIN _T1 _T4 - ON PARTSUPP.ps_suppkey = _T4.S_SUPPKEY + JOIN "_T1" "_T4" + ON PARTSUPP.ps_suppkey = "_T4".S_SUPPKEY JOIN TPCH.PART PART ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey JOIN TPCH.LINEITEM LINEITEM @@ -31,14 +31,15 @@ WITH _T1 AS ( ) SELECT PART.p_name AS part_name, - ROUND(NVL(_S11.SUM_REVENUE, 0), 2) AS revenue_generated + ROUND(NVL("_S11".SUM_REVENUE, 0), 2) AS revenue_generated FROM TPCH.PARTSUPP PARTSUPP -JOIN _T1 _T1 - ON PARTSUPP.ps_suppkey = _T1.S_SUPPKEY +JOIN "_T1" "_T1" + ON PARTSUPP.ps_suppkey = "_T1".S_SUPPKEY JOIN TPCH.PART PART ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey -LEFT JOIN _S11 _S11 - ON PARTSUPP.ps_partkey = _S11.PS_PARTKEY AND PARTSUPP.ps_suppkey = _S11.PS_SUPPKEY +LEFT JOIN "_S11" "_S11" + ON PARTSUPP.ps_partkey = "_S11".PS_PARTKEY + AND PARTSUPP.ps_suppkey = "_S11".PS_SUPPKEY ORDER BY 2 NULLS FIRST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql index aea10e83a..5c72d413f 100644 --- a/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql +++ b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S6 AS ( +WITH "_S6" AS ( SELECT PARTSUPP.ps_partkey AS PS_PARTKEY, SUM( @@ -24,10 +24,10 @@ WITH _S6 AS ( ) SELECT PART.p_name AS part_name, - ROUND(NVL(_S6.SUM_REVENUE, 0), 2) AS revenue_generated -FROM _S6 _S6 + ROUND(NVL("_S6".SUM_REVENUE, 0), 2) AS revenue_generated +FROM "_S6" "_S6" JOIN TPCH.PART PART - ON PART.p_partkey = _S6.PS_PARTKEY + ON PART.p_partkey = "_S6".PS_PARTKEY ORDER BY 2 NULLS FIRST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql index 9bab90dbd..9bd0e98cd 100644 --- a/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql +++ b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S6 AS ( +WITH "_S6" AS ( SELECT PARTSUPP.ps_partkey AS PS_PARTKEY, SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY, @@ -25,10 +25,10 @@ WITH _S6 AS ( ) SELECT PART.p_name AS part_name, - ROUND(NVL(_S6.SUM_REVENUE, 0) / NVL(_S6.SUM_L_QUANTITY, 0), 2) AS revenue_ratio -FROM _S6 _S6 + ROUND(NVL("_S6".SUM_REVENUE, 0) / NVL("_S6".SUM_L_QUANTITY, 0), 2) AS revenue_ratio +FROM "_S6" "_S6" JOIN TPCH.PART PART - ON PART.p_partkey = _S6.PS_PARTKEY + ON PART.p_partkey = "_S6".PS_PARTKEY ORDER BY 2 NULLS FIRST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/aggregation_functions_oracle.sql b/tests/test_sql_refsols/aggregation_functions_oracle.sql index 17a483609..4f9084ea9 100644 --- a/tests/test_sql_refsols/aggregation_functions_oracle.sql +++ b/tests/test_sql_refsols/aggregation_functions_oracle.sql @@ -1,15 +1,15 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY o_custkey -), _T2 AS ( +), "_T2" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_nationkey AS C_NATIONKEY, - _S1.N_ROWS, + "_S1".N_ROWS, CASE WHEN ABS( ( @@ -29,9 +29,9 @@ WITH _S1 AS ( ELSE NULL END AS EXPR_18 FROM TPCH.CUSTOMER CUSTOMER - LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY -), _T1 AS ( + LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY +), "_T1" AS ( SELECT ANY_VALUE(C_ACCTBAL) AS ANYTHING_C_ACCTBAL, AVG(C_ACCTBAL) AS AVG_C_ACCTBAL, @@ -47,7 +47,7 @@ WITH _S1 AS ( VARIANCE(C_ACCTBAL) AS SAMPLE_VAR_C_ACCTBAL, SUM(C_ACCTBAL) AS SUM_C_ACCTBAL, SUM(N_ROWS) AS SUM_N_ROWS - FROM _T2 + FROM "_T2" GROUP BY C_NATIONKEY ) @@ -65,6 +65,6 @@ SELECT POPULATION_VAR_C_ACCTBAL AS variance_p_value, SAMPLE_STD_C_ACCTBAL AS stddev_s_value, POPULATION_STD_C_ACCTBAL AS stddev_p_value -FROM _T1 +FROM "_T1" WHERE SUM_N_ROWS = 0 OR SUM_N_ROWS IS NULL diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql index 29da7a281..9fc3fc67b 100644 --- a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -1,78 +1,78 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT ca_dt AS CA_DT FROM MAIN.CALENDAR -), _T2 AS ( +), "_T2" AS ( SELECT pr_name AS PR_NAME, pr_release AS PR_RELEASE FROM MAIN.PRODUCTS WHERE pr_name = 'RubyCopper-Star' -), _S12 AS ( +), "_S12" AS ( SELECT DISTINCT - TRUNC(CAST(_S0.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER - FROM _S0 _S0 - JOIN _T2 _T2 - ON _S0.CA_DT < TRUNC(DATE_ADD(CAST(_T2.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S0.CA_DT >= _T2.PR_RELEASE -), _T5 AS ( + TRUNC(CAST("_S0".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + FROM "_S0" "_S0" + JOIN "_T2" "_T2" + ON "_S0".CA_DT < TRUNC(DATE_ADD(CAST("_T2".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S0".CA_DT >= "_T2".PR_RELEASE +), "_T5" AS ( SELECT pr_id AS PR_ID, pr_name AS PR_NAME FROM MAIN.PRODUCTS WHERE pr_name = 'RubyCopper-Star' -), _S9 AS ( +), "_S9" AS ( SELECT COUNTRIES.co_id AS CO_ID, - _T5.PR_ID - FROM _T5 _T5 + "_T5".PR_ID + FROM "_T5" "_T5" JOIN MAIN.COUNTRIES COUNTRIES ON COUNTRIES.co_name = 'CN' -), _S13 AS ( +), "_S13" AS ( SELECT - TRUNC(CAST(_S2.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + TRUNC(CAST("_S2".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID - FROM _S0 _S2 - JOIN _T2 _T4 - ON _S2.CA_DT < TRUNC(DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S2.CA_DT >= _T4.PR_RELEASE + FROM "_S0" "_S2" + JOIN "_T2" "_T4" + ON "_S2".CA_DT < TRUNC(DATE_ADD(CAST("_T4".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S2".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.INCIDENTS INCIDENTS - ON _S2.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') - JOIN _S9 _S9 - ON INCIDENTS.in_repair_country_id = _S9.CO_ID + ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN "_S9" "_S9" + ON INCIDENTS.in_repair_country_id = "_S9".CO_ID JOIN MAIN.DEVICES DEVICES - ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = _S9.PR_ID + ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = "_S9".PR_ID GROUP BY - TRUNC(CAST(_S2.CA_DT AS TIMESTAMP), 'QUARTER') -), _S21 AS ( + TRUNC(CAST("_S2".CA_DT AS TIMESTAMP), 'QUARTER') +), "_S21" AS ( SELECT - TRUNC(CAST(_S14.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + TRUNC(CAST("_S14".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, COUNT(*) AS N_ROWS - FROM _S0 _S14 - JOIN _T2 _T8 - ON _S14.CA_DT < TRUNC(DATE_ADD(CAST(_T8.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S14.CA_DT >= _T8.PR_RELEASE + FROM "_S0" "_S14" + JOIN "_T2" "_T8" + ON "_S14".CA_DT < TRUNC(DATE_ADD(CAST("_T8".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S14".CA_DT >= "_T8".PR_RELEASE JOIN MAIN.DEVICES DEVICES - ON _S14.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') - JOIN _T5 _T9 - ON DEVICES.de_product_id = _T9.PR_ID + ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN "_T5" "_T9" + ON DEVICES.de_product_id = "_T9".PR_ID GROUP BY - TRUNC(CAST(_S14.CA_DT AS TIMESTAMP), 'QUARTER') + TRUNC(CAST("_S14".CA_DT AS TIMESTAMP), 'QUARTER') ) SELECT - _S12.QUARTER AS quarter, - NVL(_S13.NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, - NVL(_S21.N_ROWS, 0) AS n_sold, + "_S12".QUARTER AS quarter, + NVL("_S13".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + NVL("_S21".N_ROWS, 0) AS n_sold, ROUND( - SUM(NVL(_S13.NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY _S12.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S21.N_ROWS, 0)) OVER (ORDER BY _S12.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(NVL("_S13".NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY "_S12".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL("_S21".N_ROWS, 0)) OVER (ORDER BY "_S12".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS quarter_cum -FROM _S12 _S12 -LEFT JOIN _S13 _S13 - ON _S12.QUARTER = _S13.QUARTER -LEFT JOIN _S21 _S21 - ON _S12.QUARTER = _S21.QUARTER +FROM "_S12" "_S12" +LEFT JOIN "_S13" "_S13" + ON "_S12".QUARTER = "_S13".QUARTER +LEFT JOIN "_S21" "_S21" + ON "_S12".QUARTER = "_S21".QUARTER ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql b/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql index b8e5545f5..d656e9d2b 100644 --- a/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql +++ b/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT c_nationkey AS C_NATIONKEY, SUM(GREATEST(c_acctbal, 0)) AS EXPR_0, @@ -6,20 +6,20 @@ WITH _S1 AS ( FROM TPCH.CUSTOMER GROUP BY c_nationkey -), _S3 AS ( +), "_S3" AS ( SELECT NATION.n_regionkey AS N_REGIONKEY, - SUM(_S1.EXPR_0) AS SUM_EXPR, - SUM(_S1.EXPR_1_0) AS SUM_EXPR_1 + SUM("_S1".EXPR_0) AS SUM_EXPR, + SUM("_S1".EXPR_1_0) AS SUM_EXPR_1 FROM TPCH.NATION NATION - JOIN _S1 _S1 - ON NATION.n_nationkey = _S1.C_NATIONKEY + JOIN "_S1" "_S1" + ON NATION.n_nationkey = "_S1".C_NATIONKEY GROUP BY NATION.n_regionkey ) SELECT REGION.r_name AS region_name, - _S3.SUM_EXPR / _S3.SUM_EXPR_1 AS avg_bal_without_debt_erasure + "_S3".SUM_EXPR / "_S3".SUM_EXPR_1 AS avg_bal_without_debt_erasure FROM TPCH.REGION REGION -JOIN _S3 _S3 - ON REGION.r_regionkey = _S3.N_REGIONKEY +JOIN "_S3" "_S3" + ON REGION.r_regionkey = "_S3".N_REGIONKEY diff --git a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql index 71166e85b..15f375aa7 100644 --- a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql +++ b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT DATEDIFF( CAST(o_orderdate AS DATETIME), @@ -11,4 +11,4 @@ WITH _T0 AS ( ) SELECT AVG(DELTA) AS avg_delta -FROM _T0 +FROM "_T0" diff --git a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql index 250ec02c8..53f926893 100644 --- a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql +++ b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT CUSTOMER.c_name AS C_NAME, ORDERS.o_custkey AS O_CUSTKEY, @@ -16,7 +16,7 @@ WITH _T1 AS ( SELECT ANY_VALUE(C_NAME) AS name, AVG(DAY_DIFF) AS avg_diff -FROM _T1 +FROM "_T1" GROUP BY O_CUSTKEY ORDER BY diff --git a/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql index e90b5e642..40bb46190 100644 --- a/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql @@ -1,26 +1,26 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY o_custkey -), _T1 AS ( +), "_T1" AS ( SELECT CUSTOMER.c_custkey AS C_CUSTKEY, - _S1.N_ROWS + "_S1".N_ROWS FROM TPCH.CUSTOMER CUSTOMER - LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST, - NVL(_S1.N_ROWS, 0) NULLS FIRST + NVL("_S1".N_ROWS, 0) NULLS FIRST FETCH FIRST 10 ROWS ONLY ) SELECT C_CUSTKEY AS cust_key, N_ROWS AS n_orders -FROM _T1 +FROM "_T1" WHERE N_ROWS <> 0 ORDER BY diff --git a/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql index 3a87abebc..4a7d1a623 100644 --- a/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql @@ -1,25 +1,25 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY o_custkey -), _T1 AS ( +), "_T1" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_custkey AS C_CUSTKEY, - _S1.N_ROWS, + "_S1".N_ROWS, COUNT(*) OVER (PARTITION BY CUSTOMER.c_nationkey) AS N_CUST FROM TPCH.CUSTOMER CUSTOMER - LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ) SELECT C_CUSTKEY AS cust_key, N_ROWS AS n_orders, N_CUST AS n_cust -FROM _T1 +FROM "_T1" WHERE N_ROWS <> 0 ORDER BY diff --git a/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql index 3a87abebc..4a7d1a623 100644 --- a/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql @@ -1,25 +1,25 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY o_custkey -), _T1 AS ( +), "_T1" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_custkey AS C_CUSTKEY, - _S1.N_ROWS, + "_S1".N_ROWS, COUNT(*) OVER (PARTITION BY CUSTOMER.c_nationkey) AS N_CUST FROM TPCH.CUSTOMER CUSTOMER - LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ) SELECT C_CUSTKEY AS cust_key, N_ROWS AS n_orders, N_CUST AS n_cust -FROM _T1 +FROM "_T1" WHERE N_ROWS <> 0 ORDER BY diff --git a/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql index b0f682f4a..570830aaa 100644 --- a/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql @@ -1,26 +1,26 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY o_custkey -), _T AS ( +), "_T" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_custkey AS C_CUSTKEY, - _S1.N_ROWS, - AVG(CAST(NVL(_S1.N_ROWS, 0) AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey) AS _W + "_S1".N_ROWS, + AVG(CAST(NVL("_S1".N_ROWS, 0) AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey) AS "_W" FROM TPCH.CUSTOMER CUSTOMER - LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ) SELECT C_CUSTKEY AS cust_key, N_ROWS AS n_orders -FROM _T +FROM "_T" WHERE - N_ROWS <> 0 AND _W > NVL(N_ROWS, 0) + N_ROWS <> 0 AND "_W" > NVL(N_ROWS, 0) ORDER BY C_ACCTBAL DESC NULLS LAST FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql index 657e14682..908f35406 100644 --- a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql @@ -1,33 +1,33 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT o_custkey AS O_CUSTKEY FROM TPCH.ORDERS -), _S1 AS ( +), "_S1" AS ( SELECT O_CUSTKEY, COUNT(*) AS N_ROWS - FROM _T2 + FROM "_T2" GROUP BY O_CUSTKEY -), _S2 AS ( +), "_S2" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_custkey AS C_CUSTKEY, - _S1.N_ROWS + "_S1".N_ROWS FROM TPCH.CUSTOMER CUSTOMER - LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ORDER BY 1 DESC NULLS LAST, 2 DESC NULLS LAST FETCH FIRST 10 ROWS ONLY ) SELECT - _S2.C_CUSTKEY AS cust_key, - NVL(_S2.N_ROWS, 0) AS n_orders -FROM _S2 _S2 -JOIN _T2 _S3 - ON _S2.C_CUSTKEY = _S3.O_CUSTKEY + "_S2".C_CUSTKEY AS cust_key, + NVL("_S2".N_ROWS, 0) AS n_orders +FROM "_S2" "_S2" +JOIN "_T2" "_S3" + ON "_S2".C_CUSTKEY = "_S3".O_CUSTKEY ORDER BY - _S2.C_ACCTBAL DESC NULLS LAST, + "_S2".C_ACCTBAL DESC NULLS LAST, 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql index 440d9980c..9e21400ab 100644 --- a/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql +++ b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS @@ -8,16 +8,16 @@ WITH _S1 AS ( ) SELECT CUSTOMER.c_acctbal < 0 AS in_debt, - _S1.N_ROWS <= 12 OR _S1.N_ROWS IS NULL AS at_most_12_orders, + "_S1".N_ROWS <= 12 OR "_S1".N_ROWS IS NULL AS at_most_12_orders, REGION.r_name = 'EUROPE' AS is_european, NATION.n_name <> 'GERMANY' AS non_german, CUSTOMER.c_acctbal > 0 AS non_empty_acct, - NOT _S1.N_ROWS IS NULL AND _S1.N_ROWS >= 5 AS at_least_5_orders, + NOT "_S1".N_ROWS IS NULL AND "_S1".N_ROWS >= 5 AS at_least_5_orders, REGION.r_name = 'ASIA' OR REGION.r_name = 'EUROPE' AS is_eurasian, CUSTOMER.c_acctbal < 0 AND REGION.r_name = 'EUROPE' AS is_european_in_debt FROM TPCH.CUSTOMER CUSTOMER -LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey JOIN TPCH.REGION REGION diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql index d00c0f5ad..bd3d2266e 100644 --- a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -1,63 +1,63 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT co_name AS CO_NAME FROM MAIN.COUNTRIES WHERE NOT co_name LIKE '%C%' -), _T4 AS ( +), "_T4" AS ( SELECT pr_name AS PR_NAME, pr_release AS PR_RELEASE FROM MAIN.PRODUCTS WHERE pr_name = 'AmethystCopper-I' -), _S3 AS ( +), "_S3" AS ( SELECT ca_dt AS CA_DT FROM MAIN.CALENDAR -), _S15 AS ( +), "_S15" AS ( SELECT - _S7.CA_DT, - _T6.CO_NAME, + "_S7".CA_DT, + "_T6".CO_NAME, COUNT(*) AS N_ROWS - FROM _T1 _T6 - CROSS JOIN _T4 _T7 - JOIN _S3 _S7 - ON _S7.CA_DT < DATE_ADD(CAST(_T7.PR_RELEASE AS TIMESTAMP), 2, 'YEAR') - AND _S7.CA_DT >= _T7.PR_RELEASE + FROM "_T1" "_T6" + CROSS JOIN "_T4" "_T7" + JOIN "_S3" "_S7" + ON "_S7".CA_DT < DATE_ADD(CAST("_T7".PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + AND "_S7".CA_DT >= "_T7".PR_RELEASE JOIN MAIN.DEVICES DEVICES - ON _S7.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON "_S7".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') JOIN MAIN.PRODUCTS PRODUCTS ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.COUNTRIES COUNTRIES ON COUNTRIES.co_id = DEVICES.de_purchase_country_id - AND COUNTRIES.co_name = _T6.CO_NAME + AND COUNTRIES.co_name = "_T6".CO_NAME GROUP BY - _S7.CA_DT, - _T6.CO_NAME -), _S17 AS ( + "_S7".CA_DT, + "_T6".CO_NAME +), "_S17" AS ( SELECT - TRUNC(CAST(_S3.CA_DT AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, - _T3.CO_NAME, - SUM(_S15.N_ROWS) AS SUM_N_ROWS - FROM _T1 _T3 - CROSS JOIN _T4 _T4 - JOIN _S3 _S3 - ON _S3.CA_DT < DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR') - AND _S3.CA_DT >= _T4.PR_RELEASE - LEFT JOIN _S15 _S15 - ON _S15.CA_DT = _S3.CA_DT AND _S15.CO_NAME = _T3.CO_NAME + TRUNC(CAST("_S3".CA_DT AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + "_T3".CO_NAME, + SUM("_S15".N_ROWS) AS SUM_N_ROWS + FROM "_T1" "_T3" + CROSS JOIN "_T4" "_T4" + JOIN "_S3" "_S3" + ON "_S3".CA_DT < DATE_ADD(CAST("_T4".PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + AND "_S3".CA_DT >= "_T4".PR_RELEASE + LEFT JOIN "_S15" "_S15" + ON "_S15".CA_DT = "_S3".CA_DT AND "_S15".CO_NAME = "_T3".CO_NAME GROUP BY - TRUNC(CAST(_S3.CA_DT AS TIMESTAMP), 'YEAR'), - _T3.CO_NAME + TRUNC(CAST("_S3".CA_DT AS TIMESTAMP), 'YEAR'), + "_T3".CO_NAME ) SELECT - _T1.CO_NAME AS country_name, - _S17.START_OF_YEAR AS start_of_year, - NVL(_S17.SUM_N_ROWS, 0) AS n_purchases -FROM _T1 _T1 -LEFT JOIN _S17 _S17 - ON _S17.CO_NAME = _T1.CO_NAME + "_T1".CO_NAME AS country_name, + "_S17".START_OF_YEAR AS start_of_year, + NVL("_S17".SUM_N_ROWS, 0) AS n_purchases +FROM "_T1" "_T1" +LEFT JOIN "_S17" "_S17" + ON "_S17".CO_NAME = "_T1".CO_NAME ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/country_x_year_combos_oracle.sql b/tests/test_sql_refsols/country_x_year_combos_oracle.sql index da1b56b19..5a5048cf2 100644 --- a/tests/test_sql_refsols/country_x_year_combos_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_combos_oracle.sql @@ -1,14 +1,14 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT co_name AS CO_NAME FROM MAIN.COUNTRIES WHERE NOT co_name LIKE '%C%' -), _S5 AS ( +), "_S5" AS ( SELECT DISTINCT TRUNC(CAST(CALENDAR.ca_dt AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, - _T3.CO_NAME - FROM _T1 _T3 + "_T3".CO_NAME + FROM "_T1" "_T3" JOIN MAIN.PRODUCTS PRODUCTS ON PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.CALENDAR CALENDAR @@ -16,11 +16,11 @@ WITH _T1 AS ( AND CALENDAR.ca_dt >= PRODUCTS.pr_release ) SELECT - _T1.CO_NAME AS country_name, - _S5.START_OF_YEAR AS start_of_year -FROM _T1 _T1 -LEFT JOIN _S5 _S5 - ON _S5.CO_NAME = _T1.CO_NAME + "_T1".CO_NAME AS country_name, + "_S5".START_OF_YEAR AS start_of_year +FROM "_T1" "_T1" +LEFT JOIN "_S5" "_S5" + ON "_S5".CO_NAME = "_T1".CO_NAME ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql index 5a41ca09b..8b45ec8d1 100644 --- a/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql +++ b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT l_discount AS L_DISCOUNT, l_extendedprice AS L_EXTENDEDPRICE, @@ -6,35 +6,35 @@ WITH _S1 AS ( FROM TPCH.LINEITEM WHERE EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_shipmode = 'AIR' -), _T5 AS ( +), "_T5" AS ( SELECT ANY_VALUE(ORDERS.o_custkey) AS ANYTHING_O_CUSTKEY, ANY_VALUE(ORDERS.o_orderdate) AS ANYTHING_O_ORDERDATE, - SUM(_S1.L_EXTENDEDPRICE * ( - 1 - _S1.L_DISCOUNT + SUM("_S1".L_EXTENDEDPRICE * ( + 1 - "_S1".L_DISCOUNT )) AS SUM_R FROM TPCH.ORDERS ORDERS - LEFT JOIN _S1 _S1 - ON ORDERS.o_orderkey = _S1.L_ORDERKEY + LEFT JOIN "_S1" "_S1" + ON ORDERS.o_orderkey = "_S1".L_ORDERKEY WHERE EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1994 GROUP BY ORDERS.o_orderkey -), _T AS ( +), "_T" AS ( SELECT ANYTHING_O_CUSTKEY, ANYTHING_O_ORDERDATE, SUM_R, - LAG(NVL(SUM_R, 0), 1) OVER (PARTITION BY ANYTHING_O_CUSTKEY ORDER BY ANYTHING_O_ORDERDATE) AS _W - FROM _T5 -), _T1 AS ( + LAG(NVL(SUM_R, 0), 1) OVER (PARTITION BY ANYTHING_O_CUSTKEY ORDER BY ANYTHING_O_ORDERDATE) AS "_W" + FROM "_T5" +), "_T1" AS ( SELECT - _T.ANYTHING_O_CUSTKEY, + "_T".ANYTHING_O_CUSTKEY, CUSTOMER.c_name AS C_NAME, - NVL(_T.SUM_R, 0) - LAG(NVL(_T.SUM_R, 0), 1) OVER (PARTITION BY _T.ANYTHING_O_CUSTKEY ORDER BY _T.ANYTHING_O_ORDERDATE) AS REVENUE_DELTA + NVL("_T".SUM_R, 0) - LAG(NVL("_T".SUM_R, 0), 1) OVER (PARTITION BY "_T".ANYTHING_O_CUSTKEY ORDER BY "_T".ANYTHING_O_ORDERDATE) AS REVENUE_DELTA FROM TPCH.CUSTOMER CUSTOMER - JOIN _T _T - ON CUSTOMER.c_custkey = _T.ANYTHING_O_CUSTKEY AND NOT _T._W IS NULL + JOIN "_T" "_T" + ON CUSTOMER.c_custkey = "_T".ANYTHING_O_CUSTKEY AND NOT "_T"."_W" IS NULL WHERE CUSTOMER.c_mktsegment = 'AUTOMOBILE' ) @@ -45,7 +45,7 @@ SELECT THEN MIN(REVENUE_DELTA) ELSE MAX(REVENUE_DELTA) END AS largest_diff -FROM _T1 +FROM "_T1" GROUP BY ANYTHING_O_CUSTKEY ORDER BY diff --git a/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql index 3a0ecd689..d0718ad39 100644 --- a/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql +++ b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql @@ -1,25 +1,25 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT o_custkey AS O_CUSTKEY, o_totalprice AS O_TOTALPRICE, - ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate DESC, o_orderkey) AS _W + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate DESC, o_orderkey) AS "_W" FROM TPCH.ORDERS -), _S1 AS ( +), "_S1" AS ( SELECT O_CUSTKEY, SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE - FROM _T + FROM "_T" WHERE - _W <= 5 + "_W" <= 5 GROUP BY O_CUSTKEY ) SELECT CUSTOMER.c_name AS name, - NVL(_S1.SUM_O_TOTALPRICE, 0) AS total_recent_value + NVL("_S1".SUM_O_TOTALPRICE, 0) AS total_recent_value FROM TPCH.CUSTOMER CUSTOMER -JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ORDER BY 2 DESC NULLS LAST FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql index 6a81334e8..70c2918f3 100644 --- a/tests/test_sql_refsols/datetime_current_oracle.sql +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -7,4 +7,4 @@ SELECT 'SECOND' ) AS d3 FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/datetime_relative_oracle.sql b/tests/test_sql_refsols/datetime_relative_oracle.sql index 39826dfcc..69b0d668d 100644 --- a/tests/test_sql_refsols/datetime_relative_oracle.sql +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT o_orderdate AS O_ORDERDATE FROM TPCH.ORDERS @@ -26,6 +26,6 @@ SELECT TIME_STR_TO_TIME('2025-07-04 12:00:00') AS d4, TIME_STR_TO_TIME('2025-07-04 12:58:00') AS d5, TIME_STR_TO_TIME('2025-07-26 02:45:25') AS d6 -FROM _T0 +FROM "_T0" ORDER BY O_ORDERDATE NULLS FIRST diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql index e7db84617..438071438 100644 --- a/tests/test_sql_refsols/datetime_sampler_oracle.sql +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -1,60 +1,60 @@ SELECT - TIME_STR_TO_TIME('2025-07-04 12:58:45') AS _expr0, - TIME_STR_TO_TIME('2024-12-31 11:59:00') AS _expr1, - TO_DATE('2025-01-01', 'YYYY-MM-DD') AS _expr2, - TO_DATE('1999-03-14', 'YYYY-MM-DD') AS _expr3, - CURRENT_TIMESTAMP AS _expr4, - CURRENT_TIMESTAMP AS _expr5, - CURRENT_TIMESTAMP AS _expr6, - CURRENT_TIMESTAMP AS _expr7, - CURRENT_TIMESTAMP AS _expr8, - CURRENT_TIMESTAMP AS _expr9, - CURRENT_TIMESTAMP AS _expr10, - CURRENT_TIMESTAMP AS _expr11, - CURRENT_TIMESTAMP AS _expr12, - CURRENT_TIMESTAMP AS _expr13, - CURRENT_TIMESTAMP AS _expr14, - CURRENT_TIMESTAMP AS _expr15, - CURRENT_TIMESTAMP AS _expr16, - CURRENT_TIMESTAMP AS _expr17, - CURRENT_TIMESTAMP AS _expr18, - CAST(o_orderdate AS TIMESTAMP) AS _expr19, - TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND) AS _expr20, - DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 8, 'MINUTE'), 141, MONTH) AS _expr21, - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), SECOND), HOUR) AS _expr22, - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), SECOND), HOUR) AS _expr23, - DATE_ADD(DATE_SUB(CURRENT_TIMESTAMP, 96, HOUR), 15, 'YEAR') AS _expr24, + TIME_STR_TO_TIME('2025-07-04 12:58:45') AS "_expr0", + TIME_STR_TO_TIME('2024-12-31 11:59:00') AS "_expr1", + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS "_expr2", + TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr3", + CURRENT_TIMESTAMP AS "_expr4", + CURRENT_TIMESTAMP AS "_expr5", + CURRENT_TIMESTAMP AS "_expr6", + CURRENT_TIMESTAMP AS "_expr7", + CURRENT_TIMESTAMP AS "_expr8", + CURRENT_TIMESTAMP AS "_expr9", + CURRENT_TIMESTAMP AS "_expr10", + CURRENT_TIMESTAMP AS "_expr11", + CURRENT_TIMESTAMP AS "_expr12", + CURRENT_TIMESTAMP AS "_expr13", + CURRENT_TIMESTAMP AS "_expr14", + CURRENT_TIMESTAMP AS "_expr15", + CURRENT_TIMESTAMP AS "_expr16", + CURRENT_TIMESTAMP AS "_expr17", + CURRENT_TIMESTAMP AS "_expr18", + CAST(o_orderdate AS TIMESTAMP) AS "_expr19", + TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND) AS "_expr20", + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 8, 'MINUTE'), 141, MONTH) AS "_expr21", + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), SECOND), HOUR) AS "_expr22", + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), SECOND), HOUR) AS "_expr23", + DATE_ADD(DATE_SUB(CURRENT_TIMESTAMP, 96, HOUR), 15, 'YEAR') AS "_expr24", DATE_ADD( TIMESTAMP_TRUNC(DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 3, YEAR), MINUTE), 65, 'MONTH' - ) AS _expr25, - TRUNC(DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 56, HOUR), 'YEAR') AS _expr26, - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 63, DAY), MINUTE), SECOND) AS _expr27, - TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS _expr28, - DATE_ADD(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 312, HOUR), SECOND), 48, 'YEAR') AS _expr29, + ) AS "_expr25", + TRUNC(DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 56, HOUR), 'YEAR') AS "_expr26", + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 63, DAY), MINUTE), SECOND) AS "_expr27", + TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS "_expr28", + DATE_ADD(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 312, HOUR), SECOND), 48, 'YEAR') AS "_expr29", DATE_SUB( DATE_ADD(TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 75, 'DAY'), 'DAY'), 600, 'MINUTE'), 294, DAY - ) AS _expr30, - DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 480, 'MONTH'), 45, YEAR) AS _expr31, + ) AS "_expr30", + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 480, 'MONTH'), 45, YEAR) AS "_expr31", TIMESTAMP_TRUNC( TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 270, MINUTE), 34, SECOND), 'DAY'), SECOND - ) AS _expr32, - DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 213, 'SECOND') AS _expr33, + ) AS "_expr32", + DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 213, 'SECOND') AS "_expr33", DATE_ADD( DATE_ADD(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 13, 'MINUTE'), 28, 'YEAR'), 344, 'SECOND' - ) AS _expr34, - TRUNC(CURRENT_TIMESTAMP, 'DAY') AS _expr35, - TIME_STR_TO_TIME('2116-01-01 00:49:00') AS _expr36, - TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 'DAY') AS _expr37, - TRUNC(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 'YEAR') AS _expr38, - TIME_STR_TO_TIME('2025-07-01 00:22:00') AS _expr39, - TRUNC(CURRENT_TIMESTAMP, 'YEAR') AS _expr40, + ) AS "_expr34", + TRUNC(CURRENT_TIMESTAMP, 'DAY') AS "_expr35", + TIME_STR_TO_TIME('2116-01-01 00:49:00') AS "_expr36", + TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 'DAY') AS "_expr37", + TRUNC(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 'YEAR') AS "_expr38", + TIME_STR_TO_TIME('2025-07-01 00:22:00') AS "_expr39", + TRUNC(CURRENT_TIMESTAMP, 'YEAR') AS "_expr40", TRUNC( DATE_SUB( DATE_ADD(DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 82, 'SECOND'), 415, 'SECOND'), @@ -62,103 +62,103 @@ SELECT SECOND ), 'YEAR' - ) AS _expr41, - DATE_ADD(CURRENT_TIMESTAMP, 192, 'MONTH') AS _expr42, + ) AS "_expr41", + DATE_ADD(CURRENT_TIMESTAMP, 192, 'MONTH') AS "_expr42", DATE_ADD( TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), MINUTE), HOUR), 486, 'MINUTE' - ) AS _expr43, - DATE_SUB(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND), 50, HOUR) AS _expr44, + ) AS "_expr43", + DATE_SUB(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND), 50, HOUR) AS "_expr44", TIMESTAMP_TRUNC( DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 297, 'DAY'), 72, 'MONTH'), 92, MONTH), HOUR - ) AS _expr45, - TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 285, 'SECOND'), 'DAY') AS _expr46, - TO_DATE('1999-05-15', 'YYYY-MM-DD') AS _expr47, - DATE_SUB(TRUNC(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 1, 'HOUR'), 'MONTH'), 21, DAY) AS _expr48, - DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 212, 'MINUTE'), 368, 'YEAR') AS _expr49, - TO_DATE('2024-01-01', 'YYYY-MM-DD') AS _expr50, - TO_DATE('1999-03-14', 'YYYY-MM-DD') AS _expr51, + ) AS "_expr45", + TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 285, 'SECOND'), 'DAY') AS "_expr46", + TO_DATE('1999-05-15', 'YYYY-MM-DD') AS "_expr47", + DATE_SUB(TRUNC(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 1, 'HOUR'), 'MONTH'), 21, DAY) AS "_expr48", + DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 212, 'MINUTE'), 368, 'YEAR') AS "_expr49", + TO_DATE('2024-01-01', 'YYYY-MM-DD') AS "_expr50", + TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr51", DATE_ADD( TIMESTAMP_TRUNC(TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 60, HOUR), 'DAY'), MINUTE), 196, 'YEAR' - ) AS _expr52, + ) AS "_expr52", DATE_ADD( TIMESTAMP_TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 40, HOUR), 385, DAY), MINUTE), 29, 'HOUR' - ) AS _expr53, - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 405, 'DAY'), HOUR), MINUTE) AS _expr54, + ) AS "_expr53", + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 405, 'DAY'), HOUR), MINUTE) AS "_expr54", DATE_ADD( DATE_ADD(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), SECOND), 98, 'YEAR'), 96, 'MONTH' - ) AS _expr55, + ) AS "_expr55", DATE_ADD( TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, MINUTE), SECOND), 'DAY'), 78, 'SECOND' - ) AS _expr56, + ) AS "_expr56", DATE_ADD( DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 136, 'HOUR'), 104, 'MINUTE'), 104, MONTH), 312, 'DAY' - ) AS _expr57, - DATE_SUB(DATE_ADD(CURRENT_TIMESTAMP, 45, 'MONTH'), 135, SECOND) AS _expr58, - EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS _expr59, - 2025 AS _expr60, - 1999 AS _expr61, - EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS _expr62, - 6 AS _expr63, - 3 AS _expr64, - EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS _expr65, - 4 AS _expr66, - 4 AS _expr67, - EXTRACT(HOUR FROM CURRENT_TIMESTAMP) AS _expr68, - 0 AS _expr69, - 0 AS _expr70, - EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS _expr71, - 30 AS _expr72, - 0 AS _expr73, - EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS _expr74, - 45 AS _expr75, - 0 AS _expr76, - DATEDIFF(CURRENT_TIMESTAMP, CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS _expr77, - DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), CAST(o_orderdate AS DATETIME), YEAR) AS _expr78, - DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MONTH) AS _expr79, - DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), TIME_STR_TO_TIME('2006-05-01 12:00:00'), MONTH) AS _expr80, - DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, DAY) AS _expr81, - DATEDIFF(CURRENT_TIMESTAMP, CAST('1999-03-14' AS TIMESTAMP), DAY) AS _expr82, - DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, HOUR) AS _expr83, - DATEDIFF(CAST(o_orderdate AS DATETIME), TO_DATE('2005-06-30', 'YYYY-MM-DD'), HOUR) AS _expr84, - DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CURRENT_TIMESTAMP, MINUTE) AS _expr85, - DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), CAST(o_orderdate AS DATETIME), MINUTE) AS _expr86, - DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS _expr87, + ) AS "_expr57", + DATE_SUB(DATE_ADD(CURRENT_TIMESTAMP, 45, 'MONTH'), 135, SECOND) AS "_expr58", + EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS "_expr59", + 2025 AS "_expr60", + 1999 AS "_expr61", + EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS "_expr62", + 6 AS "_expr63", + 3 AS "_expr64", + EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS "_expr65", + 4 AS "_expr66", + 4 AS "_expr67", + EXTRACT(HOUR FROM CURRENT_TIMESTAMP) AS "_expr68", + 0 AS "_expr69", + 0 AS "_expr70", + EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS "_expr71", + 30 AS "_expr72", + 0 AS "_expr73", + EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS "_expr74", + 45 AS "_expr75", + 0 AS "_expr76", + DATEDIFF(CURRENT_TIMESTAMP, CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS "_expr77", + DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), CAST(o_orderdate AS DATETIME), YEAR) AS "_expr78", + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MONTH) AS "_expr79", + DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), TIME_STR_TO_TIME('2006-05-01 12:00:00'), MONTH) AS "_expr80", + DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, DAY) AS "_expr81", + DATEDIFF(CURRENT_TIMESTAMP, CAST('1999-03-14' AS TIMESTAMP), DAY) AS "_expr82", + DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, HOUR) AS "_expr83", + DATEDIFF(CAST(o_orderdate AS DATETIME), TO_DATE('2005-06-30', 'YYYY-MM-DD'), HOUR) AS "_expr84", + DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CURRENT_TIMESTAMP, MINUTE) AS "_expr85", + DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), CAST(o_orderdate AS DATETIME), MINUTE) AS "_expr86", + DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS "_expr87", DATEDIFF( CAST('2018-02-14 12:41:06' AS TIMESTAMP), TO_DATE('2005-06-30', 'YYYY-MM-DD'), SECOND - ) AS _expr88, - DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CAST(o_orderdate AS DATETIME), YEAR) AS _expr89, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS _expr90, - DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), CAST(o_orderdate AS DATETIME), MONTH) AS _expr91, + ) AS "_expr88", + DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CAST(o_orderdate AS DATETIME), YEAR) AS "_expr89", + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS "_expr90", + DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), CAST(o_orderdate AS DATETIME), MONTH) AS "_expr91", DATEDIFF( CAST('2018-02-14 12:41:06' AS TIMESTAMP), TIME_STR_TO_TIME('2019-07-04 11:30:00'), MONTH - ) AS _expr92, - DATEDIFF(CAST(o_orderdate AS DATETIME), CURRENT_TIMESTAMP, DAY) AS _expr93, - DATEDIFF(CURRENT_TIMESTAMP, TIME_STR_TO_TIME('2019-07-04 11:30:00'), DAY) AS _expr94, - DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2022-11-24', 'YYYY-MM-DD'), HOUR) AS _expr95, + ) AS "_expr92", + DATEDIFF(CAST(o_orderdate AS DATETIME), CURRENT_TIMESTAMP, DAY) AS "_expr93", + DATEDIFF(CURRENT_TIMESTAMP, TIME_STR_TO_TIME('2019-07-04 11:30:00'), DAY) AS "_expr94", + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2022-11-24', 'YYYY-MM-DD'), HOUR) AS "_expr95", DATEDIFF( TIME_STR_TO_TIME('2020-12-31 00:31:06'), CAST('2018-02-14 12:41:06' AS TIMESTAMP), HOUR - ) AS _expr96, - DATEDIFF(TIME_STR_TO_TIME('2020-12-31 00:31:06'), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MINUTE) AS _expr97, - DATEDIFF(CAST('2018-02-14 12:41:06' AS TIMESTAMP), CURRENT_TIMESTAMP, MINUTE) AS _expr98, - DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), CURRENT_TIMESTAMP, SECOND) AS _expr99, - DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS _expr100 + ) AS "_expr96", + DATEDIFF(TIME_STR_TO_TIME('2020-12-31 00:31:06'), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MINUTE) AS "_expr97", + DATEDIFF(CAST('2018-02-14 12:41:06' AS TIMESTAMP), CURRENT_TIMESTAMP, MINUTE) AS "_expr98", + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), CURRENT_TIMESTAMP, SECOND) AS "_expr99", + DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS "_expr100" FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/deep_best_analysis_oracle.sql b/tests/test_sql_refsols/deep_best_analysis_oracle.sql index e8d0e5b2a..7fbb26eae 100644 --- a/tests/test_sql_refsols/deep_best_analysis_oracle.sql +++ b/tests/test_sql_refsols/deep_best_analysis_oracle.sql @@ -1,53 +1,53 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT c_acctbal AS C_ACCTBAL, c_custkey AS C_CUSTKEY, c_nationkey AS C_NATIONKEY FROM TPCH.CUSTOMER -), _T AS ( +), "_T" AS ( SELECT C_ACCTBAL, C_CUSTKEY, C_NATIONKEY, - ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS _W - FROM _T2 -), _S4 AS ( + ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS "_W" + FROM "_T2" +), "_S4" AS ( SELECT n_nationkey AS N_NATIONKEY, n_regionkey AS N_REGIONKEY FROM TPCH.NATION -), _T_2 AS ( +), "_T_2" AS ( SELECT - _S5.C_ACCTBAL, - _S4.N_NATIONKEY, - _S4.N_REGIONKEY, - ROW_NUMBER() OVER (PARTITION BY _S4.N_REGIONKEY ORDER BY _S5.C_ACCTBAL DESC, _S5.C_CUSTKEY) AS _W - FROM _S4 _S4 - JOIN _T2 _S5 - ON _S4.N_NATIONKEY = _S5.C_NATIONKEY -), _S7 AS ( + "_S5".C_ACCTBAL, + "_S4".N_NATIONKEY, + "_S4".N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY "_S4".N_REGIONKEY ORDER BY "_S5".C_ACCTBAL DESC, "_S5".C_CUSTKEY) AS "_W" + FROM "_S4" "_S4" + JOIN "_T2" "_S5" + ON "_S4".N_NATIONKEY = "_S5".C_NATIONKEY +), "_S7" AS ( SELECT C_ACCTBAL, N_NATIONKEY, N_REGIONKEY - FROM _T_2 + FROM "_T_2" WHERE - _W = 1 -), _T_3 AS ( + "_W" = 1 +), "_T_3" AS ( SELECT - _S8.N_NATIONKEY, - _S8.N_REGIONKEY, + "_S8".N_NATIONKEY, + "_S8".N_REGIONKEY, PARTSUPP.ps_availqty AS PS_AVAILQTY, PARTSUPP.ps_partkey AS PS_PARTKEY, SUPPLIER.s_nationkey AS S_NATIONKEY, SUPPLIER.s_suppkey AS S_SUPPKEY, - ROW_NUMBER() OVER (PARTITION BY _S8.N_REGIONKEY ORDER BY PARTSUPP.ps_availqty DESC, PARTSUPP.ps_partkey) AS _W - FROM _S4 _S8 + ROW_NUMBER() OVER (PARTITION BY "_S8".N_REGIONKEY ORDER BY PARTSUPP.ps_availqty DESC, PARTSUPP.ps_partkey) AS "_W" + FROM "_S4" "_S8" JOIN TPCH.SUPPLIER SUPPLIER - ON SUPPLIER.s_nationkey = _S8.N_NATIONKEY + ON SUPPLIER.s_nationkey = "_S8".N_NATIONKEY JOIN TPCH.PARTSUPP PARTSUPP ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey -), _T_4 AS ( +), "_T_4" AS ( SELECT N_NATIONKEY, N_REGIONKEY, @@ -55,55 +55,56 @@ WITH _T2 AS ( PS_PARTKEY, S_NATIONKEY, S_SUPPKEY, - ROW_NUMBER() OVER (PARTITION BY N_REGIONKEY ORDER BY PS_AVAILQTY DESC, S_SUPPKEY) AS _W - FROM _T_3 + ROW_NUMBER() OVER (PARTITION BY N_REGIONKEY ORDER BY PS_AVAILQTY DESC, S_SUPPKEY) AS "_W" + FROM "_T_3" WHERE - _W = 1 -), _S13 AS ( + "_W" = 1 +), "_S13" AS ( SELECT N_NATIONKEY, N_REGIONKEY, PS_AVAILQTY, PS_PARTKEY, S_SUPPKEY - FROM _T_4 + FROM "_T_4" WHERE - N_NATIONKEY = S_NATIONKEY AND _W = 1 -), _T_5 AS ( + N_NATIONKEY = S_NATIONKEY AND "_W" = 1 +), "_T_5" AS ( SELECT C_CUSTKEY, C_NATIONKEY, - ROW_NUMBER() OVER (ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS _W - FROM _T2 -), _S15 AS ( + ROW_NUMBER() OVER (ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS "_W" + FROM "_T2" +), "_S15" AS ( SELECT C_CUSTKEY, C_NATIONKEY - FROM _T_5 + FROM "_T_5" WHERE - _W = 1 + "_W" = 1 ) SELECT REGION.r_name, NATION.n_name, - _T.C_CUSTKEY AS c_key, - _T.C_ACCTBAL AS c_bal, - _S7.C_ACCTBAL AS cr_bal, - _S13.S_SUPPKEY AS s_key, - _S13.PS_PARTKEY AS p_key, - _S13.PS_AVAILQTY AS p_qty, - _S15.C_CUSTKEY AS cg_key + "_T".C_CUSTKEY AS c_key, + "_T".C_ACCTBAL AS c_bal, + "_S7".C_ACCTBAL AS cr_bal, + "_S13".S_SUPPKEY AS s_key, + "_S13".PS_PARTKEY AS p_key, + "_S13".PS_AVAILQTY AS p_qty, + "_S15".C_CUSTKEY AS cg_key FROM TPCH.REGION REGION JOIN TPCH.NATION NATION ON NATION.n_regionkey = REGION.r_regionkey -JOIN _T _T - ON NATION.n_nationkey = _T.C_NATIONKEY AND _T._W = 1 -LEFT JOIN _S7 _S7 - ON NATION.n_nationkey = _S7.N_NATIONKEY AND REGION.r_regionkey = _S7.N_REGIONKEY -LEFT JOIN _S13 _S13 - ON NATION.n_nationkey = _S13.N_NATIONKEY AND REGION.r_regionkey = _S13.N_REGIONKEY -LEFT JOIN _S15 _S15 - ON NATION.n_nationkey = _S15.C_NATIONKEY +JOIN "_T" "_T" + ON NATION.n_nationkey = "_T".C_NATIONKEY AND "_T"."_W" = 1 +LEFT JOIN "_S7" "_S7" + ON NATION.n_nationkey = "_S7".N_NATIONKEY AND REGION.r_regionkey = "_S7".N_REGIONKEY +LEFT JOIN "_S13" "_S13" + ON NATION.n_nationkey = "_S13".N_NATIONKEY + AND REGION.r_regionkey = "_S13".N_REGIONKEY +LEFT JOIN "_S15" "_S15" + ON NATION.n_nationkey = "_S15".C_NATIONKEY ORDER BY 2 NULLS FIRST FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen11_oracle.sql b/tests/test_sql_refsols/defog_academic_gen11_oracle.sql index b4fd8b3e6..1fe24b015 100644 --- a/tests/test_sql_refsols/defog_academic_gen11_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen11_oracle.sql @@ -1,13 +1,13 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.PUBLICATION -), _S1 AS ( +), "_S1" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.AUTHOR ) SELECT - _S0.N_ROWS / NULLIF(_S1.N_ROWS, 0) AS publication_to_author_ratio -FROM _S0 _S0 -CROSS JOIN _S1 _S1 + "_S0".N_ROWS / NULLIF("_S1".N_ROWS, 0) AS publication_to_author_ratio +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/defog_academic_gen13_oracle.sql b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql index eb8c255e8..57918f9b6 100644 --- a/tests/test_sql_refsols/defog_academic_gen13_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql @@ -1,11 +1,11 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT did AS DID, COUNT(*) AS N_ROWS FROM MAIN.DOMAIN_PUBLICATION GROUP BY did -), _S3 AS ( +), "_S3" AS ( SELECT did AS DID, COUNT(*) AS N_ROWS @@ -15,9 +15,9 @@ WITH _S1 AS ( ) SELECT DOMAIN.did AS domain_id, - NVL(_S1.N_ROWS, 0) / NULLIF(_S3.N_ROWS, 0) AS ratio + NVL("_S1".N_ROWS, 0) / NULLIF("_S3".N_ROWS, 0) AS ratio FROM MAIN.DOMAIN DOMAIN -LEFT JOIN _S1 _S1 - ON DOMAIN.did = _S1.DID -LEFT JOIN _S3 _S3 - ON DOMAIN.did = _S3.DID +LEFT JOIN "_S1" "_S1" + ON DOMAIN.did = "_S1".DID +LEFT JOIN "_S3" "_S3" + ON DOMAIN.did = "_S3".DID diff --git a/tests/test_sql_refsols/defog_academic_gen15_oracle.sql b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql index d9a01a6ac..70ce5a3eb 100644 --- a/tests/test_sql_refsols/defog_academic_gen15_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT ANY_VALUE(ORGANIZATION.continent) AS ANYTHING_CONTINENT, COUNT(AUTHOR.oid) AS COUNT_OID @@ -11,7 +11,7 @@ WITH _T1 AS ( SELECT ANYTHING_CONTINENT AS continent, NVL(SUM(COUNT_OID), 0) / COUNT(*) AS ratio -FROM _T1 +FROM "_T1" GROUP BY ANYTHING_CONTINENT ORDER BY diff --git a/tests/test_sql_refsols/defog_academic_gen16_oracle.sql b/tests/test_sql_refsols/defog_academic_gen16_oracle.sql index 6fd7a3f5e..bda7a8a4e 100644 --- a/tests/test_sql_refsols/defog_academic_gen16_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen16_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT WRITES.aid AS AID, COUNT(DISTINCT PUBLICATION.pid) AS NDISTINCT_PID @@ -10,10 +10,10 @@ WITH _S3 AS ( ) SELECT AUTHOR.name, - _S3.NDISTINCT_PID AS count_publication + "_S3".NDISTINCT_PID AS count_publication FROM MAIN.AUTHOR AUTHOR -JOIN _S3 _S3 - ON AUTHOR.aid = _S3.AID +JOIN "_S3" "_S3" + ON AUTHOR.aid = "_S3".AID ORDER BY 2 DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql index fef7d2f38..d88251faf 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT jid AS JID, COUNT(*) AS N_ROWS @@ -9,9 +9,9 @@ WITH _S1 AS ( SELECT JOURNAL.name, JOURNAL.jid AS journal_id, - NVL(_S1.N_ROWS, 0) AS num_publications + NVL("_S1".N_ROWS, 0) AS num_publications FROM MAIN.JOURNAL JOURNAL -LEFT JOIN _S1 _S1 - ON JOURNAL.jid = _S1.JID +LEFT JOIN "_S1" "_S1" + ON JOURNAL.jid = "_S1".JID ORDER BY 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen1_oracle.sql b/tests/test_sql_refsols/defog_academic_gen1_oracle.sql index 1b959360c..0219ee3c3 100644 --- a/tests/test_sql_refsols/defog_academic_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen1_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT WRITES.aid AS AID, COUNT(DISTINCT DOMAIN_PUBLICATION.did) AS NDISTINCT_DID @@ -14,5 +14,5 @@ WITH _T0 AS ( SELECT AUTHOR.name FROM MAIN.AUTHOR AUTHOR -JOIN _T0 _T0 - ON AUTHOR.aid = _T0.AID AND _T0.NDISTINCT_DID = 2 +JOIN "_T0" "_T0" + ON AUTHOR.aid = "_T0".AID AND "_T0".NDISTINCT_DID = 2 diff --git a/tests/test_sql_refsols/defog_academic_gen22_oracle.sql b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql index 033908e18..c9e088c13 100644 --- a/tests/test_sql_refsols/defog_academic_gen22_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT aid AS AID, did AS DID @@ -8,9 +8,9 @@ SELECT AUTHOR.name, AUTHOR.aid AS author_id FROM MAIN.AUTHOR AUTHOR -JOIN _S0 _S0 - ON AUTHOR.aid = _S0.AID -JOIN _S0 _S1 - ON _S0.DID = _S1.DID +JOIN "_S0" "_S0" + ON AUTHOR.aid = "_S0".AID +JOIN "_S0" "_S1" + ON "_S0".DID = "_S1".DID JOIN MAIN.AUTHOR AUTHOR_2 - ON AUTHOR_2.aid = _S1.AID AND LOWER(AUTHOR_2.name) LIKE '%martin%' + ON AUTHOR_2.aid = "_S1".AID AND LOWER(AUTHOR_2.name) LIKE '%martin%' diff --git a/tests/test_sql_refsols/defog_academic_gen24_oracle.sql b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql index 271916517..aa489d190 100644 --- a/tests/test_sql_refsols/defog_academic_gen24_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql @@ -1,4 +1,4 @@ -WITH _S7 AS ( +WITH "_S7" AS ( SELECT DOMAIN_CONFERENCE.cid AS CID, WRITES.pid AS PID @@ -13,7 +13,7 @@ WITH _S7 AS ( SELECT PUBLICATION.title FROM MAIN.PUBLICATION PUBLICATION -JOIN _S7 _S7 - ON PUBLICATION.cid = _S7.CID AND PUBLICATION.pid = _S7.PID +JOIN "_S7" "_S7" + ON PUBLICATION.cid = "_S7".CID AND PUBLICATION.pid = "_S7".PID WHERE PUBLICATION.year = 2020 diff --git a/tests/test_sql_refsols/defog_academic_gen2_oracle.sql b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql index 064538245..4c017f8c4 100644 --- a/tests/test_sql_refsols/defog_academic_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT WRITES.aid AS AID, SUM(PUBLICATION.citation_num) AS SUM_CITATION_NUM @@ -10,7 +10,7 @@ WITH _S3 AS ( ) SELECT AUTHOR.name, - NVL(_S3.SUM_CITATION_NUM, 0) AS total_citations + NVL("_S3".SUM_CITATION_NUM, 0) AS total_citations FROM MAIN.AUTHOR AUTHOR -JOIN _S3 _S3 - ON AUTHOR.aid = _S3.AID +JOIN "_S3" "_S3" + ON AUTHOR.aid = "_S3".AID diff --git a/tests/test_sql_refsols/defog_academic_gen3_oracle.sql b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql index c60cca3b1..b6f4e060f 100644 --- a/tests/test_sql_refsols/defog_academic_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql @@ -1,6 +1,6 @@ SELECT year, - COUNT(*) AS _expr0 + COUNT(*) AS "_expr0" FROM MAIN.PUBLICATION GROUP BY year diff --git a/tests/test_sql_refsols/defog_academic_gen4_oracle.sql b/tests/test_sql_refsols/defog_academic_gen4_oracle.sql index 3cc9a35e2..45874c5c8 100644 --- a/tests/test_sql_refsols/defog_academic_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT DOMAIN_PUBLICATION.did AS DID, AVG(PUBLICATION.reference_num) AS AVG_REFERENCE_NUM @@ -10,7 +10,7 @@ WITH _S3 AS ( ) SELECT DOMAIN.name, - _S3.AVG_REFERENCE_NUM AS average_references + "_S3".AVG_REFERENCE_NUM AS average_references FROM MAIN.DOMAIN DOMAIN -LEFT JOIN _S3 _S3 - ON DOMAIN.did = _S3.DID +LEFT JOIN "_S3" "_S3" + ON DOMAIN.did = "_S3".DID diff --git a/tests/test_sql_refsols/defog_academic_gen7_oracle.sql b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql index 773797334..1bc5f4996 100644 --- a/tests/test_sql_refsols/defog_academic_gen7_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT did AS DID, COUNT(DISTINCT aid) AS NDISTINCT_AID @@ -8,10 +8,10 @@ WITH _S1 AS ( ) SELECT DOMAIN.name, - NVL(_S1.NDISTINCT_AID, 0) AS author_count + NVL("_S1".NDISTINCT_AID, 0) AS author_count FROM MAIN.DOMAIN DOMAIN -LEFT JOIN _S1 _S1 - ON DOMAIN.did = _S1.DID +LEFT JOIN "_S1" "_S1" + ON DOMAIN.did = "_S1".DID ORDER BY 2 DESC NULLS LAST, 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_broker_adv10_oracle.sql b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql index 0d4d5f38e..035e32558 100644 --- a/tests/test_sql_refsols/defog_broker_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) AS MONTH_SBTXDATETIME, EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) AS YEAR_SBTXDATETIME, @@ -11,14 +11,14 @@ WITH _S1 AS ( sbtxcustid ) SELECT - SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustid AS "_id", SBCUSTOMER.sbcustname AS name, - NVL(_S1.N_ROWS, 0) AS num_transactions + NVL("_S1".N_ROWS, 0) AS num_transactions FROM MAIN.SBCUSTOMER SBCUSTOMER -LEFT JOIN _S1 _S1 - ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID - AND _S1.MONTH_SBTXDATETIME = EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) - AND _S1.YEAR_SBTXDATETIME = EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) +LEFT JOIN "_S1" "_S1" + ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID + AND "_S1".MONTH_SBTXDATETIME = EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) + AND "_S1".YEAR_SBTXDATETIME = EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) ORDER BY 3 DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql index 1759f243b..85fd51da5 100644 --- a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbdptickerid AS SBDPTICKERID, COUNT(sbdpclose) AS COUNT_SBDPCLOSE, @@ -11,9 +11,9 @@ WITH _S1 AS ( ) SELECT SBTICKER.sbtickertype AS ticker_type, - SUM(_S1.SUM_SBDPCLOSE) / SUM(_S1.COUNT_SBDPCLOSE) AS ACP + SUM("_S1".SUM_SBDPCLOSE) / SUM("_S1".COUNT_SBDPCLOSE) AS ACP FROM MAIN.SBTICKER SBTICKER -JOIN _S1 _S1 - ON SBTICKER.sbtickerid = _S1.SBDPTICKERID +JOIN "_S1" "_S1" + ON SBTICKER.sbtickerid = "_S1".SBDPTICKERID GROUP BY SBTICKER.sbtickertype diff --git a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql index 4260360a9..7498070df 100644 --- a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxtickerid AS SBTXTICKERID, SUM(sbtxtax + sbtxcommission) AS SUM_EXPR, @@ -13,11 +13,11 @@ SELECT SBTICKER.sbtickersymbol AS symbol, ( 100.0 * ( - NVL(_S1.SUM_SBTXAMOUNT, 0) - NVL(_S1.SUM_EXPR, 0) + NVL("_S1".SUM_SBTXAMOUNT, 0) - NVL("_S1".SUM_EXPR, 0) ) - ) / NVL(_S1.SUM_SBTXAMOUNT, 0) AS SPM + ) / NVL("_S1".SUM_SBTXAMOUNT, 0) AS SPM FROM MAIN.SBTICKER SBTICKER -JOIN _S1 _S1 - ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +JOIN "_S1" "_S1" + ON SBTICKER.sbtickerid = "_S1".SBTXTICKERID ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_broker_adv1_oracle.sql b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql index c24b8cb5d..f63422da4 100644 --- a/tests/test_sql_refsols/defog_broker_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxcustid AS SBTXCUSTID, SUM(sbtxamount) AS SUM_SBTXAMOUNT @@ -8,10 +8,10 @@ WITH _S1 AS ( ) SELECT SBCUSTOMER.sbcustname AS name, - NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount + NVL("_S1".SUM_SBTXAMOUNT, 0) AS total_amount FROM MAIN.SBCUSTOMER SBCUSTOMER -LEFT JOIN _S1 _S1 - ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +LEFT JOIN "_S1" "_S1" + ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID ORDER BY 2 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql index 2f4a3b8ff..bdc8b2673 100644 --- a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxtickerid AS SBTXTICKERID, COUNT(*) AS N_ROWS @@ -11,10 +11,10 @@ WITH _S1 AS ( ) SELECT SBTICKER.sbtickersymbol AS symbol, - NVL(_S1.N_ROWS, 0) AS tx_count + NVL("_S1".N_ROWS, 0) AS tx_count FROM MAIN.SBTICKER SBTICKER -LEFT JOIN _S1 _S1 - ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +LEFT JOIN "_S1" "_S1" + ON SBTICKER.sbtickerid = "_S1".SBTXTICKERID ORDER BY 2 DESC NULLS LAST FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv3_oracle.sql b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql index 7cb8a51f8..bc734142c 100644 --- a/tests/test_sql_refsols/defog_broker_adv3_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT sbtxcustid AS SBTXCUSTID, COUNT(*) AS N_ROWS, @@ -10,10 +10,10 @@ WITH _T1 AS ( SELECT SBCUSTOMER.sbcustname AS name, ( - 100.0 * NVL(_T1.SUM_EXPR, 0) - ) / _T1.N_ROWS AS success_rate + 100.0 * NVL("_T1".SUM_EXPR, 0) + ) / "_T1".N_ROWS AS success_rate FROM MAIN.SBCUSTOMER SBCUSTOMER -JOIN _T1 _T1 - ON SBCUSTOMER.sbcustid = _T1.SBTXCUSTID AND _T1.N_ROWS >= 5 +JOIN "_T1" "_T1" + ON SBCUSTOMER.sbcustid = "_T1".SBTXCUSTID AND "_T1".N_ROWS >= 5 ORDER BY 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_broker_adv4_oracle.sql b/tests/test_sql_refsols/defog_broker_adv4_oracle.sql index ddeb351a6..e082d47ff 100644 --- a/tests/test_sql_refsols/defog_broker_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbdptickerid AS SBDPTICKERID, MAX(sbdphigh) AS MAX_SBDPHIGH, @@ -12,10 +12,10 @@ WITH _S1 AS ( ) SELECT SBTICKER.sbtickersymbol AS symbol, - _S1.MAX_SBDPHIGH - _S1.MIN_SBDPLOW AS price_change + "_S1".MAX_SBDPHIGH - "_S1".MIN_SBDPLOW AS price_change FROM MAIN.SBTICKER SBTICKER -LEFT JOIN _S1 _S1 - ON SBTICKER.sbtickerid = _S1.SBDPTICKERID +LEFT JOIN "_S1" "_S1" + ON SBTICKER.sbtickerid = "_S1".SBDPTICKERID ORDER BY 2 DESC NULLS LAST FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql index 377b1212f..dc54073de 100644 --- a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT LISTAGG( '-', @@ -30,19 +30,19 @@ WITH _S0 AS ( END ), sbdptickerid -), _T0 AS ( +), "_T0" AS ( SELECT - _S0.MONTH, + "_S0".MONTH, SBTICKER.sbtickersymbol AS SBTICKERSYMBOL, - MAX(_S0.MAX_SBDPHIGH) AS MAX_MAX_SBDPHIGH, - MIN(_S0.MIN_SBDPLOW) AS MIN_MIN_SBDPLOW, - SUM(_S0.COUNT_SBDPCLOSE) AS SUM_COUNT_SBDPCLOSE, - SUM(_S0.SUM_SBDPCLOSE) AS SUM_SUM_SBDPCLOSE - FROM _S0 _S0 + MAX("_S0".MAX_SBDPHIGH) AS MAX_MAX_SBDPHIGH, + MIN("_S0".MIN_SBDPLOW) AS MIN_MIN_SBDPLOW, + SUM("_S0".COUNT_SBDPCLOSE) AS SUM_COUNT_SBDPCLOSE, + SUM("_S0".SUM_SBDPCLOSE) AS SUM_SUM_SBDPCLOSE + FROM "_S0" "_S0" JOIN MAIN.SBTICKER SBTICKER - ON SBTICKER.sbtickerid = _S0.SBDPTICKERID + ON SBTICKER.sbtickerid = "_S0".SBDPTICKERID GROUP BY - _S0.MONTH, + "_S0".MONTH, SBTICKER.sbtickersymbol ) SELECT @@ -56,4 +56,4 @@ SELECT SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE ) - LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) ) / LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) AS momc -FROM _T0 +FROM "_T0" diff --git a/tests/test_sql_refsols/defog_broker_adv6_oracle.sql b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql index 439f89fb9..a1ed99779 100644 --- a/tests/test_sql_refsols/defog_broker_adv6_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxcustid AS SBTXCUSTID, COUNT(*) AS N_ROWS, @@ -9,9 +9,9 @@ WITH _S1 AS ( ) SELECT SBCUSTOMER.sbcustname AS name, - _S1.N_ROWS AS num_tx, - NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount, - RANK() OVER (ORDER BY NVL(_S1.SUM_SBTXAMOUNT, 0) DESC) AS cust_rank + "_S1".N_ROWS AS num_tx, + NVL("_S1".SUM_SBTXAMOUNT, 0) AS total_amount, + RANK() OVER (ORDER BY NVL("_S1".SUM_SBTXAMOUNT, 0) DESC) AS cust_rank FROM MAIN.SBCUSTOMER SBCUSTOMER -JOIN _S1 _S1 - ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +JOIN "_S1" "_S1" + ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql index 68fecfd7b..fd522b87f 100644 --- a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -1,4 +1,4 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT LISTAGG( '-', @@ -28,7 +28,7 @@ WITH _S2 AS ( )) END ) -), _S3 AS ( +), "_S3" AS ( SELECT LISTAGG( '-', @@ -70,9 +70,9 @@ WITH _S2 AS ( ) ) SELECT - _S2.MONTH AS month, - _S2.N_ROWS AS customer_signups, - _S3.AVG_SBTXAMOUNT AS avg_tx_amount -FROM _S2 _S2 -LEFT JOIN _S3 _S3 - ON _S2.MONTH = _S3.MONTH + "_S2".MONTH AS month, + "_S2".N_ROWS AS customer_signups, + "_S3".AVG_SBTXAMOUNT AS avg_tx_amount +FROM "_S2" "_S2" +LEFT JOIN "_S3" "_S3" + ON "_S2".MONTH = "_S3".MONTH diff --git a/tests/test_sql_refsols/defog_broker_basic10_oracle.sql b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql index 28dcbe3a8..2adfc549e 100644 --- a/tests/test_sql_refsols/defog_broker_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql @@ -1,5 +1,5 @@ SELECT - SBTICKER.sbtickerid AS _id, + SBTICKER.sbtickerid AS "_id", SBTICKER.sbtickersymbol AS symbol FROM MAIN.SBTICKER SBTICKER JOIN MAIN.SBDAILYPRICE SBDAILYPRICE diff --git a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql index ef3b58c45..9e5c7998b 100644 --- a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxcustid AS SBTXCUSTID, COUNT(*) AS N_ROWS, @@ -11,10 +11,10 @@ WITH _S1 AS ( ) SELECT SBCUSTOMER.sbcustcountry AS country, - NVL(SUM(_S1.N_ROWS), 0) AS num_transactions, - NVL(SUM(_S1.SUM_SBTXAMOUNT), 0) AS total_amount + NVL(SUM("_S1".N_ROWS), 0) AS num_transactions, + NVL(SUM("_S1".SUM_SBTXAMOUNT), 0) AS total_amount FROM MAIN.SBCUSTOMER SBCUSTOMER -LEFT JOIN _S1 _S1 - ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +LEFT JOIN "_S1" "_S1" + ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID GROUP BY SBCUSTOMER.sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_basic3_oracle.sql b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql index 43686a8c6..8090f7ace 100644 --- a/tests/test_sql_refsols/defog_broker_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxtickerid AS SBTXTICKERID, COUNT(*) AS N_ROWS, @@ -9,11 +9,11 @@ WITH _S1 AS ( ) SELECT SBTICKER.sbtickersymbol AS symbol, - NVL(_S1.N_ROWS, 0) AS num_transactions, - NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount + NVL("_S1".N_ROWS, 0) AS num_transactions, + NVL("_S1".SUM_SBTXAMOUNT, 0) AS total_amount FROM MAIN.SBTICKER SBTICKER -LEFT JOIN _S1 _S1 - ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +LEFT JOIN "_S1" "_S1" + ON SBTICKER.sbtickerid = "_S1".SBTXTICKERID ORDER BY 3 DESC NULLS LAST FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic4_oracle.sql b/tests/test_sql_refsols/defog_broker_basic4_oracle.sql index f393e80a3..d301c4449 100644 --- a/tests/test_sql_refsols/defog_broker_basic4_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT sbtxcustid AS SBTXCUSTID, sbtxtickerid AS SBTXTICKERID, @@ -7,28 +7,28 @@ WITH _S0 AS ( GROUP BY sbtxcustid, sbtxtickerid -), _S2 AS ( +), "_S2" AS ( SELECT SBTICKER.sbtickertype AS SBTICKERTYPE, - _S0.SBTXCUSTID, - SUM(_S0.N_ROWS) AS SUM_N_ROWS - FROM _S0 _S0 + "_S0".SBTXCUSTID, + SUM("_S0".N_ROWS) AS SUM_N_ROWS + FROM "_S0" "_S0" JOIN MAIN.SBTICKER SBTICKER - ON SBTICKER.sbtickerid = _S0.SBTXTICKERID + ON SBTICKER.sbtickerid = "_S0".SBTXTICKERID GROUP BY SBTICKER.sbtickertype, - _S0.SBTXCUSTID + "_S0".SBTXCUSTID ) SELECT SBCUSTOMER.sbcuststate AS state, - _S2.SBTICKERTYPE AS ticker_type, - SUM(_S2.SUM_N_ROWS) AS num_transactions -FROM _S2 _S2 + "_S2".SBTICKERTYPE AS ticker_type, + SUM("_S2".SUM_N_ROWS) AS num_transactions +FROM "_S2" "_S2" JOIN MAIN.SBCUSTOMER SBCUSTOMER - ON SBCUSTOMER.sbcustid = _S2.SBTXCUSTID + ON SBCUSTOMER.sbcustid = "_S2".SBTXCUSTID GROUP BY SBCUSTOMER.sbcuststate, - _S2.SBTICKERTYPE + "_S2".SBTICKERTYPE ORDER BY 3 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic5_oracle.sql b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql index aae7e245d..a654464c9 100644 --- a/tests/test_sql_refsols/defog_broker_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql @@ -1,5 +1,5 @@ SELECT - SBCUSTOMER.sbcustid AS _id + SBCUSTOMER.sbcustid AS "_id" FROM MAIN.SBCUSTOMER SBCUSTOMER JOIN MAIN.SBTRANSACTION SBTRANSACTION ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid AND SBTRANSACTION.sbtxtype = 'buy' diff --git a/tests/test_sql_refsols/defog_broker_basic6_oracle.sql b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql index 40f0b5e9d..d98f14363 100644 --- a/tests/test_sql_refsols/defog_broker_basic6_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql @@ -1,5 +1,5 @@ SELECT - SBTICKER.sbtickerid AS _id + SBTICKER.sbtickerid AS "_id" FROM MAIN.SBTICKER SBTICKER JOIN MAIN.SBDAILYPRICE SBDAILYPRICE ON SBDAILYPRICE.sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') diff --git a/tests/test_sql_refsols/defog_broker_basic9_oracle.sql b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql index 7467ecb95..626c335e8 100644 --- a/tests/test_sql_refsols/defog_broker_basic9_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql @@ -1,5 +1,5 @@ SELECT - SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustid AS "_id", SBCUSTOMER.sbcustname AS name FROM MAIN.SBCUSTOMER SBCUSTOMER JOIN MAIN.SBTRANSACTION SBTRANSACTION diff --git a/tests/test_sql_refsols/defog_broker_gen3_oracle.sql b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql index ff2528e48..293d545ec 100644 --- a/tests/test_sql_refsols/defog_broker_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxcustid AS SBTXCUSTID, MIN(sbtxdatetime) AS MIN_SBTXDATETIME @@ -9,10 +9,10 @@ WITH _S1 AS ( SELECT SBCUSTOMER.sbcustid AS cust_id, DATEDIFF( - CAST(_S1.MIN_SBTXDATETIME AS DATETIME), + CAST("_S1".MIN_SBTXDATETIME AS DATETIME), CAST(SBCUSTOMER.sbcustjoindate AS DATETIME), SECOND ) / 86400.0 AS DaysFromJoinToFirstTransaction FROM MAIN.SBCUSTOMER SBCUSTOMER -JOIN _S1 _S1 - ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +JOIN "_S1" "_S1" + ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql index 5ecfd9079..79a50e2cc 100644 --- a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sbtxcustid AS SBTXCUSTID, COUNT(*) AS N_ROWS @@ -10,12 +10,12 @@ WITH _S1 AS ( sbtxcustid ) SELECT - SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustid AS "_id", SBCUSTOMER.sbcustname AS name, - NVL(_S1.N_ROWS, 0) AS num_tx + NVL("_S1".N_ROWS, 0) AS num_tx FROM MAIN.SBCUSTOMER SBCUSTOMER -LEFT JOIN _S1 _S1 - ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +LEFT JOIN "_S1" "_S1" + ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID ORDER BY 3 DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql index e4c217050..f7fe19653 100644 --- a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT sale_id AS SALE_ID, MAX(payment_date) AS MAX_PAYMENT_DATE @@ -9,10 +9,10 @@ WITH _S1 AS ( SELECT ROUND( AVG( - DATEDIFF(CAST(_S1.MAX_PAYMENT_DATE AS DATETIME), CAST(SALES.sale_date AS DATETIME), DAY) + DATEDIFF(CAST("_S1".MAX_PAYMENT_DATE AS DATETIME), CAST(SALES.sale_date AS DATETIME), DAY) ), 2 ) AS avg_days_to_payment FROM MAIN.SALES SALES -LEFT JOIN _S1 _S1 - ON SALES._id = _S1.SALE_ID +LEFT JOIN "_S1" "_S1" + ON SALES."_id" = "_S1".SALE_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql index 4a8dfc7de..06b7ee277 100644 --- a/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT car_id AS CAR_ID, SUM(sale_price) AS SUM_SALE_PRICE @@ -11,9 +11,9 @@ WITH _S0 AS ( SELECT ( ( - NVL(SUM(_S0.SUM_SALE_PRICE), 0) - NVL(SUM(CARS.cost), 0) + NVL(SUM("_S0".SUM_SALE_PRICE), 0) - NVL(SUM(CARS.cost), 0) ) / NVL(SUM(CARS.cost), 0) ) * 100 AS GPM -FROM _S0 _S0 +FROM "_S0" "_S0" JOIN MAIN.CARS CARS - ON CARS._id = _S0.CAR_ID + ON CARS."_id" = "_S0".CAR_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql index 061b61a35..51a389dea 100644 --- a/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql @@ -4,9 +4,9 @@ SELECT SALES.sale_price FROM MAIN.SALES SALES JOIN MAIN.CARS CARS - ON CARS._id = SALES.car_id + ON CARS."_id" = SALES.car_id JOIN MAIN.INVENTORY_SNAPSHOTS INVENTORY_SNAPSHOTS - ON CARS._id = INVENTORY_SNAPSHOTS.car_id + ON CARS."_id" = INVENTORY_SNAPSHOTS.car_id AND INVENTORY_SNAPSHOTS.snapshot_date = SALES.sale_date AND NOT INVENTORY_SNAPSHOTS.is_in_inventory ORDER BY diff --git a/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql index 52c71ad39..1af15049a 100644 --- a/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT salesperson_id AS SALESPERSON_ID, AVG(sale_price) AS AVG_SALE_PRICE @@ -9,10 +9,10 @@ WITH _S1 AS ( SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, - _S1.AVG_SALE_PRICE AS ASP + "_S1".AVG_SALE_PRICE AS ASP FROM MAIN.SALESPERSONS SALESPERSONS -LEFT JOIN _S1 _S1 - ON SALESPERSONS._id = _S1.SALESPERSON_ID +LEFT JOIN "_S1" "_S1" + ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID ORDER BY 3 DESC NULLS LAST FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql index b0798c8a8..a69868e97 100644 --- a/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT salesperson_id AS SALESPERSON_ID, SUM(sale_price) AS SUM_SALE_PRICE @@ -7,13 +7,13 @@ WITH _S1 AS ( salesperson_id ) SELECT - SALESPERSONS._id, + SALESPERSONS."_id", SALESPERSONS.first_name, SALESPERSONS.last_name, - NVL(_S1.SUM_SALE_PRICE, 0) AS total + NVL("_S1".SUM_SALE_PRICE, 0) AS total FROM MAIN.SALESPERSONS SALESPERSONS -LEFT JOIN _S1 _S1 - ON SALESPERSONS._id = _S1.SALESPERSON_ID +LEFT JOIN "_S1" "_S1" + ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID ORDER BY 4 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql index e310104b3..0fdd8ba92 100644 --- a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -13,7 +13,7 @@ SELECT ) AS weekend_payments FROM MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED JOIN MAIN.SALES SALES - ON PAYMENTS_RECEIVED.sale_id = SALES._id AND SALES.sale_price > 30000 + ON PAYMENTS_RECEIVED.sale_id = SALES."_id" AND SALES.sale_price > 30000 WHERE DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) <= 8 AND DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) >= 1 diff --git a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql index 103486c61..ca3968375 100644 --- a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT salesperson_id AS SALESPERSON_ID, COUNT(*) AS N_ROWS @@ -9,13 +9,13 @@ WITH _S1 AS ( salesperson_id ) SELECT - SALESPERSONS._id, + SALESPERSONS."_id", SALESPERSONS.first_name, SALESPERSONS.last_name, - _S1.N_ROWS AS num_sales + "_S1".N_ROWS AS num_sales FROM MAIN.SALESPERSONS SALESPERSONS -JOIN _S1 _S1 - ON SALESPERSONS._id = _S1.SALESPERSON_ID +JOIN "_S1" "_S1" + ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID ORDER BY 4 DESC NULLS LAST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql index b2be4d80b..3c3d69671 100644 --- a/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql @@ -1,21 +1,21 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT ANY_VALUE(CARS.make) AS ANYTHING_MAKE, ANY_VALUE(CARS.model) AS ANYTHING_MODEL, COUNT(SALES.car_id) AS COUNT_CAR_ID FROM MAIN.CARS CARS LEFT JOIN MAIN.SALES SALES - ON CARS._id = SALES.car_id + ON CARS."_id" = SALES.car_id WHERE LOWER(CARS.vin_number) LIKE '%m5%' GROUP BY - CARS._id + CARS."_id" ) SELECT ANYTHING_MAKE AS make, ANYTHING_MODEL AS model, NVL(SUM(COUNT_CAR_ID), 0) AS num_sales -FROM _T1 +FROM "_T1" GROUP BY ANYTHING_MAKE, ANYTHING_MODEL diff --git a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql index 822289164..a0cc8da10 100644 --- a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql @@ -3,7 +3,7 @@ SELECT CASE WHEN COUNT(*) <> 0 THEN NVL(SUM(SALES.sale_price), 0) ELSE NULL END AS total_revenue FROM MAIN.CARS CARS JOIN MAIN.SALES SALES - ON CARS._id = SALES.car_id + ON CARS."_id" = SALES.car_id AND SALES.sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 30, DAY) WHERE LOWER(CARS.make) LIKE '%toyota%' diff --git a/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql index e4a4a4f4a..b9d1e038f 100644 --- a/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT salesperson_id AS SALESPERSON_ID, COUNT(*) AS N_ROWS, @@ -10,11 +10,11 @@ WITH _S1 AS ( SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, - NVL(_S1.SUM_SALE_PRICE, 0) AS total_sales, - _S1.N_ROWS AS num_sales, - RANK() OVER (ORDER BY NVL(_S1.SUM_SALE_PRICE, 0) DESC) AS sales_rank + NVL("_S1".SUM_SALE_PRICE, 0) AS total_sales, + "_S1".N_ROWS AS num_sales, + RANK() OVER (ORDER BY NVL("_S1".SUM_SALE_PRICE, 0) DESC) AS sales_rank FROM MAIN.SALESPERSONS SALESPERSONS -JOIN _S1 _S1 - ON SALESPERSONS._id = _S1.SALESPERSON_ID +JOIN "_S1" "_S1" + ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID ORDER BY 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql index f117716b5..db2736f0c 100644 --- a/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql @@ -1,8 +1,8 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT car_id AS CAR_ID, is_in_inventory AS IS_IN_INVENTORY, - ROW_NUMBER() OVER (PARTITION BY car_id ORDER BY snapshot_date DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY car_id ORDER BY snapshot_date DESC) AS "_W" FROM MAIN.INVENTORY_SNAPSHOTS ) SELECT @@ -10,11 +10,11 @@ SELECT ANY_VALUE(CARS.model) AS model, MAX(SALES.sale_price) AS highest_sale_price FROM MAIN.CARS CARS -JOIN _T _T - ON CARS._id = _T.CAR_ID AND NOT _T.IS_IN_INVENTORY AND _T._W = 1 +JOIN "_T" "_T" + ON CARS."_id" = "_T".CAR_ID AND NOT "_T".IS_IN_INVENTORY AND "_T"."_W" = 1 LEFT JOIN MAIN.SALES SALES - ON CARS._id = SALES.car_id + ON CARS."_id" = SALES.car_id GROUP BY - CARS._id + CARS."_id" ORDER BY 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql index 8da3ad13a..c9b4087aa 100644 --- a/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT car_id AS CAR_ID, AVG(sale_price) AS AVG_SALE_PRICE @@ -12,9 +12,9 @@ SELECT CARS.year, CARS.color, CARS.vin_number, - _S1.AVG_SALE_PRICE AS avg_sale_price + "_S1".AVG_SALE_PRICE AS avg_sale_price FROM MAIN.CARS CARS -LEFT JOIN _S1 _S1 - ON CARS._id = _S1.CAR_ID +LEFT JOIN "_S1" "_S1" + ON CARS."_id" = "_S1".CAR_ID WHERE LOWER(CARS.make) LIKE '%fords%' OR LOWER(CARS.model) LIKE '%mustang%' diff --git a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql index 5d5532a4b..cbb2cf067 100644 --- a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT salesperson_id AS SALESPERSON_ID, COUNT(*) AS N_ROWS, @@ -12,11 +12,11 @@ WITH _S1 AS ( SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, - NVL(_S1.N_ROWS, 0) AS total_sales, - NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue + NVL("_S1".N_ROWS, 0) AS total_sales, + NVL("_S1".SUM_SALE_PRICE, 0) AS total_revenue FROM MAIN.SALESPERSONS SALESPERSONS -LEFT JOIN _S1 _S1 - ON SALESPERSONS._id = _S1.SALESPERSON_ID +LEFT JOIN "_S1" "_S1" + ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID ORDER BY 4 DESC NULLS LAST FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql index 309996ad3..9aa0abe60 100644 --- a/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql @@ -1,8 +1,8 @@ SELECT - CARS._id, + CARS."_id", CARS.make, CARS.model, CARS.year FROM MAIN.CARS CARS JOIN MAIN.SALES SALES - ON CARS._id = SALES.car_id + ON CARS."_id" = SALES.car_id diff --git a/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql index 78f8ce95e..d8d9fb956 100644 --- a/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql @@ -1,5 +1,5 @@ SELECT - CUSTOMERS._id + CUSTOMERS."_id" FROM MAIN.CUSTOMERS CUSTOMERS JOIN MAIN.SALES SALES - ON CUSTOMERS._id = SALES.customer_id + ON CUSTOMERS."_id" = SALES.customer_id diff --git a/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql index 01e3e7313..54603aaf0 100644 --- a/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql @@ -1,8 +1,8 @@ SELECT - SALESPERSONS._id AS salesperson_id + SALESPERSONS."_id" AS salesperson_id FROM MAIN.SALESPERSONS SALESPERSONS JOIN MAIN.SALES SALES - ON SALES.salesperson_id = SALESPERSONS._id + ON SALES.salesperson_id = SALESPERSONS."_id" JOIN MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED ON PAYMENTS_RECEIVED.payment_method = 'cash' - AND PAYMENTS_RECEIVED.sale_id = SALES._id + AND PAYMENTS_RECEIVED.sale_id = SALES."_id" diff --git a/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql index ca96da0e3..43376b4de 100644 --- a/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql @@ -1,7 +1,7 @@ SELECT - SALESPERSONS._id, + SALESPERSONS."_id", SALESPERSONS.first_name, SALESPERSONS.last_name FROM MAIN.SALESPERSONS SALESPERSONS JOIN MAIN.SALES SALES - ON SALES.salesperson_id = SALESPERSONS._id + ON SALES.salesperson_id = SALESPERSONS."_id" diff --git a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql index 81e9bacc8..ee0568d30 100644 --- a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT salesperson_id AS SALESPERSON_ID, COUNT(*) AS N_ROWS, @@ -12,11 +12,11 @@ WITH _S1 AS ( SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, - _S1.N_ROWS AS total_sales, - NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue + "_S1".N_ROWS AS total_sales, + NVL("_S1".SUM_SALE_PRICE, 0) AS total_revenue FROM MAIN.SALESPERSONS SALESPERSONS -JOIN _S1 _S1 - ON SALESPERSONS._id = _S1.SALESPERSON_ID +JOIN "_S1" "_S1" + ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID ORDER BY 3 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql index c837e2702..b8c6b0d39 100644 --- a/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql @@ -4,7 +4,7 @@ SELECT NVL(SUM(SALES.sale_price), 0) AS total_revenue FROM MAIN.SALES SALES JOIN MAIN.CUSTOMERS CUSTOMERS - ON CUSTOMERS._id = SALES.customer_id + ON CUSTOMERS."_id" = SALES.customer_id GROUP BY CUSTOMERS.state ORDER BY diff --git a/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql index 51b30b8f3..b7e04e9a6 100644 --- a/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT car_id AS CAR_ID, COUNT(*) AS N_ROWS, @@ -10,11 +10,11 @@ WITH _S1 AS ( SELECT CARS.make, CARS.model, - NVL(_S1.N_ROWS, 0) AS total_sales, - NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue + NVL("_S1".N_ROWS, 0) AS total_sales, + NVL("_S1".SUM_SALE_PRICE, 0) AS total_revenue FROM MAIN.CARS CARS -LEFT JOIN _S1 _S1 - ON CARS._id = _S1.CAR_ID +LEFT JOIN "_S1" "_S1" + ON CARS."_id" = "_S1".CAR_ID ORDER BY 4 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql index 93b1b0f57..3c58a82ef 100644 --- a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER') AS QUARTER, customer_id AS CUSTOMER_ID, @@ -9,23 +9,23 @@ WITH _S0 AS ( GROUP BY TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER'), customer_id -), _T1 AS ( +), "_T1" AS ( SELECT - _S0.QUARTER, + "_S0".QUARTER, CUSTOMERS.state AS STATE, - SUM(_S0.SUM_SALE_PRICE) AS SUM_SUM_SALE_PRICE - FROM _S0 _S0 + SUM("_S0".SUM_SALE_PRICE) AS SUM_SUM_SALE_PRICE + FROM "_S0" "_S0" JOIN MAIN.CUSTOMERS CUSTOMERS - ON CUSTOMERS._id = _S0.CUSTOMER_ID + ON CUSTOMERS."_id" = "_S0".CUSTOMER_ID GROUP BY - _S0.QUARTER, + "_S0".QUARTER, CUSTOMERS.state ) SELECT QUARTER AS quarter, STATE AS customer_state, SUM_SUM_SALE_PRICE AS total_sales -FROM _T1 +FROM "_T1" WHERE NOT SUM_SUM_SALE_PRICE IS NULL AND SUM_SUM_SALE_PRICE > 0 ORDER BY diff --git a/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql index e341242df..538935eca 100644 --- a/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql @@ -1,20 +1,20 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT car_id AS CAR_ID, is_in_inventory AS IS_IN_INVENTORY, - RANK() OVER (ORDER BY snapshot_date DESC) AS _W + RANK() OVER (ORDER BY snapshot_date DESC) AS "_W" FROM MAIN.INVENTORY_SNAPSHOTS WHERE EXTRACT(MONTH FROM CAST(snapshot_date AS DATETIME)) = 3 AND EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 ) SELECT - CARS._id, + CARS."_id", CARS.make, CARS.model, CARS.year -FROM _T _T +FROM "_T" "_T" JOIN MAIN.CARS CARS - ON CARS._id = _T.CAR_ID + ON CARS."_id" = "_T".CAR_ID WHERE - _T.IS_IN_INVENTORY AND _T._W = 1 + "_T".IS_IN_INVENTORY AND "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql index 54abc90be..ec8b9d52c 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT TREATMENTS.drug_id AS DRUG_ID, COUNT(*) AS N_ROWS @@ -12,10 +12,10 @@ WITH _S3 AS ( SELECT DRUGS.drug_id, DRUGS.drug_name, - _S3.N_ROWS AS num_adverse_events + "_S3".N_ROWS AS num_adverse_events FROM MAIN.DRUGS DRUGS -JOIN _S3 _S3 - ON DRUGS.drug_id = _S3.DRUG_ID +JOIN "_S3" "_S3" + ON DRUGS.drug_id = "_S3".DRUG_ID ORDER BY 3 DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql index 52bc4e847..1fa6d2b28 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT drug_id AS DRUG_ID, AVG( @@ -12,9 +12,9 @@ WITH _S3 AS ( ) SELECT DRUGS.drug_name, - _S3.AVG_DDD AS avg_ddd + "_S3".AVG_DDD AS avg_ddd FROM MAIN.DRUGS DRUGS JOIN MAIN.TREATMENTS TREATMENTS ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT TREATMENTS.end_dt IS NULL -LEFT JOIN _S3 _S3 - ON DRUGS.drug_id = _S3.DRUG_ID +LEFT JOIN "_S3" "_S3" + ON DRUGS.drug_id = "_S3".DRUG_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql index bf0356723..861dd8bba 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT MIN(EXTRACT(YEAR FROM CAST(TREATMENTS_2.start_dt AS DATETIME))) AS MIN_YEAR_START_DT FROM MAIN.PATIENTS PATIENTS @@ -8,11 +8,11 @@ WITH _T1 AS ( ON PATIENTS.patient_id = TREATMENTS_2.patient_id GROUP BY PATIENTS.patient_id -), _T0 AS ( +), "_T0" AS ( SELECT MIN_YEAR_START_DT, COUNT(*) AS N_ROWS - FROM _T1 + FROM "_T1" GROUP BY MIN_YEAR_START_DT ) @@ -26,6 +26,6 @@ SELECT THEN N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) ELSE NULL END AS npi -FROM _T0 +FROM "_T0" ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql index b7e2433f0..46c7b7aca 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT doc_id AS DOC_ID, COUNT(DISTINCT drug_id) AS NDISTINCT_DRUG_ID @@ -9,8 +9,8 @@ WITH _S1 AS ( SELECT DOCTORS.doc_id, DOCTORS.specialty, - _S1.NDISTINCT_DRUG_ID AS num_distinct_drugs, - DENSE_RANK() OVER (PARTITION BY DOCTORS.specialty ORDER BY _S1.NDISTINCT_DRUG_ID DESC) AS SDRSDR + "_S1".NDISTINCT_DRUG_ID AS num_distinct_drugs, + DENSE_RANK() OVER (PARTITION BY DOCTORS.specialty ORDER BY "_S1".NDISTINCT_DRUG_ID DESC) AS SDRSDR FROM MAIN.DOCTORS DOCTORS -JOIN _S1 _S1 - ON DOCTORS.doc_id = _S1.DOC_ID +JOIN "_S1" "_S1" + ON DOCTORS.doc_id = "_S1".DOC_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql index e33d49c5a..bb52043a2 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') AS START_MONTH, COUNT(*) AS N_ROWS, @@ -22,6 +22,6 @@ SELECT ) AS start_month, NDISTINCT_DIAG_ID AS PMPD, N_ROWS AS PMTC -FROM _T0 +FROM "_T0" ORDER BY 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql index 38990537b..24b1a79ca 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -1,4 +1,4 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT LISTAGG( '-', @@ -28,7 +28,7 @@ WITH _S2 AS ( )) END ) -), _S3 AS ( +), "_S3" AS ( SELECT LISTAGG( '-', @@ -68,11 +68,11 @@ WITH _S2 AS ( ) ) SELECT - _S2.TREATMENT_MONTH AS month, - _S2.NDISTINCT_PATIENT_ID AS patient_count, - NVL(_S3.NDISTINCT_PATIENT_ID, 0) AS biologic_treatment_count -FROM _S2 _S2 -LEFT JOIN _S3 _S3 - ON _S2.TREATMENT_MONTH = _S3.TREATMENT_MONTH + "_S2".TREATMENT_MONTH AS month, + "_S2".NDISTINCT_PATIENT_ID AS patient_count, + NVL("_S3".NDISTINCT_PATIENT_ID, 0) AS biologic_treatment_count +FROM "_S2" "_S2" +LEFT JOIN "_S3" "_S3" + ON "_S2".TREATMENT_MONTH = "_S3".TREATMENT_MONTH ORDER BY 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql index 525ea1b8f..3ce4e86fe 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT doc_id AS DOC_ID, COUNT(*) AS N_ROWS, @@ -8,14 +8,14 @@ WITH _S1 AS ( start_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') GROUP BY doc_id -), _T1 AS ( +), "_T1" AS ( SELECT DOCTORS.specialty AS SPECIALTY, - SUM(_S1.N_ROWS) AS SUM_N_ROWS, - SUM(_S1.SUM_TOT_DRUG_AMT) AS SUM_SUM_TOT_DRUG_AMT + SUM("_S1".N_ROWS) AS SUM_N_ROWS, + SUM("_S1".SUM_TOT_DRUG_AMT) AS SUM_SUM_TOT_DRUG_AMT FROM MAIN.DOCTORS DOCTORS - LEFT JOIN _S1 _S1 - ON DOCTORS.doc_id = _S1.DOC_ID + LEFT JOIN "_S1" "_S1" + ON DOCTORS.doc_id = "_S1".DOC_ID GROUP BY DOCTORS.specialty ) @@ -23,7 +23,7 @@ SELECT SPECIALTY AS specialty, SUM_N_ROWS AS num_treatments, NVL(SUM_SUM_TOT_DRUG_AMT, 0) AS total_drug_amount -FROM _T1 +FROM "_T1" WHERE SUM_N_ROWS <> 0 ORDER BY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql index 9290669b7..e9a8b49ad 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql @@ -1,4 +1,4 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT end_dt AS END_DT, patient_id AS PATIENT_ID, @@ -6,30 +6,30 @@ WITH _T2 AS ( FROM MAIN.TREATMENTS WHERE EXTRACT(YEAR FROM CAST(end_dt AS DATETIME)) = 2022 -), _T3 AS ( +), "_T3" AS ( SELECT day100_pasi_score AS DAY100_PASI_SCORE, treatment_id AS TREATMENT_ID FROM MAIN.OUTCOMES WHERE NOT day100_pasi_score IS NULL -), _S3 AS ( +), "_S3" AS ( SELECT ins_type AS INS_TYPE, patient_id AS PATIENT_ID FROM MAIN.PATIENTS -), _S10 AS ( +), "_S10" AS ( SELECT - _S3.INS_TYPE, - COUNT(DISTINCT _T2.PATIENT_ID) AS NDISTINCT_PATIENT_ID - FROM _T2 _T2 - JOIN _T3 _T3 - ON _T2.TREATMENT_ID = _T3.TREATMENT_ID - JOIN _S3 _S3 - ON _S3.PATIENT_ID = _T2.PATIENT_ID + "_S3".INS_TYPE, + COUNT(DISTINCT "_T2".PATIENT_ID) AS NDISTINCT_PATIENT_ID + FROM "_T2" "_T2" + JOIN "_T3" "_T3" + ON "_T2".TREATMENT_ID = "_T3".TREATMENT_ID + JOIN "_S3" "_S3" + ON "_S3".PATIENT_ID = "_T2".PATIENT_ID GROUP BY - _S3.INS_TYPE -), _S9 AS ( + "_S3".INS_TYPE +), "_S9" AS ( SELECT treatment_id AS TREATMENT_ID, COUNT(day100_pasi_score) AS COUNT_DAY100_PASI_SCORE, @@ -37,27 +37,27 @@ WITH _T2 AS ( FROM MAIN.OUTCOMES GROUP BY treatment_id -), _S11 AS ( +), "_S11" AS ( SELECT - SUM(_S9.SUM_DAY100_PASI_SCORE) / SUM(_S9.COUNT_DAY100_PASI_SCORE) AS AVG_DAY100_PASI_SCORE, - _S7.INS_TYPE - FROM _T2 _T6 - JOIN _T3 _T7 - ON _T6.TREATMENT_ID = _T7.TREATMENT_ID - JOIN _S3 _S7 - ON _S7.PATIENT_ID = _T6.PATIENT_ID - JOIN _S9 _S9 - ON _S9.TREATMENT_ID = _T6.TREATMENT_ID + SUM("_S9".SUM_DAY100_PASI_SCORE) / SUM("_S9".COUNT_DAY100_PASI_SCORE) AS AVG_DAY100_PASI_SCORE, + "_S7".INS_TYPE + FROM "_T2" "_T6" + JOIN "_T3" "_T7" + ON "_T6".TREATMENT_ID = "_T7".TREATMENT_ID + JOIN "_S3" "_S7" + ON "_S7".PATIENT_ID = "_T6".PATIENT_ID + JOIN "_S9" "_S9" + ON "_S9".TREATMENT_ID = "_T6".TREATMENT_ID GROUP BY - _S7.INS_TYPE + "_S7".INS_TYPE ) SELECT - _S10.INS_TYPE AS insurance_type, - _S10.NDISTINCT_PATIENT_ID AS num_distinct_patients, - _S11.AVG_DAY100_PASI_SCORE AS avg_pasi_score_day100 -FROM _S10 _S10 -LEFT JOIN _S11 _S11 - ON _S10.INS_TYPE = _S11.INS_TYPE + "_S10".INS_TYPE AS insurance_type, + "_S10".NDISTINCT_PATIENT_ID AS num_distinct_patients, + "_S11".AVG_DAY100_PASI_SCORE AS avg_pasi_score_day100 +FROM "_S10" "_S10" +LEFT JOIN "_S11" "_S11" + ON "_S10".INS_TYPE = "_S11".INS_TYPE ORDER BY 3 NULLS FIRST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql index ba625b6b6..acae8a855 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT drug_id AS DRUG_ID, AVG(tot_drug_amt) AS AVG_TOT_DRUG_AMT, @@ -9,11 +9,11 @@ WITH _S1 AS ( ) SELECT DRUGS.drug_name, - NVL(_S1.N_ROWS, 0) AS num_treatments, - _S1.AVG_TOT_DRUG_AMT AS avg_drug_amount + NVL("_S1".N_ROWS, 0) AS num_treatments, + "_S1".AVG_TOT_DRUG_AMT AS avg_drug_amount FROM MAIN.DRUGS DRUGS -LEFT JOIN _S1 _S1 - ON DRUGS.drug_id = _S1.DRUG_ID +LEFT JOIN "_S1" "_S1" + ON DRUGS.drug_id = "_S1".DRUG_ID ORDER BY 2 DESC NULLS LAST, 3 DESC NULLS LAST, diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql index 7044080db..8268f4b01 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT ANY_VALUE(TREATMENTS.diag_id) AS ANYTHING_DIAG_ID, ANY_VALUE(TREATMENTS.patient_id) AS ANYTHING_PATIENT_ID, @@ -8,22 +8,22 @@ WITH _T1 AS ( ON OUTCOMES.treatment_id = TREATMENTS.treatment_id GROUP BY OUTCOMES.treatment_id -), _S3 AS ( +), "_S3" AS ( SELECT ANYTHING_DIAG_ID, MAX(MAX_DAY100_ITCH_VAS) AS MAX_MAX_DAY100_ITCH_VAS, COUNT(DISTINCT ANYTHING_PATIENT_ID) AS NDISTINCT_ANYTHING_PATIENT_ID - FROM _T1 + FROM "_T1" GROUP BY ANYTHING_DIAG_ID ) SELECT DIAGNOSES.diag_name AS diagnosis_name, - _S3.NDISTINCT_ANYTHING_PATIENT_ID AS num_patients, - _S3.MAX_MAX_DAY100_ITCH_VAS AS max_itch_score + "_S3".NDISTINCT_ANYTHING_PATIENT_ID AS num_patients, + "_S3".MAX_MAX_DAY100_ITCH_VAS AS max_itch_score FROM MAIN.DIAGNOSES DIAGNOSES -JOIN _S3 _S3 - ON DIAGNOSES.diag_id = _S3.ANYTHING_DIAG_ID +JOIN "_S3" "_S3" + ON DIAGNOSES.diag_id = "_S3".ANYTHING_DIAG_ID ORDER BY 3 DESC NULLS LAST, 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql index 788d00c7a..1fc9dffaa 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql @@ -1,26 +1,26 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT doc_id AS DOC_ID, start_dt AS START_DT, treatment_id AS TREATMENT_ID, - ROW_NUMBER() OVER (PARTITION BY doc_id ORDER BY start_dt) AS _W + ROW_NUMBER() OVER (PARTITION BY doc_id ORDER BY start_dt) AS "_W" FROM MAIN.TREATMENTS -), _S1 AS ( +), "_S1" AS ( SELECT DOC_ID, START_DT, TREATMENT_ID - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 ) SELECT DOCTORS.last_name, DOCTORS.year_reg, - _S1.START_DT AS first_treatment_date, - _S1.TREATMENT_ID AS first_treatment_id + "_S1".START_DT AS first_treatment_date, + "_S1".TREATMENT_ID AS first_treatment_id FROM MAIN.DOCTORS DOCTORS -LEFT JOIN _S1 _S1 - ON DOCTORS.doc_id = _S1.DOC_ID +LEFT JOIN "_S1" "_S1" + ON DOCTORS.doc_id = "_S1".DOC_ID WHERE DOCTORS.year_reg = EXTRACT(YEAR FROM DATE_SUB(CURRENT_TIMESTAMP, 2, YEAR)) diff --git a/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql index bc455ae65..ee0d96e3b 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL(SUM(status = 'success'), 0) / COUNT(*) AS _expr0 + NVL(SUM(status = 'success'), 0) / COUNT(*) AS "_expr0" FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE DATEDIFF(CURRENT_TIMESTAMP, CAST(created_at AS DATETIME), MONTH) = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql index daa189a31..babc7982a 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT COUPONS.merchant_id AS MERCHANT_ID, COUNT(*) AS N_ROWS @@ -12,10 +12,10 @@ WITH _S3 AS ( SELECT MERCHANTS.mid AS merchant_id, MERCHANTS.name AS merchant_name, - NVL(_S3.N_ROWS, 0) AS coupons_per_merchant + NVL("_S3".N_ROWS, 0) AS coupons_per_merchant FROM MAIN.MERCHANTS MERCHANTS -LEFT JOIN _S3 _S3 - ON MERCHANTS.mid = _S3.MERCHANT_ID +LEFT JOIN "_S3" "_S3" + ON MERCHANTS.mid = "_S3".MERCHANT_ID ORDER BY 3 DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql index e3bbd9ad8..c68ff399e 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql @@ -1,13 +1,13 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT balance AS BALANCE, user_id AS USER_ID, - ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY updated_at DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY updated_at DESC) AS "_W" FROM MAIN.WALLET_USER_BALANCE_DAILY ) SELECT USER_ID AS user_id, BALANCE AS latest_balance -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql index 461713544..1de2c9b86 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql @@ -1,13 +1,13 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT marketing_opt_in AS MARKETING_OPT_IN, user_id AS USER_ID, - ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS "_W" FROM MAIN.USER_SETTING_SNAPSHOT ) SELECT USERS.uid, - _T.MARKETING_OPT_IN AS marketing_opt_in + "_T".MARKETING_OPT_IN AS marketing_opt_in FROM MAIN.USERS USERS -JOIN _T _T - ON USERS.uid = _T.USER_ID AND _T._W = 1 +JOIN "_T" "_T" + ON USERS.uid = "_T".USER_ID AND "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql index b3d311310..8dc71ed62 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT amount AS AMOUNT, receiver_id AS RECEIVER_ID @@ -9,11 +9,11 @@ WITH _S1 AS ( ) SELECT ANY_VALUE(MERCHANTS.name) AS merchant_name, - NVL(NULLIF(COUNT(_S1.RECEIVER_ID), 0), 0) AS total_transactions, - NVL(SUM(_S1.AMOUNT), 0) AS total_amount + NVL(NULLIF(COUNT("_S1".RECEIVER_ID), 0), 0) AS total_transactions, + NVL(SUM("_S1".AMOUNT), 0) AS total_amount FROM MAIN.MERCHANTS MERCHANTS -LEFT JOIN _S1 _S1 - ON MERCHANTS.mid = _S1.RECEIVER_ID +LEFT JOIN "_S1" "_S1" + ON MERCHANTS.mid = "_S1".RECEIVER_ID GROUP BY MERCHANTS.mid ORDER BY diff --git a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql index e9f9f48e5..fbb930523 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT CASE WHEN ABS( @@ -22,5 +22,5 @@ WITH _T0 AS ( TRUNC(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS TIMESTAMP), 'DAY') = TRUNC(CURRENT_TIMESTAMP, 'DAY') ) SELECT - AVG(EXPR_1) AS _expr0 -FROM _T0 + AVG(EXPR_1) AS "_expr0" +FROM "_T0" diff --git a/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql index eb3840caa..3888863c7 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql @@ -1,10 +1,10 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT MIN(snapshot_date) AS MIN_SNAPSHOT_DATE FROM MAIN.USER_SETTING_SNAPSHOT WHERE EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 -), _S1 AS ( +), "_S1" AS ( SELECT snapshot_date AS SNAPSHOT_DATE, AVG(tx_limit_daily) AS AVG_TX_LIMIT_DAILY, @@ -16,8 +16,8 @@ WITH _S0 AS ( snapshot_date ) SELECT - _S1.AVG_TX_LIMIT_DAILY AS avg_daily_limit, - _S1.AVG_TX_LIMIT_MONTHLY AS avg_monthly_limit -FROM _S0 _S0 -LEFT JOIN _S1 _S1 - ON _S0.MIN_SNAPSHOT_DATE = _S1.SNAPSHOT_DATE + "_S1".AVG_TX_LIMIT_DAILY AS avg_daily_limit, + "_S1".AVG_TX_LIMIT_MONTHLY AS avg_monthly_limit +FROM "_S0" "_S0" +LEFT JOIN "_S1" "_S1" + ON "_S0".MIN_SNAPSHOT_DATE = "_S1".SNAPSHOT_DATE diff --git a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql index 51a3f4d03..c7d0e27d0 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql @@ -1,36 +1,36 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT merchant_id AS MERCHANT_ID, start_date AS START_DATE FROM MAIN.COUPONS -), _S1 AS ( +), "_S1" AS ( SELECT MERCHANT_ID, MIN(START_DATE) AS MIN_START_DATE - FROM _T1 + FROM "_T1" GROUP BY MERCHANT_ID -), _S4 AS ( +), "_S4" AS ( SELECT MERCHANTS.mid AS MID, - _S1.MIN_START_DATE, + "_S1".MIN_START_DATE, ANY_VALUE(MERCHANTS.created_at) AS ANYTHING_CREATED_AT, MAX(COUPONS.cid) AS MAX_CID FROM MAIN.MERCHANTS MERCHANTS - LEFT JOIN _S1 _S1 - ON MERCHANTS.mid = _S1.MERCHANT_ID + LEFT JOIN "_S1" "_S1" + ON MERCHANTS.mid = "_S1".MERCHANT_ID LEFT JOIN MAIN.COUPONS COUPONS - ON COUPONS.merchant_id = MERCHANTS.mid AND COUPONS.start_date = _S1.MIN_START_DATE + ON COUPONS.merchant_id = MERCHANTS.mid AND COUPONS.start_date = "_S1".MIN_START_DATE GROUP BY MERCHANTS.mid, - _S1.MIN_START_DATE + "_S1".MIN_START_DATE ) SELECT - _S4.MID AS merchants_id, - _S4.ANYTHING_CREATED_AT AS merchant_registration_date, - _S4.MIN_START_DATE AS earliest_coupon_start_date, - _S4.MAX_CID AS earliest_coupon_id -FROM _S4 _S4 -JOIN _T1 _S5 - ON _S4.MID = _S5.MERCHANT_ID - AND _S5.START_DATE <= DATE_ADD(CAST(_S4.ANYTHING_CREATED_AT AS TIMESTAMP), 1, 'YEAR') + "_S4".MID AS merchants_id, + "_S4".ANYTHING_CREATED_AT AS merchant_registration_date, + "_S4".MIN_START_DATE AS earliest_coupon_start_date, + "_S4".MAX_CID AS earliest_coupon_id +FROM "_S4" "_S4" +JOIN "_T1" "_S5" + ON "_S4".MID = "_S5".MERCHANT_ID + AND "_S5".START_DATE <= DATE_ADD(CAST("_S4".ANYTHING_CREATED_AT AS TIMESTAMP), 1, 'YEAR') diff --git a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql index 566fd4aac..4087698ab 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql @@ -1,15 +1,15 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.RESTAURANT WHERE rating > 4.5 -), _S1 AS ( +), "_S1" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.RESTAURANT ) SELECT - _S0.N_ROWS / _S1.N_ROWS AS ratio -FROM _S0 _S0 -CROSS JOIN _S1 _S1 + "_S0".N_ROWS / "_S1".N_ROWS AS ratio +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql index 2a5b78bd7..07da2b0a3 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT city_name AS CITY_NAME, name AS NAME, @@ -12,6 +12,6 @@ SELECT CITY_NAME AS city_name, NAME AS name, N_ROWS AS n_restaurants -FROM _T0 +FROM "_T0" WHERE N_ROWS > 1 diff --git a/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql index 64c651bf1..6a2320f36 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql @@ -1,19 +1,19 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT city_name AS CITY_NAME, region AS REGION FROM MAIN.GEOGRAPHIC -), _S1 AS ( +), "_S1" AS ( SELECT city_name AS CITY_NAME FROM MAIN.RESTAURANT -), _S6 AS ( +), "_S6" AS ( SELECT DISTINCT - _S0.REGION - FROM _S0 _S0 - JOIN _S1 _S1 - ON _S0.CITY_NAME = _S1.CITY_NAME -), _S5 AS ( + "_S0".REGION + FROM "_S0" "_S0" + JOIN "_S1" "_S1" + ON "_S0".CITY_NAME = "_S1".CITY_NAME +), "_S5" AS ( SELECT city_name AS CITY_NAME, COUNT(rating) AS COUNT_RATING, @@ -21,23 +21,23 @@ WITH _S0 AS ( FROM MAIN.RESTAURANT GROUP BY city_name -), _S7 AS ( +), "_S7" AS ( SELECT - SUM(_S5.SUM_RATING) / SUM(_S5.COUNT_RATING) AS AVG_RATING, - _S2.REGION - FROM _S0 _S2 - JOIN _S1 _S3 - ON _S2.CITY_NAME = _S3.CITY_NAME - JOIN _S5 _S5 - ON _S2.CITY_NAME = _S5.CITY_NAME + SUM("_S5".SUM_RATING) / SUM("_S5".COUNT_RATING) AS AVG_RATING, + "_S2".REGION + FROM "_S0" "_S2" + JOIN "_S1" "_S3" + ON "_S2".CITY_NAME = "_S3".CITY_NAME + JOIN "_S5" "_S5" + ON "_S2".CITY_NAME = "_S5".CITY_NAME GROUP BY - _S2.REGION + "_S2".REGION ) SELECT - _S6.REGION AS rest_region, - _S7.AVG_RATING AS avg_rating -FROM _S6 _S6 -LEFT JOIN _S7 _S7 - ON _S6.REGION = _S7.REGION + "_S6".REGION AS rest_region, + "_S7".AVG_RATING AS avg_rating +FROM "_S6" "_S6" +LEFT JOIN "_S7" "_S7" + ON "_S6".REGION = "_S7".REGION ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql index c181210f5..d0bdf54fd 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT city_name AS CITY_NAME, COUNT(*) AS N_ROWS @@ -10,10 +10,10 @@ WITH _S0 AS ( ) SELECT GEOGRAPHIC.region AS rest_region, - SUM(_S0.N_ROWS) AS n_restaurants -FROM _S0 _S0 + SUM("_S0".N_ROWS) AS n_restaurants +FROM "_S0" "_S0" JOIN MAIN.GEOGRAPHIC GEOGRAPHIC - ON GEOGRAPHIC.city_name = _S0.CITY_NAME + ON GEOGRAPHIC.city_name = "_S0".CITY_NAME GROUP BY GEOGRAPHIC.region ORDER BY diff --git a/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql index 4d1d8701d..bb6f0c403 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT city_name AS CITY_NAME, COUNT(*) AS N_ROWS @@ -8,10 +8,10 @@ WITH _S0 AS ( ) SELECT GEOGRAPHIC.region AS rest_region, - SUM(_S0.N_ROWS) AS n_restaurants -FROM _S0 _S0 + SUM("_S0".N_ROWS) AS n_restaurants +FROM "_S0" "_S0" JOIN MAIN.GEOGRAPHIC GEOGRAPHIC - ON GEOGRAPHIC.city_name = _S0.CITY_NAME + ON GEOGRAPHIC.city_name = "_S0".CITY_NAME GROUP BY GEOGRAPHIC.region ORDER BY diff --git a/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql index 597e3305d..a96442ae1 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql @@ -1,33 +1,33 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT city_name AS CITY_NAME, region AS REGION FROM MAIN.GEOGRAPHIC -), _S6 AS ( +), "_S6" AS ( SELECT DISTINCT - _S1.REGION + "_S1".REGION FROM MAIN.LOCATION LOCATION - LEFT JOIN _S1 _S1 - ON LOCATION.city_name = _S1.CITY_NAME -), _S7 AS ( + LEFT JOIN "_S1" "_S1" + ON LOCATION.city_name = "_S1".CITY_NAME +), "_S7" AS ( SELECT - _S3.REGION, + "_S3".REGION, SUM(CASE WHEN NOT RESTAURANT.rating IS NULL THEN 1 ELSE 0 END) AS SUM_EXPR, SUM(RESTAURANT.rating) AS SUM_RATING FROM MAIN.LOCATION LOCATION - LEFT JOIN _S1 _S3 - ON LOCATION.city_name = _S3.CITY_NAME + LEFT JOIN "_S1" "_S3" + ON LOCATION.city_name = "_S3".CITY_NAME JOIN MAIN.RESTAURANT RESTAURANT ON LOCATION.restaurant_id = RESTAURANT.id GROUP BY - _S3.REGION + "_S3".REGION ) SELECT - _S6.REGION AS region_name, - _S7.SUM_RATING / _S7.SUM_EXPR AS avg_rating -FROM _S6 _S6 -JOIN _S7 _S7 - ON _S6.REGION = _S7.REGION + "_S6".REGION AS region_name, + "_S7".SUM_RATING / "_S7".SUM_EXPR AS avg_rating +FROM "_S6" "_S6" +JOIN "_S7" "_S7" + ON "_S6".REGION = "_S7".REGION ORDER BY 1 NULLS FIRST, 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql index ec5eea326..ff2376998 100644 --- a/tests/test_sql_refsols/double_cross_oracle.sql +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -1,59 +1,59 @@ -WITH _T3 AS ( +WITH "_T3" AS ( SELECT o_orderdate AS O_ORDERDATE FROM TPCH.ORDERS -), _S0 AS ( +), "_S0" AS ( SELECT MIN(O_ORDERDATE) AS MIN_O_ORDERDATE - FROM _T3 -), _S2 AS ( + FROM "_T3" +), "_S2" AS ( SELECT - DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) AS ORD_WK, + DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST("_S0".MIN_O_ORDERDATE AS DATETIME), WEEK) AS ORD_WK, COUNT(*) AS N_ROWS - FROM _S0 _S0 + FROM "_S0" "_S0" JOIN TPCH.ORDERS ORDERS - ON DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) < 10 + ON DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST("_S0".MIN_O_ORDERDATE AS DATETIME), WEEK) < 10 AND ORDERS.o_orderpriority = '1-URGENT' AND ORDERS.o_orderstatus = 'F' GROUP BY - DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) -), _S3 AS ( + DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST("_S0".MIN_O_ORDERDATE AS DATETIME), WEEK) +), "_S3" AS ( SELECT MIN(O_ORDERDATE) AS MIN_O_ORDERDATE - FROM _T3 -), _T0 AS ( + FROM "_T3" +), "_T0" AS ( SELECT DATEDIFF( CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + CAST("_S3".MIN_O_ORDERDATE AS DATETIME), WEEK ) AS LINE_WK, - _S2.ORD_WK, - ANY_VALUE(_S2.N_ROWS) AS ANYTHING_N_ROWS, + "_S2".ORD_WK, + ANY_VALUE("_S2".N_ROWS) AS ANYTHING_N_ROWS, COUNT(*) AS N_ROWS - FROM _S2 _S2 - CROSS JOIN _S3 _S3 + FROM "_S2" "_S2" + CROSS JOIN "_S3" "_S3" JOIN TPCH.LINEITEM LINEITEM ON DATEDIFF( CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + CAST("_S3".MIN_O_ORDERDATE AS DATETIME), WEEK ) < 10 AND EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1992 AND LINEITEM.l_returnflag = 'R' AND LINEITEM.l_shipmode = 'RAIL' - AND _S2.ORD_WK = DATEDIFF( + AND "_S2".ORD_WK = DATEDIFF( CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + CAST("_S3".MIN_O_ORDERDATE AS DATETIME), WEEK ) GROUP BY DATEDIFF( CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + CAST("_S3".MIN_O_ORDERDATE AS DATETIME), WEEK ), - _S2.ORD_WK + "_S2".ORD_WK ) SELECT ORD_WK AS wk, @@ -63,6 +63,6 @@ SELECT SUM(N_ROWS) OVER (ORDER BY LINE_WK ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(ANYTHING_N_ROWS) OVER (ORDER BY ORD_WK ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 4 ) AS lpo -FROM _T0 +FROM "_T0" ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/double_partition_oracle.sql b/tests/test_sql_refsols/double_partition_oracle.sql index 843f4d0f3..417a6d4c8 100644 --- a/tests/test_sql_refsols/double_partition_oracle.sql +++ b/tests/test_sql_refsols/double_partition_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, COUNT(*) AS N_ROWS @@ -10,6 +10,6 @@ WITH _T0 AS ( SELECT YEAR_O_ORDERDATE AS year, MAX(N_ROWS) AS best_month -FROM _T0 +FROM "_T0" GROUP BY YEAR_O_ORDERDATE diff --git a/tests/test_sql_refsols/dumb_aggregation_oracle.sql b/tests/test_sql_refsols/dumb_aggregation_oracle.sql index 18c231309..031b6c7f9 100644 --- a/tests/test_sql_refsols/dumb_aggregation_oracle.sql +++ b/tests/test_sql_refsols/dumb_aggregation_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT n_name AS N_NAME, n_regionkey AS N_REGIONKEY @@ -6,7 +6,7 @@ WITH _S0 AS ( ORDER BY 1 NULLS FIRST FETCH FIRST 2 ROWS ONLY -), _S1 AS ( +), "_S1" AS ( SELECT r_name AS R_NAME, r_regionkey AS R_REGIONKEY, @@ -26,21 +26,21 @@ WITH _S0 AS ( FROM TPCH.REGION ) SELECT - _S0.N_NAME AS nation_name, - _S1.R_NAME AS a1, - _S1.R_NAME AS a2, - _S1.R_REGIONKEY AS a3, + "_S0".N_NAME AS nation_name, + "_S1".R_NAME AS a1, + "_S1".R_NAME AS a2, + "_S1".R_REGIONKEY AS a3, CASE - WHEN NOT CASE WHEN _S1.R_NAME <> 'AMERICA' THEN _S1.R_REGIONKEY ELSE NULL END IS NULL + WHEN NOT CASE WHEN "_S1".R_NAME <> 'AMERICA' THEN "_S1".R_REGIONKEY ELSE NULL END IS NULL THEN 1 ELSE 0 END AS a4, 1 AS a5, - _S1.R_REGIONKEY AS a6, - _S1.R_NAME AS a7, - _S1.AVG_EXPR AS a8 -FROM _S0 _S0 -JOIN _S1 _S1 - ON _S0.N_REGIONKEY = _S1.R_REGIONKEY + "_S1".R_REGIONKEY AS a6, + "_S1".R_NAME AS a7, + "_S1".AVG_EXPR AS a8 +FROM "_S0" "_S0" +JOIN "_S1" "_S1" + ON "_S0".N_REGIONKEY = "_S1".R_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql index 50f710944..b48b54e32 100644 --- a/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql +++ b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql @@ -1,4 +1,4 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT ev_dt AS EV_DT, ev_key AS EV_KEY @@ -14,17 +14,17 @@ FROM EVENTS EVENTS JOIN ERAS ERAS ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) -JOIN _S2 _S2 - ON EVENTS.ev_key = _S2.EV_KEY +JOIN "_S2" "_S2" + ON EVENTS.ev_key = "_S2".EV_KEY JOIN SEASONS SEASONS - ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) - OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) - OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) -JOIN _S2 _S6 - ON EVENTS.ev_key = _S6.EV_KEY + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATETIME)) +JOIN "_S2" "_S6" + ON EVENTS.ev_key = "_S6".EV_KEY JOIN TIMES TIMES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(_S6.EV_DT AS DATETIME)) - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(_S6.EV_DT AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S6".EV_DT AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S6".EV_DT AS DATETIME)) WHERE EVENTS.ev_typ = 'culture' ORDER BY diff --git a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql index ade631cd8..a81ff0f60 100644 --- a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql +++ b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql @@ -1,4 +1,4 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT ERAS.er_end_year AS ER_END_YEAR, ERAS.er_name AS ER_NAME, @@ -17,7 +17,7 @@ WITH _T2 AS ( SELECT ER_NAME AS era_name, AVG(DAY_GAP) AS avg_event_gap -FROM _T2 +FROM "_T2" WHERE ER_END_YEAR > EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) AND ER_START_YEAR <= EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) diff --git a/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql index 4c896c87b..483d55e49 100644 --- a/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql +++ b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql @@ -1,9 +1,9 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT ERAS.er_name AS ER_NAME, ERAS.er_start_year AS ER_START_YEAR, EVENTS.ev_name AS EV_NAME, - ROW_NUMBER() OVER (PARTITION BY ERAS.er_name ORDER BY EVENTS.ev_dt) AS _W + ROW_NUMBER() OVER (PARTITION BY ERAS.er_name ORDER BY EVENTS.ev_dt) AS "_W" FROM ERAS ERAS JOIN EVENTS EVENTS ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) @@ -12,8 +12,8 @@ WITH _T AS ( SELECT ER_NAME AS era_name, EV_NAME AS event_name -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY ER_START_YEAR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql index 766e646c5..9058dd39d 100644 --- a/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql +++ b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql @@ -1,86 +1,86 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT s_month1 AS S_MONTH1, s_month2 AS S_MONTH2, s_month3 AS S_MONTH3, s_name AS S_NAME FROM SEASONS -), _S5 AS ( +), "_S5" AS ( SELECT ev_dt AS EV_DT, ev_name AS EV_NAME FROM EVENTS -), _S9 AS ( +), "_S9" AS ( SELECT - _S2.S_NAME, + "_S2".S_NAME, SEARCHES.search_id AS SEARCH_ID - FROM _S0 _S2 + FROM "_S0" "_S2" JOIN SEARCHES SEARCHES - ON _S2.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR _S2.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR _S2.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - JOIN _S5 _S5 - ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(_S5.EV_NAME), '%') - JOIN _S0 _S7 - ON _S2.S_NAME = _S7.S_NAME + ON "_S2".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR "_S2".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR "_S2".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + JOIN "_S5" "_S5" + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER("_S5".EV_NAME), '%') + JOIN "_S0" "_S7" + ON "_S2".S_NAME = "_S7".S_NAME AND ( - _S7.S_MONTH1 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) - OR _S7.S_MONTH2 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) - OR _S7.S_MONTH3 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + "_S7".S_MONTH1 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATETIME)) + OR "_S7".S_MONTH2 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATETIME)) + OR "_S7".S_MONTH3 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATETIME)) ) -), _T1 AS ( +), "_T1" AS ( SELECT - _S0.S_NAME, - COUNT(_S9.SEARCH_ID) AS COUNT_SEARCH_ID - FROM _S0 _S0 + "_S0".S_NAME, + COUNT("_S9".SEARCH_ID) AS COUNT_SEARCH_ID + FROM "_S0" "_S0" JOIN SEARCHES SEARCHES - ON _S0.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR _S0.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR _S0.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - LEFT JOIN _S9 _S9 - ON SEARCHES.search_id = _S9.SEARCH_ID AND _S0.S_NAME = _S9.S_NAME + ON "_S0".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR "_S0".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR "_S0".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + LEFT JOIN "_S9" "_S9" + ON SEARCHES.search_id = "_S9".SEARCH_ID AND "_S0".S_NAME = "_S9".S_NAME GROUP BY SEARCHES.search_id, - _S0.S_NAME -), _S16 AS ( + "_S0".S_NAME +), "_S16" AS ( SELECT S_NAME, COUNT(*) AS N_ROWS, SUM(( NOT NULLIF(COUNT_SEARCH_ID, 0) IS NULL AND NULLIF(COUNT_SEARCH_ID, 0) > 0 )) AS SUM_IS_INTRA_SEASON - FROM _T1 + FROM "_T1" GROUP BY S_NAME -), _S17 AS ( +), "_S17" AS ( SELECT - _S10.S_NAME, + "_S10".S_NAME, COUNT(*) AS N_ROWS, - SUM(_S15.S_NAME = _S10.S_NAME) AS SUM_IS_INTRA_SEASON - FROM _S0 _S10 - JOIN _S5 _S11 - ON _S10.S_MONTH1 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) - OR _S10.S_MONTH2 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) - OR _S10.S_MONTH3 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + SUM("_S15".S_NAME = "_S10".S_NAME) AS SUM_IS_INTRA_SEASON + FROM "_S0" "_S10" + JOIN "_S5" "_S11" + ON "_S10".S_MONTH1 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATETIME)) + OR "_S10".S_MONTH2 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATETIME)) + OR "_S10".S_MONTH3 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATETIME)) JOIN SEARCHES SEARCHES - ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(_S11.EV_NAME), '%') - JOIN _S0 _S15 - ON _S15.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR _S15.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR _S15.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER("_S11".EV_NAME), '%') + JOIN "_S0" "_S15" + ON "_S15".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR "_S15".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR "_S15".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) GROUP BY - _S10.S_NAME + "_S10".S_NAME ) SELECT - _S16.S_NAME AS season_name, + "_S16".S_NAME AS season_name, ROUND(( - 100.0 * NVL(_S16.SUM_IS_INTRA_SEASON, 0) - ) / _S16.N_ROWS, 2) AS pct_season_searches, + 100.0 * NVL("_S16".SUM_IS_INTRA_SEASON, 0) + ) / "_S16".N_ROWS, 2) AS pct_season_searches, ROUND(( - 100.0 * NVL(_S17.SUM_IS_INTRA_SEASON, 0) - ) / NVL(_S17.N_ROWS, 0), 2) AS pct_event_searches -FROM _S16 _S16 -LEFT JOIN _S17 _S17 - ON _S16.S_NAME = _S17.S_NAME + 100.0 * NVL("_S17".SUM_IS_INTRA_SEASON, 0) + ) / NVL("_S17".N_ROWS, 0), 2) AS pct_event_searches +FROM "_S16" "_S16" +LEFT JOIN "_S17" "_S17" + ON "_S16".S_NAME = "_S17".S_NAME ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql index 02aa44615..138bc436f 100644 --- a/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql +++ b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql @@ -1,4 +1,4 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT SEARCHES.search_engine AS SEARCH_ENGINE, TIMES.t_name AS T_NAME, @@ -10,20 +10,20 @@ WITH _T2 AS ( GROUP BY SEARCHES.search_engine, TIMES.t_name -), _T AS ( +), "_T" AS ( SELECT SEARCH_ENGINE, T_NAME, N_ROWS, - ROW_NUMBER() OVER (PARTITION BY T_NAME ORDER BY N_ROWS DESC, SEARCH_ENGINE) AS _W - FROM _T2 + ROW_NUMBER() OVER (PARTITION BY T_NAME ORDER BY N_ROWS DESC, SEARCH_ENGINE) AS "_W" + FROM "_T2" ) SELECT T_NAME AS tod, SEARCH_ENGINE AS search_engine, N_ROWS AS n_searches -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql index 9299070ad..fb281fa9d 100644 --- a/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql +++ b/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT EVENTS.ev_typ AS EV_TYP, USERS.user_region AS USER_REGION, @@ -11,18 +11,18 @@ WITH _T1 AS ( GROUP BY EVENTS.ev_typ, USERS.user_region -), _T AS ( +), "_T" AS ( SELECT EV_TYP, USER_REGION, NDISTINCT_SEARCH_ID, - ROW_NUMBER() OVER (PARTITION BY USER_REGION ORDER BY NDISTINCT_SEARCH_ID DESC) AS _W - FROM _T1 + ROW_NUMBER() OVER (PARTITION BY USER_REGION ORDER BY NDISTINCT_SEARCH_ID DESC) AS "_W" + FROM "_T1" ) SELECT USER_REGION AS region, EV_TYP AS event_type, NDISTINCT_SEARCH_ID AS n_searches -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql index 94566b070..2b7095b43 100644 --- a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql @@ -1,19 +1,19 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT ev_dt AS EV_DT, ev_key AS EV_KEY FROM EVENTS ) SELECT - COUNT(DISTINCT _S0.EV_KEY) AS n_events -FROM _S0 _S0 + COUNT(DISTINCT "_S0".EV_KEY) AS n_events +FROM "_S0" "_S0" JOIN TIMES TIMES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(_S0.EV_DT AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S0".EV_DT AS DATETIME)) AND TIMES.t_name = 'Pre-Dawn' - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(_S0.EV_DT AS DATETIME)) -JOIN _S0 _S2 - ON _S0.EV_KEY = _S2.EV_KEY + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S0".EV_DT AS DATETIME)) +JOIN "_S0" "_S2" + ON "_S0".EV_KEY = "_S2".EV_KEY JOIN ERAS ERAS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(_S2.EV_DT AS DATETIME)) + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATETIME)) AND ERAS.er_name = 'Cold War' - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(_S2.EV_DT AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATETIME)) diff --git a/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql b/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql index 46530b80a..075eb0a4c 100644 --- a/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql +++ b/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql @@ -1,28 +1,28 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT user_id AS USER_ID, user_name AS USER_NAME FROM USERS -), _S1 AS ( +), "_S1" AS ( SELECT search_string AS SEARCH_STRING, search_user_id AS SEARCH_USER_ID FROM SEARCHES ) SELECT - ANY_VALUE(_S0.USER_NAME) AS user_name, - COUNT(DISTINCT _S7.USER_ID) AS n_other_users -FROM _S0 _S0 -JOIN _S1 _S1 - ON _S0.USER_ID = _S1.SEARCH_USER_ID + ANY_VALUE("_S0".USER_NAME) AS user_name, + COUNT(DISTINCT "_S7".USER_ID) AS n_other_users +FROM "_S0" "_S0" +JOIN "_S1" "_S1" + ON "_S0".USER_ID = "_S1".SEARCH_USER_ID JOIN EVENTS EVENTS - ON LOWER(_S1.SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') -JOIN _S1 _S5 - ON LOWER(_S5.SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') -JOIN _S0 _S7 - ON _S0.USER_NAME <> _S7.USER_NAME AND _S5.SEARCH_USER_ID = _S7.USER_ID + ON LOWER("_S1".SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') +JOIN "_S1" "_S5" + ON LOWER("_S5".SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') +JOIN "_S0" "_S7" + ON "_S0".USER_NAME <> "_S7".USER_NAME AND "_S5".SEARCH_USER_ID = "_S7".USER_ID GROUP BY - _S0.USER_ID + "_S0".USER_ID ORDER BY 2 DESC NULLS LAST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql b/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql index ab4c80c99..5d61e2b6c 100644 --- a/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql +++ b/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql @@ -1,30 +1,30 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT user_id AS USER_ID, user_name AS USER_NAME FROM USERS -), _T2 AS ( +), "_T2" AS ( SELECT - _S0.USER_ID, + "_S0".USER_ID, ANY_VALUE(SEARCHES.search_user_id) AS ANYTHING_SEARCH_USER_ID, - ANY_VALUE(_S0.USER_NAME) AS ANYTHING_USER_NAME - FROM _S0 _S0 + ANY_VALUE("_S0".USER_NAME) AS ANYTHING_USER_NAME + FROM "_S0" "_S0" JOIN SEARCHES SEARCHES - ON SEARCHES.search_user_id = _S0.USER_ID + ON SEARCHES.search_user_id = "_S0".USER_ID JOIN EVENTS EVENTS ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') JOIN SEARCHES SEARCHES_2 ON LOWER(SEARCHES_2.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') - JOIN _S0 _S7 - ON SEARCHES_2.search_user_id = _S7.USER_ID AND _S0.USER_NAME <> _S7.USER_NAME + JOIN "_S0" "_S7" + ON SEARCHES_2.search_user_id = "_S7".USER_ID AND "_S0".USER_NAME <> "_S7".USER_NAME GROUP BY SEARCHES.search_id, - _S0.USER_ID + "_S0".USER_ID ) SELECT ANY_VALUE(ANYTHING_USER_NAME) AS user_name, COUNT(*) AS n_searches -FROM _T2 +FROM "_T2" WHERE ANYTHING_SEARCH_USER_ID = USER_ID GROUP BY diff --git a/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql index 55a1b08b5..2df5df362 100644 --- a/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql +++ b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT TIMES.t_name AS T_NAME, ANY_VALUE(TIMES.t_start_hour) AS ANYTHING_T_START_HOUR, @@ -15,6 +15,6 @@ SELECT ROUND(( 100.0 * N_ROWS ) / SUM(N_ROWS) OVER (), 2) AS pct_searches -FROM _T0 +FROM "_T0" ORDER BY ANYTHING_T_START_HOUR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql index 518f51a92..e2145dcc7 100644 --- a/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql +++ b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT TIMES.t_name AS T_NAME, ANY_VALUE(TIMES.t_start_hour) AS ANYTHING_T_START_HOUR, @@ -17,6 +17,6 @@ SELECT 100.0 * N_ROWS ) / SUM(N_ROWS) OVER (), 2) AS pct_searches, ROUND(AVG_SEARCH_NUM_RESULTS, 2) AS avg_results -FROM _T0 +FROM "_T0" ORDER BY ANYTHING_T_START_HOUR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql index 9c93974e4..2edca9da2 100644 --- a/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql +++ b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql @@ -1,8 +1,8 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT DISTINCT search_engine AS SEARCH_ENGINE FROM SEARCHES -), _S1 AS ( +), "_S1" AS ( SELECT search_engine AS SEARCH_ENGINE, COUNT(DISTINCT search_user_id) AS NDISTINCT_SEARCH_USER_ID @@ -14,10 +14,10 @@ WITH _S0 AS ( search_engine ) SELECT - _S0.SEARCH_ENGINE AS engine, - NVL(_S1.NDISTINCT_SEARCH_USER_ID, 0) AS n_users -FROM _S0 _S0 -LEFT JOIN _S1 _S1 - ON _S0.SEARCH_ENGINE = _S1.SEARCH_ENGINE + "_S0".SEARCH_ENGINE AS engine, + NVL("_S1".NDISTINCT_SEARCH_USER_ID, 0) AS n_users +FROM "_S0" "_S0" +LEFT JOIN "_S1" "_S1" + ON "_S0".SEARCH_ENGINE = "_S1".SEARCH_ENGINE ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql index 30588f15b..cf4e87416 100644 --- a/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql +++ b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT ANY_VALUE(SEARCHES.search_user_id) AS ANYTHING_SEARCH_USER_ID FROM SEARCHES SEARCHES @@ -10,20 +10,20 @@ WITH _T1 AS ( AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) GROUP BY SEARCHES.search_id -), _S5 AS ( +), "_S5" AS ( SELECT ANYTHING_SEARCH_USER_ID, COUNT(*) AS N_ROWS - FROM _T1 + FROM "_T1" GROUP BY ANYTHING_SEARCH_USER_ID ) SELECT USERS.user_name, - _S5.N_ROWS AS n_cold_war_searches + "_S5".N_ROWS AS n_cold_war_searches FROM USERS USERS -JOIN _S5 _S5 - ON USERS.user_id = _S5.ANYTHING_SEARCH_USER_ID +JOIN "_S5" "_S5" + ON USERS.user_id = "_S5".ANYTHING_SEARCH_USER_ID ORDER BY 2 DESC NULLS LAST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/first_order_in_year_oracle.sql b/tests/test_sql_refsols/first_order_in_year_oracle.sql index b7bff4dc7..7272558d7 100644 --- a/tests/test_sql_refsols/first_order_in_year_oracle.sql +++ b/tests/test_sql_refsols/first_order_in_year_oracle.sql @@ -1,9 +1,9 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT o_orderdate AS O_ORDERDATE, o_orderkey AS O_ORDERKEY, - LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS _W, - LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS _W_2 + LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS "_W", + LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS "_W_2" FROM TPCH.ORDERS WHERE EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 @@ -11,9 +11,9 @@ WITH _T AS ( SELECT O_ORDERDATE AS order_date, O_ORDERKEY AS key -FROM _T +FROM "_T" WHERE - EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) <> EXTRACT(YEAR FROM CAST(_W_2 AS DATETIME)) - OR _W IS NULL + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) <> EXTRACT(YEAR FROM CAST("_W_2" AS DATETIME)) + OR "_W" IS NULL ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/first_order_per_customer_oracle.sql b/tests/test_sql_refsols/first_order_per_customer_oracle.sql index e13ddceda..f6b67b34f 100644 --- a/tests/test_sql_refsols/first_order_per_customer_oracle.sql +++ b/tests/test_sql_refsols/first_order_per_customer_oracle.sql @@ -1,18 +1,18 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT o_custkey AS O_CUSTKEY, o_orderdate AS O_ORDERDATE, o_totalprice AS O_TOTALPRICE, - ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate, o_orderkey) AS _W + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate, o_orderkey) AS "_W" FROM TPCH.ORDERS ) SELECT CUSTOMER.c_name AS name, - _T.O_ORDERDATE AS first_order_date, - _T.O_TOTALPRICE AS first_order_price + "_T".O_ORDERDATE AS first_order_date, + "_T".O_TOTALPRICE AS first_order_price FROM TPCH.CUSTOMER CUSTOMER -JOIN _T _T - ON CUSTOMER.c_custkey = _T.O_CUSTKEY AND _T._W = 1 +JOIN "_T" "_T" + ON CUSTOMER.c_custkey = "_T".O_CUSTKEY AND "_T"."_W" = 1 WHERE CUSTOMER.c_acctbal >= 9000.0 ORDER BY diff --git a/tests/test_sql_refsols/floor_and_ceil_oracle.sql b/tests/test_sql_refsols/floor_and_ceil_oracle.sql index fbccc9e04..60a8753cb 100644 --- a/tests/test_sql_refsols/floor_and_ceil_oracle.sql +++ b/tests/test_sql_refsols/floor_and_ceil_oracle.sql @@ -8,4 +8,4 @@ SELECT FLOOR(-6) AS floor_int_neg, CEIL(-6) AS ceil_int_neg FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/get_part_multiple_oracle.sql b/tests/test_sql_refsols/get_part_multiple_oracle.sql index 67d366df4..e99f6fe52 100644 --- a/tests/test_sql_refsols/get_part_multiple_oracle.sql +++ b/tests/test_sql_refsols/get_part_multiple_oracle.sql @@ -1,5 +1,5 @@ SELECT - CAST(SUBSTR(sbcustid, 2) AS INT) AS _expr0, + CAST(SUBSTR(sbcustid, 2) AS INT) AS "_expr0", REGEXP_SUBSTR( sbcustname, '[^ ]+', diff --git a/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql index 5f50f8fab..4928cd2c3 100644 --- a/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql +++ b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT c_acctbal AS C_ACCTBAL, CASE @@ -48,4 +48,4 @@ SELECT AVG(EXPR_7) AS median_red_acctbal, AVG(EXPR_5) AS median_black_acctbal, AVG(EXPR_6) AS median_overall_acctbal -FROM _T0 +FROM "_T0" diff --git a/tests/test_sql_refsols/highest_priority_per_year_oracle.sql b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql index a8dc8028e..0b2fc6e24 100644 --- a/tests/test_sql_refsols/highest_priority_per_year_oracle.sql +++ b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql @@ -1,4 +1,4 @@ -WITH _T3 AS ( +WITH "_T3" AS ( SELECT EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, o_orderpriority AS O_ORDERPRIORITY, @@ -7,28 +7,28 @@ WITH _T3 AS ( GROUP BY EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), o_orderpriority -), _T2 AS ( +), "_T2" AS ( SELECT O_ORDERPRIORITY, YEAR_O_ORDERDATE, ( 100.0 * N_ROWS ) / SUM(N_ROWS) OVER (PARTITION BY YEAR_O_ORDERDATE) AS PRIORITY_PCT - FROM _T3 -), _T AS ( + FROM "_T3" +), "_T" AS ( SELECT O_ORDERPRIORITY, YEAR_O_ORDERDATE, PRIORITY_PCT, - ROW_NUMBER() OVER (PARTITION BY YEAR_O_ORDERDATE ORDER BY PRIORITY_PCT DESC) AS _W - FROM _T2 + ROW_NUMBER() OVER (PARTITION BY YEAR_O_ORDERDATE ORDER BY PRIORITY_PCT DESC) AS "_W" + FROM "_T2" ) SELECT YEAR_O_ORDERDATE AS order_year, O_ORDERPRIORITY AS highest_priority, PRIORITY_PCT AS priority_pct -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/hour_minute_day_oracle.sql b/tests/test_sql_refsols/hour_minute_day_oracle.sql index f61e48ec1..6d37fe54b 100644 --- a/tests/test_sql_refsols/hour_minute_day_oracle.sql +++ b/tests/test_sql_refsols/hour_minute_day_oracle.sql @@ -1,8 +1,8 @@ SELECT SBTRANSACTION.sbtxid AS transaction_id, - EXTRACT(HOUR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr0, - EXTRACT(MINUTE FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr1, - EXTRACT(SECOND FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr2 + EXTRACT(HOUR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS "_expr0", + EXTRACT(MINUTE FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS "_expr1", + EXTRACT(SECOND FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS "_expr2" FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBTICKER SBTICKER ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_ansi.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_ansi.sql index 7dd4f0e1f..8a3ab4723 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_ansi.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_ansi.sql @@ -1,7 +1,7 @@ SELECT COALESCE("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, - calculate.".WHERE" AS _where, - calculate."LIKE" AS _like, + calculate.".WHERE" AS "_where", + calculate."LIKE" AS "_like", calculate.datetime, "WHERE".abs, "WHERE".has diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_mysql.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_mysql.sql index b1c01c491..ba06c338d 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_mysql.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_mysql.sql @@ -1,7 +1,7 @@ SELECT COALESCE(`WHERE`.default_to, `WHERE`.`.CALCULATE`) AS calculate2, - CALCULATE.`.WHERE` AS _where, - CALCULATE.`LIKE` AS _like, + CALCULATE.`.WHERE` AS `_where`, + CALCULATE.`LIKE` AS `_like`, CALCULATE.datetime, `WHERE`.abs, `WHERE`.has diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql index c66d1c7d0..0b96c92bf 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql @@ -1,7 +1,7 @@ SELECT NVL("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, - CALCULATE.".WHERE" AS _where, - CALCULATE."LIKE" AS _like, + CALCULATE.".WHERE" AS "_where", + CALCULATE."LIKE" AS "_like", CALCULATE.datetime, "WHERE".abs, "WHERE".has diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_postgres.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_postgres.sql index 7dd4f0e1f..8a3ab4723 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_postgres.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_postgres.sql @@ -1,7 +1,7 @@ SELECT COALESCE("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, - calculate.".WHERE" AS _where, - calculate."LIKE" AS _like, + calculate.".WHERE" AS "_where", + calculate."LIKE" AS "_like", calculate.datetime, "WHERE".abs, "WHERE".has diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_snowflake.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_snowflake.sql index 7dd4f0e1f..8a3ab4723 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_snowflake.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_snowflake.sql @@ -1,7 +1,7 @@ SELECT COALESCE("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, - calculate.".WHERE" AS _where, - calculate."LIKE" AS _like, + calculate.".WHERE" AS "_where", + calculate."LIKE" AS "_like", calculate.datetime, "WHERE".abs, "WHERE".has diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_sqlite.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_sqlite.sql index c7b09e3f5..5c6c510f3 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_sqlite.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_sqlite.sql @@ -1,7 +1,7 @@ SELECT COALESCE("where".default_to, "where".".calculate") AS calculate2, - calculate.".where" AS _where, - calculate."like" AS _like, + calculate.".where" AS "_where", + calculate."like" AS "_like", calculate.datetime, "where".abs, "where".has diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_ansi.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_ansi.sql index 67208d505..da3b6ef6c 100644 --- a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_ansi.sql +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_ansi.sql @@ -1,9 +1,9 @@ SELECT "CAST".id2 AS id1, "CAST".id AS id2, - "lowercase_detail"."select" AS fk1_select, - "lowercase_detail"."as" AS fk1_as, - lowercase_detail_2."two words" AS fk2_two_words + "lowercase_detail"."select" AS "fk1_select", + "lowercase_detail"."as" AS "fk1_as", + lowercase_detail_2."two words" AS "fk2_two_words" FROM keywords."CAST" AS "CAST" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "CAST".id2 = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_mysql.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_mysql.sql index 7dbd9574a..c78f5b8f7 100644 --- a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_mysql.sql +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_mysql.sql @@ -1,9 +1,9 @@ SELECT `CAST`.id2 AS id1, `CAST`.id AS id2, - `lowercase_detail`.`select` AS fk1_select, - `lowercase_detail`.`as` AS fk1_as, - lowercase_detail_2.`two words` AS fk2_two_words + `lowercase_detail`.`select` AS `fk1_select`, + `lowercase_detail`.`as` AS `fk1_as`, + lowercase_detail_2.`two words` AS `fk2_two_words` FROM keywords.`CAST` AS `CAST` JOIN keywords.`lowercase_detail` AS `lowercase_detail` ON `CAST`.id2 = `lowercase_detail`.id diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql index 2b4d0af84..648838cd5 100644 --- a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql @@ -1,9 +1,9 @@ SELECT "CAST".id2 AS id1, "CAST".id AS id2, - "lowercase_detail"."select" AS fk1_select, - "lowercase_detail"."as" AS fk1_as, - lowercase_detail_2."two words" AS fk2_two_words + "lowercase_detail"."select" AS "fk1_select", + "lowercase_detail"."as" AS "fk1_as", + lowercase_detail_2."two words" AS "fk2_two_words" FROM KEYWORDS."CAST" "CAST" JOIN KEYWORDS."lowercase_detail" "lowercase_detail" ON "CAST".id2 = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_postgres.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_postgres.sql index 67208d505..da3b6ef6c 100644 --- a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_postgres.sql +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_postgres.sql @@ -1,9 +1,9 @@ SELECT "CAST".id2 AS id1, "CAST".id AS id2, - "lowercase_detail"."select" AS fk1_select, - "lowercase_detail"."as" AS fk1_as, - lowercase_detail_2."two words" AS fk2_two_words + "lowercase_detail"."select" AS "fk1_select", + "lowercase_detail"."as" AS "fk1_as", + lowercase_detail_2."two words" AS "fk2_two_words" FROM keywords."CAST" AS "CAST" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "CAST".id2 = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_snowflake.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_snowflake.sql index 70b5136ea..3aa531ecc 100644 --- a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_snowflake.sql +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_snowflake.sql @@ -1,9 +1,9 @@ SELECT "CAST".id2 AS id1, "CAST".id AS id2, - "lowercase_detail"."select" AS fk1_select, - "lowercase_detail"."as" AS fk1_as, - lowercase_detail_2."two words" AS fk2_two_words + "lowercase_detail"."select" AS "fk1_select", + "lowercase_detail"."as" AS "fk1_as", + lowercase_detail_2."two words" AS "fk2_two_words" FROM keywords."CAST" AS "CAST" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "CAST".id2 = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_sqlite.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_sqlite.sql index 0837c18bf..79b65037f 100644 --- a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_sqlite.sql +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_sqlite.sql @@ -1,9 +1,9 @@ SELECT "cast".id2 AS id1, "cast".id AS id2, - "lowercase_detail"."select" AS fk1_select, - "lowercase_detail"."as" AS fk1_as, - lowercase_detail_2."two words" AS fk2_two_words + "lowercase_detail"."select" AS "fk1_select", + "lowercase_detail"."as" AS "fk1_as", + lowercase_detail_2."two words" AS "fk2_two_words" FROM keywords."cast" AS "cast" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "cast".id2 = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_ansi.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_ansi.sql index 01f78e568..957d6bc51 100644 --- a/tests/test_sql_refsols/keywords_column_alias_reserved_ansi.sql +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_ansi.sql @@ -1,9 +1,9 @@ SELECT - "MixedCase_1:1"."Id" AS id_, - "MixedCase_1:1"."LowerCaseId" AS LowerCaseID, - "UPPERCASE_MASTER"."INTEGER" AS integer, - "lowercase_detail"."as" AS as_, - "UPPERCASE_MASTER"."ORDER BY" AS order_ + "MixedCase_1:1"."Id" AS "id_", + "MixedCase_1:1"."LowerCaseId" AS "LowerCaseID", + "UPPERCASE_MASTER"."INTEGER" AS "integer", + "lowercase_detail"."as" AS "as_", + "UPPERCASE_MASTER"."ORDER BY" AS "order_" FROM keywords."MixedCase_1:1" AS "MixedCase_1:1" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "MixedCase_1:1"."LowerCaseId" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_mysql.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_mysql.sql index 884f6fbc1..72ea1c4d2 100644 --- a/tests/test_sql_refsols/keywords_column_alias_reserved_mysql.sql +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_mysql.sql @@ -1,9 +1,9 @@ SELECT - `MixedCase_1:1`.`Id` AS id_, - `MixedCase_1:1`.`LowerCaseId` AS LowerCaseID, + `MixedCase_1:1`.`Id` AS `id_`, + `MixedCase_1:1`.`LowerCaseId` AS `LowerCaseID`, `UPPERCASE_MASTER`.`INTEGER` AS `integer`, - `lowercase_detail`.`as` AS as_, - `UPPERCASE_MASTER`.`ORDER BY` AS order_ + `lowercase_detail`.`as` AS `as_`, + `UPPERCASE_MASTER`.`ORDER BY` AS `order_` FROM keywords.`MixedCase_1:1` AS `MixedCase_1:1` JOIN keywords.`lowercase_detail` AS `lowercase_detail` ON `MixedCase_1:1`.`LowerCaseId` = `lowercase_detail`.id diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql index 10b3a0514..8affdea49 100644 --- a/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql @@ -1,9 +1,9 @@ SELECT - "MixedCase_1:1"."Id" AS id_, - "MixedCase_1:1"."LowerCaseId" AS LowerCaseID, - "UPPERCASE_MASTER"."INTEGER" AS integer, - "lowercase_detail"."as" AS as_, - "UPPERCASE_MASTER"."ORDER BY" AS order_ + "MixedCase_1:1"."Id" AS "id_", + "MixedCase_1:1"."LowerCaseId" AS "LowerCaseID", + "UPPERCASE_MASTER"."INTEGER" AS "integer", + "lowercase_detail"."as" AS "as_", + "UPPERCASE_MASTER"."ORDER BY" AS "order_" FROM KEYWORDS."MixedCase_1:1" "MixedCase_1:1" JOIN KEYWORDS."lowercase_detail" "lowercase_detail" ON "MixedCase_1:1"."LowerCaseId" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_postgres.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_postgres.sql index 01f78e568..957d6bc51 100644 --- a/tests/test_sql_refsols/keywords_column_alias_reserved_postgres.sql +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_postgres.sql @@ -1,9 +1,9 @@ SELECT - "MixedCase_1:1"."Id" AS id_, - "MixedCase_1:1"."LowerCaseId" AS LowerCaseID, - "UPPERCASE_MASTER"."INTEGER" AS integer, - "lowercase_detail"."as" AS as_, - "UPPERCASE_MASTER"."ORDER BY" AS order_ + "MixedCase_1:1"."Id" AS "id_", + "MixedCase_1:1"."LowerCaseId" AS "LowerCaseID", + "UPPERCASE_MASTER"."INTEGER" AS "integer", + "lowercase_detail"."as" AS "as_", + "UPPERCASE_MASTER"."ORDER BY" AS "order_" FROM keywords."MixedCase_1:1" AS "MixedCase_1:1" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "MixedCase_1:1"."LowerCaseId" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_snowflake.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_snowflake.sql index 01f78e568..957d6bc51 100644 --- a/tests/test_sql_refsols/keywords_column_alias_reserved_snowflake.sql +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_snowflake.sql @@ -1,9 +1,9 @@ SELECT - "MixedCase_1:1"."Id" AS id_, - "MixedCase_1:1"."LowerCaseId" AS LowerCaseID, - "UPPERCASE_MASTER"."INTEGER" AS integer, - "lowercase_detail"."as" AS as_, - "UPPERCASE_MASTER"."ORDER BY" AS order_ + "MixedCase_1:1"."Id" AS "id_", + "MixedCase_1:1"."LowerCaseId" AS "LowerCaseID", + "UPPERCASE_MASTER"."INTEGER" AS "integer", + "lowercase_detail"."as" AS "as_", + "UPPERCASE_MASTER"."ORDER BY" AS "order_" FROM keywords."MixedCase_1:1" AS "MixedCase_1:1" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "MixedCase_1:1"."LowerCaseId" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_sqlite.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_sqlite.sql index 4fc43615b..4ed67e5aa 100644 --- a/tests/test_sql_refsols/keywords_column_alias_reserved_sqlite.sql +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_sqlite.sql @@ -1,9 +1,9 @@ SELECT - "mixedcase_1:1"."id" AS id_, - "mixedcase_1:1"."lowercaseid" AS LowerCaseID, + "mixedcase_1:1"."id" AS "id_", + "mixedcase_1:1"."lowercaseid" AS "LowerCaseID", "uppercase_master"."integer", - "lowercase_detail"."as" AS as_, - "uppercase_master"."order by" AS order_ + "lowercase_detail"."as" AS "as_", + "uppercase_master"."order by" AS "order_" FROM keywords."mixedcase_1:1" AS "mixedcase_1:1" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON "lowercase_detail"."as" = '10 as reserved word' diff --git a/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql index a0bb869cd..dd42f6bba 100644 --- a/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql +++ b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql @@ -1,8 +1,8 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT MAX("WHERE") AS MAX_WHERE FROM KEYWORDS."PARTITION" -), _S1 AS ( +), "_S1" AS ( SELECT AVG("= ""QUOTE""") AS AVG_QUOTE, COUNT("`cast`") AS COUNT_CAST, @@ -12,11 +12,11 @@ WITH _S0 AS ( FROM KEYWORDS."""QUOTED TABLE_NAME""" ) SELECT - _S0.MAX_WHERE AS max_where, - _S1.MIN_QUOTE AS min_quote, - _S1.MAX_NAME AS max_name, - _S1.COUNT_CAST AS count_cast, - _S1.AVG_QUOTE AS quote_avg, - NVL(_S1.SUM_NAME, 0) AS sum_name -FROM _S0 _S0 -CROSS JOIN _S1 _S1 + "_S0".MAX_WHERE AS max_where, + "_S1".MIN_QUOTE AS min_quote, + "_S1".MAX_NAME AS max_name, + "_S1".COUNT_CAST AS count_cast, + "_S1".AVG_QUOTE AS quote_avg, + NVL("_S1".SUM_NAME, 0) AS sum_name +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_ansi.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_ansi.sql index 52598097c..d289837ee 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_ansi.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_ansi.sql @@ -1,9 +1,9 @@ SELECT - """," AS dbl_quote_dot, - "." AS dot, + """," AS "dbl_quote_dot", + "." AS "dot", "." + COALESCE("FLOAT", str, 1) AS addition, - "__col__" AS col, - "__col1__" AS col1, + "__col__" AS "col", + "__col1__" AS "col1", def AS def_, del AS __del__, "__init__" diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_mysql.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_mysql.sql index 70736e391..19478dfd7 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_mysql.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_mysql.sql @@ -1,9 +1,9 @@ SELECT - `",` AS dbl_quote_dot, - `.` AS dot, + `",` AS `dbl_quote_dot`, + `.` AS `dot`, `.` + COALESCE(`FLOAT`, str, 1) AS addition, - `__col__` AS col, - `__col1__` AS col1, + `__col__` AS `col`, + `__col1__` AS `col1`, def AS def_, del AS __del__, `__init__` diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql index 1e6f25015..a38b0f5ad 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql @@ -1,11 +1,11 @@ SELECT - """," AS dbl_quote_dot, - "." AS dot, + """," AS "dbl_quote_dot", + "." AS "dot", "." + NVL("FLOAT", str, 1) AS addition, - "__col__" AS col, - "__col1__" AS col1, + "__col__" AS "col", + "__col1__" AS "col1", def AS def_, - del AS __del__, + del AS "__del__", "__init__" FROM KEYWORDS."COUNT" WHERE diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_postgres.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_postgres.sql index 52598097c..d289837ee 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_postgres.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_postgres.sql @@ -1,9 +1,9 @@ SELECT - """," AS dbl_quote_dot, - "." AS dot, + """," AS "dbl_quote_dot", + "." AS "dot", "." + COALESCE("FLOAT", str, 1) AS addition, - "__col__" AS col, - "__col1__" AS col1, + "__col__" AS "col", + "__col1__" AS "col1", def AS def_, del AS __del__, "__init__" diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_snowflake.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_snowflake.sql index 52598097c..d289837ee 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_snowflake.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_snowflake.sql @@ -1,9 +1,9 @@ SELECT - """," AS dbl_quote_dot, - "." AS dot, + """," AS "dbl_quote_dot", + "." AS "dot", "." + COALESCE("FLOAT", str, 1) AS addition, - "__col__" AS col, - "__col1__" AS col1, + "__col__" AS "col", + "__col1__" AS "col1", def AS def_, del AS __del__, "__init__" diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_sqlite.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_sqlite.sql index 68610a67c..33be41834 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_sqlite.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_sqlite.sql @@ -1,9 +1,9 @@ SELECT - """," AS dbl_quote_dot, - "." AS dot, + """," AS "dbl_quote_dot", + "." AS "dot", "." + COALESCE("float", str, 1) AS addition, - "__col__" AS col, - "__col1__" AS col1, + "__col__" AS "col", + "__col1__" AS "col1", def AS def_, del AS __del__, "__init__" diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_ansi.sql b/tests/test_sql_refsols/keywords_quoted_table_name_ansi.sql index 9943434ab..5ed1fe4de 100644 --- a/tests/test_sql_refsols/keywords_quoted_table_name_ansi.sql +++ b/tests/test_sql_refsols/keywords_quoted_table_name_ansi.sql @@ -1,9 +1,9 @@ SELECT - """QUOTED TABLE_NAME"""."`cast`" AS cast_, - """QUOTED TABLE_NAME"""."`name""[" AS name, - """QUOTED TABLE_NAME"""."= ""QUOTE""" AS quote_, - "lowercase_detail"."0 = 0 and '" AS _0_0_and, - "lowercase_detail"."as" AS as_ + """QUOTED TABLE_NAME"""."`cast`" AS "cast_", + """QUOTED TABLE_NAME"""."`name""[" AS "name", + """QUOTED TABLE_NAME"""."= ""QUOTE""" AS "quote_", + "lowercase_detail"."0 = 0 and '" AS "_0_0_and", + "lowercase_detail"."as" AS "as_" FROM keywords."""QUOTED TABLE_NAME""" AS """QUOTED TABLE_NAME""" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON """QUOTED TABLE_NAME"""."`name""[" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_mysql.sql b/tests/test_sql_refsols/keywords_quoted_table_name_mysql.sql index 334c8f513..84b6fe2ac 100644 --- a/tests/test_sql_refsols/keywords_quoted_table_name_mysql.sql +++ b/tests/test_sql_refsols/keywords_quoted_table_name_mysql.sql @@ -1,9 +1,9 @@ SELECT - `"QUOTED TABLE_NAME"`.```cast``` AS cast_, - `"QUOTED TABLE_NAME"`.```name"[` AS name, - `"QUOTED TABLE_NAME"`.`= "QUOTE"` AS quote_, - `lowercase_detail`.`0 = 0 and '` AS _0_0_and, - `lowercase_detail`.`as` AS as_ + `"QUOTED TABLE_NAME"`.```cast``` AS `cast_`, + `"QUOTED TABLE_NAME"`.```name"[` AS `name`, + `"QUOTED TABLE_NAME"`.`= "QUOTE"` AS `quote_`, + `lowercase_detail`.`0 = 0 and '` AS `_0_0_and`, + `lowercase_detail`.`as` AS `as_` FROM keywords.`"QUOTED TABLE_NAME"` AS `"QUOTED TABLE_NAME"` JOIN keywords.`lowercase_detail` AS `lowercase_detail` ON `"QUOTED TABLE_NAME"`.```name"[` = `lowercase_detail`.id diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql b/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql index 632332320..dcd4c1e88 100644 --- a/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql +++ b/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql @@ -1,9 +1,9 @@ SELECT - """QUOTED TABLE_NAME"""."`cast`" AS cast_, - """QUOTED TABLE_NAME"""."`name""[" AS name, - """QUOTED TABLE_NAME"""."= ""QUOTE""" AS quote_, - "lowercase_detail"."0 = 0 and '" AS _0_0_and, - "lowercase_detail"."as" AS as_ + """QUOTED TABLE_NAME"""."`cast`" AS "cast_", + """QUOTED TABLE_NAME"""."`name""[" AS "name", + """QUOTED TABLE_NAME"""."= ""QUOTE""" AS "quote_", + "lowercase_detail"."0 = 0 and '" AS "_0_0_and", + "lowercase_detail"."as" AS "as_" FROM KEYWORDS."""QUOTED TABLE_NAME""" """QUOTED TABLE_NAME""" JOIN KEYWORDS."lowercase_detail" "lowercase_detail" ON """QUOTED TABLE_NAME"""."`name""[" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_postgres.sql b/tests/test_sql_refsols/keywords_quoted_table_name_postgres.sql index 9943434ab..5ed1fe4de 100644 --- a/tests/test_sql_refsols/keywords_quoted_table_name_postgres.sql +++ b/tests/test_sql_refsols/keywords_quoted_table_name_postgres.sql @@ -1,9 +1,9 @@ SELECT - """QUOTED TABLE_NAME"""."`cast`" AS cast_, - """QUOTED TABLE_NAME"""."`name""[" AS name, - """QUOTED TABLE_NAME"""."= ""QUOTE""" AS quote_, - "lowercase_detail"."0 = 0 and '" AS _0_0_and, - "lowercase_detail"."as" AS as_ + """QUOTED TABLE_NAME"""."`cast`" AS "cast_", + """QUOTED TABLE_NAME"""."`name""[" AS "name", + """QUOTED TABLE_NAME"""."= ""QUOTE""" AS "quote_", + "lowercase_detail"."0 = 0 and '" AS "_0_0_and", + "lowercase_detail"."as" AS "as_" FROM keywords."""QUOTED TABLE_NAME""" AS """QUOTED TABLE_NAME""" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON """QUOTED TABLE_NAME"""."`name""[" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_snowflake.sql b/tests/test_sql_refsols/keywords_quoted_table_name_snowflake.sql index 9943434ab..5ed1fe4de 100644 --- a/tests/test_sql_refsols/keywords_quoted_table_name_snowflake.sql +++ b/tests/test_sql_refsols/keywords_quoted_table_name_snowflake.sql @@ -1,9 +1,9 @@ SELECT - """QUOTED TABLE_NAME"""."`cast`" AS cast_, - """QUOTED TABLE_NAME"""."`name""[" AS name, - """QUOTED TABLE_NAME"""."= ""QUOTE""" AS quote_, - "lowercase_detail"."0 = 0 and '" AS _0_0_and, - "lowercase_detail"."as" AS as_ + """QUOTED TABLE_NAME"""."`cast`" AS "cast_", + """QUOTED TABLE_NAME"""."`name""[" AS "name", + """QUOTED TABLE_NAME"""."= ""QUOTE""" AS "quote_", + "lowercase_detail"."0 = 0 and '" AS "_0_0_and", + "lowercase_detail"."as" AS "as_" FROM keywords."""QUOTED TABLE_NAME""" AS """QUOTED TABLE_NAME""" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON """QUOTED TABLE_NAME"""."`name""[" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_sqlite.sql b/tests/test_sql_refsols/keywords_quoted_table_name_sqlite.sql index e130322a3..ed86f2957 100644 --- a/tests/test_sql_refsols/keywords_quoted_table_name_sqlite.sql +++ b/tests/test_sql_refsols/keywords_quoted_table_name_sqlite.sql @@ -1,9 +1,9 @@ SELECT - """quoted table_name"""."`cast`" AS cast_, - """quoted table_name"""."`name""[" AS name, - """quoted table_name"""."= ""quote""" AS quote_, - "lowercase_detail"."0 = 0 and '" AS _0_0_and, - "lowercase_detail"."as" AS as_ + """quoted table_name"""."`cast`" AS "cast_", + """quoted table_name"""."`name""[" AS "name", + """quoted table_name"""."= ""quote""" AS "quote_", + "lowercase_detail"."0 = 0 and '" AS "_0_0_and", + "lowercase_detail"."as" AS "as_" FROM keywords."""quoted table_name""" AS """quoted table_name""" JOIN keywords."lowercase_detail" AS "lowercase_detail" ON """quoted table_name"""."`name""[" = "lowercase_detail".id diff --git a/tests/test_sql_refsols/many_net_filter_4_oracle.sql b/tests/test_sql_refsols/many_net_filter_4_oracle.sql index 4d1be14b4..684779a0b 100644 --- a/tests/test_sql_refsols/many_net_filter_4_oracle.sql +++ b/tests/test_sql_refsols/many_net_filter_4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT n_nationkey AS N_NATIONKEY, n_regionkey AS N_REGIONKEY @@ -7,12 +7,12 @@ WITH _S1 AS ( SELECT COUNT(*) AS n FROM TPCH.SUPPLIER SUPPLIER -JOIN _S1 _S1 - ON SUPPLIER.s_nationkey = _S1.N_NATIONKEY -JOIN _S1 _S3 - ON _S1.N_REGIONKEY = _S3.N_REGIONKEY +JOIN "_S1" "_S1" + ON SUPPLIER.s_nationkey = "_S1".N_NATIONKEY +JOIN "_S1" "_S3" + ON "_S1".N_REGIONKEY = "_S3".N_REGIONKEY JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey - AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY + AND CUSTOMER.c_nationkey = "_S3".N_NATIONKEY WHERE SUPPLIER.s_nationkey = 4 diff --git a/tests/test_sql_refsols/many_net_filter_7_oracle.sql b/tests/test_sql_refsols/many_net_filter_7_oracle.sql index edf363166..9bb8020d2 100644 --- a/tests/test_sql_refsols/many_net_filter_7_oracle.sql +++ b/tests/test_sql_refsols/many_net_filter_7_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT n_nationkey AS N_NATIONKEY, n_regionkey AS N_REGIONKEY @@ -7,11 +7,11 @@ WITH _S1 AS ( SELECT COUNT(*) AS n FROM TPCH.SUPPLIER SUPPLIER -JOIN _S1 _S1 - ON SUPPLIER.s_nationkey = _S1.N_NATIONKEY -JOIN _S1 _S3 - ON _S1.N_REGIONKEY = _S3.N_REGIONKEY +JOIN "_S1" "_S1" + ON SUPPLIER.s_nationkey = "_S1".N_NATIONKEY +JOIN "_S1" "_S3" + ON "_S1".N_REGIONKEY = "_S3".N_REGIONKEY JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey AND CUSTOMER.c_nationkey = 7 - AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY + AND CUSTOMER.c_nationkey = "_S3".N_NATIONKEY diff --git a/tests/test_sql_refsols/menu_5556_oracle.sql b/tests/test_sql_refsols/menu_5556_oracle.sql index 52047c5f0..7f2d4edbb 100644 --- a/tests/test_sql_refsols/menu_5556_oracle.sql +++ b/tests/test_sql_refsols/menu_5556_oracle.sql @@ -1,28 +1,28 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT 1 AS N_ROWS, id AS ID FROM MAIN.DISH WHERE LOWER(name) = 'baked apples with cream' -), _T1 AS ( +), "_T1" AS ( SELECT MENUPAGE.menu_id AS MENU_ID, MAX(MENUITEM.price) AS MAX_PRICE, - SUM(_S3.N_ROWS) AS SUM_N_ROWS + SUM("_S3".N_ROWS) AS SUM_N_ROWS FROM MAIN.MENUPAGE MENUPAGE JOIN MAIN.MENUITEM MENUITEM ON MENUITEM.menu_page_id = MENUPAGE.id - LEFT JOIN _S3 _S3 - ON MENUITEM.dish_id = _S3.ID + LEFT JOIN "_S3" "_S3" + ON MENUITEM.dish_id = "_S3".ID GROUP BY MENUPAGE.menu_id ) SELECT MENU.sponsor FROM MAIN.MENU MENU -JOIN _T1 _T1 - ON MENU.id = _T1.MENU_ID AND _T1.SUM_N_ROWS <> 0 +JOIN "_T1" "_T1" + ON MENU.id = "_T1".MENU_ID AND "_T1".SUM_N_ROWS <> 0 ORDER BY - _T1.MAX_PRICE DESC NULLS LAST + "_T1".MAX_PRICE DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql index b35180fcb..47dcc9e1c 100644 --- a/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql +++ b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql @@ -1,4 +1,4 @@ -WITH _T7 AS ( +WITH "_T7" AS ( SELECT o_orderdate AS O_ORDERDATE, o_orderpriority AS O_ORDERPRIORITY, @@ -6,47 +6,47 @@ WITH _T7 AS ( FROM TPCH.ORDERS WHERE o_orderpriority = '1-URGENT' -), _T5 AS ( +), "_T5" AS ( SELECT EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE - FROM _T7 + FROM "_T7" GROUP BY EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) -), _T4 AS ( +), "_T4" AS ( SELECT SUM_O_TOTALPRICE, YEAR_O_ORDERDATE, LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE) AS NEXT_YEAR_TOTAL_SPENT - FROM _T5 -), _T2 AS ( + FROM "_T5" +), "_T2" AS ( SELECT - EXTRACT(MONTH FROM CAST(_T8.O_ORDERDATE AS DATETIME)) AS MONTH_O_ORDERDATE, - EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, - SUM(_T8.O_TOTALPRICE) AS SUM_O_TOTALPRICE - FROM _T4 _T4 - JOIN _T7 _T8 - ON _T4.YEAR_O_ORDERDATE = EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) + EXTRACT(MONTH FROM CAST("_T8".O_ORDERDATE AS DATETIME)) AS MONTH_O_ORDERDATE, + EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + SUM("_T8".O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM "_T4" "_T4" + JOIN "_T7" "_T8" + ON "_T4".YEAR_O_ORDERDATE = EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATETIME)) WHERE - _T4.NEXT_YEAR_TOTAL_SPENT < NVL(_T4.SUM_O_TOTALPRICE, 0) + "_T4".NEXT_YEAR_TOTAL_SPENT < NVL("_T4".SUM_O_TOTALPRICE, 0) GROUP BY - EXTRACT(MONTH FROM CAST(_T8.O_ORDERDATE AS DATETIME)), - EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) -), _T AS ( + EXTRACT(MONTH FROM CAST("_T8".O_ORDERDATE AS DATETIME)), + EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATETIME)) +), "_T" AS ( SELECT MONTH_O_ORDERDATE, YEAR_O_ORDERDATE, SUM_O_TOTALPRICE, - LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS _W, - LAG(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS _W_2 - FROM _T2 + LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS "_W", + LAG(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS "_W_2" + FROM "_T2" ) SELECT YEAR_O_ORDERDATE AS year, MONTH_O_ORDERDATE AS month -FROM _T +FROM "_T" WHERE - _W < NVL(SUM_O_TOTALPRICE, 0) AND _W_2 < NVL(SUM_O_TOTALPRICE, 0) + "_W" < NVL(SUM_O_TOTALPRICE, 0) AND "_W_2" < NVL(SUM_O_TOTALPRICE, 0) ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/n_orders_first_day_oracle.sql b/tests/test_sql_refsols/n_orders_first_day_oracle.sql index 9c364559c..116e642b0 100644 --- a/tests/test_sql_refsols/n_orders_first_day_oracle.sql +++ b/tests/test_sql_refsols/n_orders_first_day_oracle.sql @@ -1,10 +1,10 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT - RANK() OVER (ORDER BY o_orderdate) AS _W + RANK() OVER (ORDER BY o_orderdate) AS "_W" FROM TPCH.ORDERS ) SELECT COUNT(*) AS n_orders -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql index ef73f8bb2..ff3dab5ad 100644 --- a/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql +++ b/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_nationkey AS C_NATIONKEY, @@ -55,7 +55,7 @@ SELECT AVG(EXPR_7) AS median_red_acctbal, AVG(EXPR_5) AS median_black_acctbal, AVG(EXPR_6) AS median_overall_acctbal -FROM _T1 +FROM "_T1" GROUP BY C_NATIONKEY ORDER BY diff --git a/tests/test_sql_refsols/nation_best_order_oracle.sql b/tests/test_sql_refsols/nation_best_order_oracle.sql index 94b746662..2260b6813 100644 --- a/tests/test_sql_refsols/nation_best_order_oracle.sql +++ b/tests/test_sql_refsols/nation_best_order_oracle.sql @@ -1,4 +1,4 @@ -WITH _T3 AS ( +WITH "_T3" AS ( SELECT CUSTOMER.c_name AS C_NAME, CUSTOMER.c_nationkey AS C_NATIONKEY, @@ -11,26 +11,26 @@ WITH _T3 AS ( JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 -), _T AS ( +), "_T" AS ( SELECT C_NAME, C_NATIONKEY, O_ORDERKEY, O_TOTALPRICE, VALUE_PERCENTAGE, - ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY O_TOTALPRICE DESC) AS _W - FROM _T3 + ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY O_TOTALPRICE DESC) AS "_W" + FROM "_T3" ) SELECT NATION.n_name AS nation_name, - _T.C_NAME AS customer_name, - _T.O_ORDERKEY AS order_key, - _T.O_TOTALPRICE AS order_value, - _T.VALUE_PERCENTAGE AS value_percentage + "_T".C_NAME AS customer_name, + "_T".O_ORDERKEY AS order_key, + "_T".O_TOTALPRICE AS order_value, + "_T".VALUE_PERCENTAGE AS value_percentage FROM TPCH.NATION NATION JOIN TPCH.REGION REGION ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' -JOIN _T _T - ON NATION.n_nationkey = _T.C_NATIONKEY AND _T._W = 1 +JOIN "_T" "_T" + ON NATION.n_nationkey = "_T".C_NATIONKEY AND "_T"."_W" = 1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/order_info_per_priority_oracle.sql b/tests/test_sql_refsols/order_info_per_priority_oracle.sql index 4824c7fde..85b335d37 100644 --- a/tests/test_sql_refsols/order_info_per_priority_oracle.sql +++ b/tests/test_sql_refsols/order_info_per_priority_oracle.sql @@ -1,9 +1,9 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT o_orderkey AS O_ORDERKEY, o_orderpriority AS O_ORDERPRIORITY, o_totalprice AS O_TOTALPRICE, - ROW_NUMBER() OVER (PARTITION BY o_orderpriority ORDER BY o_totalprice DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY o_orderpriority ORDER BY o_totalprice DESC) AS "_W" FROM TPCH.ORDERS WHERE EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 @@ -12,8 +12,8 @@ SELECT O_ORDERPRIORITY AS order_priority, O_ORDERKEY AS order_key, O_TOTALPRICE AS order_total_price -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql index a76fa5d8e..7e260dcf3 100644 --- a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql +++ b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql @@ -1,36 +1,36 @@ -WITH _S4 AS ( +WITH "_S4" AS ( SELECT o_custkey AS O_CUSTKEY, o_orderdate AS O_ORDERDATE, o_orderkey AS O_ORDERKEY FROM TPCH.ORDERS -), _T AS ( +), "_T" AS ( SELECT CUSTOMER.c_custkey AS C_CUSTKEY, CUSTOMER.c_name AS C_NAME, - _S3.O_ORDERDATE, - ROW_NUMBER() OVER (PARTITION BY _S3.O_CUSTKEY ORDER BY _S3.O_ORDERDATE, _S3.O_ORDERKEY) AS _W + "_S3".O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY "_S3".O_CUSTKEY ORDER BY "_S3".O_ORDERDATE, "_S3".O_ORDERKEY) AS "_W" FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'VIETNAM' - JOIN _S4 _S3 - ON CUSTOMER.c_custkey = _S3.O_CUSTKEY -), _S5 AS ( + JOIN "_S4" "_S3" + ON CUSTOMER.c_custkey = "_S3".O_CUSTKEY +), "_S5" AS ( SELECT C_CUSTKEY, C_NAME, O_ORDERDATE - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 ) SELECT - _S5.C_NAME AS customer_name, - _S4.O_ORDERKEY AS order_key, - DATEDIFF(CAST(_S4.O_ORDERDATE AS DATETIME), CAST(_S5.O_ORDERDATE AS DATETIME), DAY) AS days_since_first_order -FROM _S4 _S4 -LEFT JOIN _S5 _S5 - ON _S4.O_CUSTKEY = _S5.C_CUSTKEY + "_S5".C_NAME AS customer_name, + "_S4".O_ORDERKEY AS order_key, + DATEDIFF(CAST("_S4".O_ORDERDATE AS DATETIME), CAST("_S5".O_ORDERDATE AS DATETIME), DAY) AS days_since_first_order +FROM "_S4" "_S4" +LEFT JOIN "_S5" "_S5" + ON "_S4".O_CUSTKEY = "_S5".C_CUSTKEY ORDER BY 3 DESC NULLS LAST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_a_oracle.sql b/tests/test_sql_refsols/part_cross_part_a_oracle.sql index cb017e43d..0e0c73108 100644 --- a/tests/test_sql_refsols/part_cross_part_a_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_a_oracle.sql @@ -1,35 +1,35 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT DISTINCT sbtickerexchange AS SBTICKEREXCHANGE FROM MAIN.SBTICKER -), _S9 AS ( +), "_S9" AS ( SELECT SBCUSTOMER.sbcustid AS SBCUSTID, - _S2.SBTICKEREXCHANGE, + "_S2".SBTICKEREXCHANGE, COUNT(*) AS N_ROWS - FROM _S0 _S2 + FROM "_S0" "_S2" CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER JOIN MAIN.SBTRANSACTION SBTRANSACTION ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid JOIN MAIN.SBTICKER SBTICKER - ON SBTICKER.sbtickerexchange = _S2.SBTICKEREXCHANGE + ON SBTICKER.sbtickerexchange = "_S2".SBTICKEREXCHANGE AND SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid GROUP BY SBCUSTOMER.sbcustid, - _S2.SBTICKEREXCHANGE + "_S2".SBTICKEREXCHANGE ) SELECT SBCUSTOMER.sbcuststate AS state, - _S0.SBTICKEREXCHANGE AS exchange, - NVL(SUM(_S9.N_ROWS), 0) AS n -FROM _S0 _S0 + "_S0".SBTICKEREXCHANGE AS exchange, + NVL(SUM("_S9".N_ROWS), 0) AS n +FROM "_S0" "_S0" CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER -LEFT JOIN _S9 _S9 - ON SBCUSTOMER.sbcustid = _S9.SBCUSTID - AND _S0.SBTICKEREXCHANGE = _S9.SBTICKEREXCHANGE +LEFT JOIN "_S9" "_S9" + ON SBCUSTOMER.sbcustid = "_S9".SBCUSTID + AND "_S0".SBTICKEREXCHANGE = "_S9".SBTICKEREXCHANGE GROUP BY SBCUSTOMER.sbcuststate, - _S0.SBTICKEREXCHANGE + "_S0".SBTICKEREXCHANGE ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_b_oracle.sql b/tests/test_sql_refsols/part_cross_part_b_oracle.sql index aff0ebb50..dc55f69f2 100644 --- a/tests/test_sql_refsols/part_cross_part_b_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_b_oracle.sql @@ -1,46 +1,46 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT DISTINCT sbcuststate AS SBCUSTSTATE FROM MAIN.SBCUSTOMER -), _T2 AS ( +), "_T2" AS ( SELECT sbtxdatetime AS SBTXDATETIME FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 -), _S1 AS ( +), "_S1" AS ( SELECT DISTINCT TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH - FROM _T2 -), _S3 AS ( + FROM "_T2" +), "_S3" AS ( SELECT DISTINCT TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH - FROM _T2 -), _S9 AS ( + FROM "_T2" +), "_S9" AS ( SELECT - _S3.MONTH, - _S2.SBCUSTSTATE, + "_S3".MONTH, + "_S2".SBCUSTSTATE, COUNT(*) AS N_ROWS - FROM _S0 _S2 - CROSS JOIN _S3 _S3 + FROM "_S0" "_S2" + CROSS JOIN "_S3" "_S3" JOIN MAIN.SBTRANSACTION SBTRANSACTION ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 - AND _S3.MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid - AND SBCUSTOMER.sbcuststate = _S2.SBCUSTSTATE + AND SBCUSTOMER.sbcuststate = "_S2".SBCUSTSTATE GROUP BY - _S3.MONTH, - _S2.SBCUSTSTATE + "_S3".MONTH, + "_S2".SBCUSTSTATE ) SELECT - _S0.SBCUSTSTATE AS state, - _S1.MONTH AS month_of_year, - SUM(NVL(_S9.N_ROWS, 0)) OVER (PARTITION BY _S0.SBCUSTSTATE ORDER BY _S1.MONTH ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n -FROM _S0 _S0 -CROSS JOIN _S1 _S1 -LEFT JOIN _S9 _S9 - ON _S0.SBCUSTSTATE = _S9.SBCUSTSTATE AND _S1.MONTH = _S9.MONTH + "_S0".SBCUSTSTATE AS state, + "_S1".MONTH AS month_of_year, + SUM(NVL("_S9".N_ROWS, 0)) OVER (PARTITION BY "_S0".SBCUSTSTATE ORDER BY "_S1".MONTH ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" +LEFT JOIN "_S9" "_S9" + ON "_S0".SBCUSTSTATE = "_S9".SBCUSTSTATE AND "_S1".MONTH = "_S9".MONTH ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_c_oracle.sql b/tests/test_sql_refsols/part_cross_part_c_oracle.sql index 44e2df7f9..b2cc55022 100644 --- a/tests/test_sql_refsols/part_cross_part_c_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_c_oracle.sql @@ -1,44 +1,44 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT DISTINCT sbcuststate AS SBCUSTSTATE FROM MAIN.SBCUSTOMER -), _T2 AS ( +), "_T2" AS ( SELECT sbtxdatetime AS SBTXDATETIME FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 -), _S1 AS ( +), "_S1" AS ( SELECT DISTINCT TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH - FROM _T2 -), _S3 AS ( + FROM "_T2" +), "_S3" AS ( SELECT DISTINCT TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH - FROM _T2 -), _S9 AS ( + FROM "_T2" +), "_S9" AS ( SELECT - _S3.MONTH, - _S2.SBCUSTSTATE, + "_S3".MONTH, + "_S2".SBCUSTSTATE, COUNT(*) AS N_ROWS - FROM _S0 _S2 - CROSS JOIN _S3 _S3 + FROM "_S0" "_S2" + CROSS JOIN "_S3" "_S3" JOIN MAIN.SBTRANSACTION SBTRANSACTION ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 - AND _S3.MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid - AND SBCUSTOMER.sbcuststate = _S2.SBCUSTSTATE + AND SBCUSTOMER.sbcuststate = "_S2".SBCUSTSTATE GROUP BY - _S3.MONTH, - _S2.SBCUSTSTATE + "_S3".MONTH, + "_S2".SBCUSTSTATE ) SELECT - _S0.SBCUSTSTATE AS state, - MAX(NVL(_S9.N_ROWS, 0)) AS max_n -FROM _S0 _S0 -CROSS JOIN _S1 _S1 -LEFT JOIN _S9 _S9 - ON _S0.SBCUSTSTATE = _S9.SBCUSTSTATE AND _S1.MONTH = _S9.MONTH + "_S0".SBCUSTSTATE AS state, + MAX(NVL("_S9".N_ROWS, 0)) AS max_n +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" +LEFT JOIN "_S9" "_S9" + ON "_S0".SBCUSTSTATE = "_S9".SBCUSTSTATE AND "_S1".MONTH = "_S9".MONTH GROUP BY - _S0.SBCUSTSTATE + "_S0".SBCUSTSTATE diff --git a/tests/test_sql_refsols/part_reduced_size_oracle.sql b/tests/test_sql_refsols/part_reduced_size_oracle.sql index a8675c6dd..0920fad07 100644 --- a/tests/test_sql_refsols/part_reduced_size_oracle.sql +++ b/tests/test_sql_refsols/part_reduced_size_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT p_partkey AS P_PARTKEY, p_retailprice AS P_RETAILPRICE, @@ -9,16 +9,16 @@ WITH _S0 AS ( FETCH FIRST 2 ROWS ONLY ) SELECT - CAST(_S0.P_SIZE / 2.5 AS DOUBLE PRECISION) AS reduced_size, - CAST(_S0.P_RETAILPRICE AS INT) AS retail_price_int, - LISTAGG('', 'old size: ', CAST(_S0.P_SIZE AS CLOB)) AS message, + CAST("_S0".P_SIZE / 2.5 AS DOUBLE PRECISION) AS reduced_size, + CAST("_S0".P_RETAILPRICE AS INT) AS retail_price_int, + LISTAGG('', 'old size: ', CAST("_S0".P_SIZE AS CLOB)) AS message, LINEITEM.l_discount AS discount, TO_CHAR(LINEITEM.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, TO_CHAR(LINEITEM.l_receiptdate, 'MM/DD') AS date_md, TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MIP.M.') AS am_pm -FROM _S0 _S0 +FROM "_S0" "_S0" JOIN TPCH.LINEITEM LINEITEM - ON LINEITEM.l_partkey = _S0.P_PARTKEY + ON LINEITEM.l_partkey = "_S0".P_PARTKEY ORDER BY 4 DESC NULLS LAST, 5 NULLS FIRST diff --git a/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql index 58ed7cd20..8b99c5d82 100644 --- a/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql +++ b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql @@ -1,4 +1,4 @@ -WITH _T4 AS ( +WITH "_T4" AS ( SELECT l_orderkey AS L_ORDERKEY, l_partkey AS L_PARTKEY, @@ -7,35 +7,35 @@ WITH _T4 AS ( FROM TPCH.LINEITEM WHERE l_shipmode = 'RAIL' -), _S6 AS ( +), "_S6" AS ( SELECT - _T4.L_PARTKEY, + "_T4".L_PARTKEY, ANY_VALUE(PART.p_name) AS ANYTHING_P_NAME, - SUM(_T4.L_QUANTITY) AS SUM_L_QUANTITY + SUM("_T4".L_QUANTITY) AS SUM_L_QUANTITY FROM TPCH.PART PART - JOIN _T4 _T4 - ON PART.p_partkey = _T4.L_PARTKEY + JOIN "_T4" "_T4" + ON PART.p_partkey = "_T4".L_PARTKEY JOIN TPCH.ORDERS ORDERS ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 - AND ORDERS.o_orderkey = _T4.L_ORDERKEY + AND ORDERS.o_orderkey = "_T4".L_ORDERKEY WHERE PART.p_container LIKE 'SM%' GROUP BY - _T4.L_PARTKEY + "_T4".L_PARTKEY ) SELECT - ANY_VALUE(_S6.ANYTHING_P_NAME) AS name, - NVL(ANY_VALUE(_S6.SUM_L_QUANTITY), 0) AS qty_95, - NVL(SUM(_T6.L_QUANTITY), 0) AS qty_96 -FROM _S6 _S6 -JOIN _T4 _T6 - ON _S6.L_PARTKEY = _T6.L_PARTKEY + ANY_VALUE("_S6".ANYTHING_P_NAME) AS name, + NVL(ANY_VALUE("_S6".SUM_L_QUANTITY), 0) AS qty_95, + NVL(SUM("_T6".L_QUANTITY), 0) AS qty_96 +FROM "_S6" "_S6" +JOIN "_T4" "_T6" + ON "_S6".L_PARTKEY = "_T6".L_PARTKEY JOIN TPCH.ORDERS ORDERS ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1996 - AND ORDERS.o_orderkey = _T6.L_ORDERKEY + AND ORDERS.o_orderkey = "_T6".L_ORDERKEY GROUP BY - _T6.L_PARTKEY + "_T6".L_PARTKEY ORDER BY - NVL(SUM(_T6.L_QUANTITY), 0) - NVL(ANY_VALUE(_S6.SUM_L_QUANTITY), 0) DESC NULLS LAST, + NVL(SUM("_T6".L_QUANTITY), 0) - NVL(ANY_VALUE("_S6".SUM_L_QUANTITY), 0) DESC NULLS LAST, 1 NULLS FIRST FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql index 2e021f3ea..239e53a08 100644 --- a/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql +++ b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql @@ -1,16 +1,16 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT CUSTOMER.c_name AS C_NAME, CUSTOMER.c_phone AS C_PHONE, - NTILE(100) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal) AS _W + NTILE(100) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal) AS "_W" FROM TPCH.NATION NATION JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_nationkey = NATION.n_nationkey ) SELECT C_NAME AS name -FROM _T +FROM "_T" WHERE - C_PHONE LIKE '%00' AND _W = 95 + C_PHONE LIKE '%00' AND "_W" = 95 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_1_oracle.sql b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql index e44b1431c..ff802f162 100644 --- a/tests/test_sql_refsols/quantile_function_test_1_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT CASE WHEN FLOOR(0.3 * COUNT(o_totalprice) OVER ()) < ROW_NUMBER() OVER (ORDER BY o_totalprice DESC NULLS LAST) @@ -11,4 +11,4 @@ WITH _T0 AS ( ) SELECT MAX(EXPR_1) AS seventieth_order_price -FROM _T0 +FROM "_T0" diff --git a/tests/test_sql_refsols/quantile_function_test_2_oracle.sql b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql index 3c129aed5..2e1484ac1 100644 --- a/tests/test_sql_refsols/quantile_function_test_2_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT n_name AS N_NAME, n_nationkey AS N_NATIONKEY, @@ -7,7 +7,7 @@ WITH _S0 AS ( ORDER BY 1 NULLS FIRST FETCH FIRST 5 ROWS ONLY -), _S5 AS ( +), "_S5" AS ( SELECT CUSTOMER.c_nationkey AS C_NATIONKEY, ORDERS.o_totalprice AS O_TOTALPRICE @@ -15,52 +15,52 @@ WITH _S0 AS ( JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 -), _T1 AS ( +), "_T1" AS ( SELECT - _S0.N_NAME, - _S0.N_NATIONKEY, - _S5.O_TOTALPRICE, + "_S0".N_NAME, + "_S0".N_NATIONKEY, + "_S5".O_TOTALPRICE, REGION.r_name AS R_NAME, CASE - WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.99 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_10, CASE - WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.75 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_11, CASE - WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.25 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_12, CASE - WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.1 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_13, CASE - WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.01 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_14, CASE - WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.5 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_15, CASE - WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.9 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_9 - FROM _S0 _S0 + FROM "_S0" "_S0" JOIN TPCH.REGION REGION - ON REGION.r_regionkey = _S0.N_REGIONKEY - LEFT JOIN _S5 _S5 - ON _S0.N_NATIONKEY = _S5.C_NATIONKEY + ON REGION.r_regionkey = "_S0".N_REGIONKEY + LEFT JOIN "_S5" "_S5" + ON "_S0".N_NATIONKEY = "_S5".C_NATIONKEY ) SELECT ANY_VALUE(R_NAME) AS region_name, @@ -74,7 +74,7 @@ SELECT MAX(EXPR_13) AS orders_90_percent, MAX(EXPR_14) AS orders_99_percent, MAX(O_TOTALPRICE) AS orders_max -FROM _T1 +FROM "_T1" GROUP BY N_NATIONKEY ORDER BY diff --git a/tests/test_sql_refsols/quantile_function_test_3_oracle.sql b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql index 3c129aed5..2e1484ac1 100644 --- a/tests/test_sql_refsols/quantile_function_test_3_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT n_name AS N_NAME, n_nationkey AS N_NATIONKEY, @@ -7,7 +7,7 @@ WITH _S0 AS ( ORDER BY 1 NULLS FIRST FETCH FIRST 5 ROWS ONLY -), _S5 AS ( +), "_S5" AS ( SELECT CUSTOMER.c_nationkey AS C_NATIONKEY, ORDERS.o_totalprice AS O_TOTALPRICE @@ -15,52 +15,52 @@ WITH _S0 AS ( JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 -), _T1 AS ( +), "_T1" AS ( SELECT - _S0.N_NAME, - _S0.N_NATIONKEY, - _S5.O_TOTALPRICE, + "_S0".N_NAME, + "_S0".N_NATIONKEY, + "_S5".O_TOTALPRICE, REGION.r_name AS R_NAME, CASE - WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.99 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_10, CASE - WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.75 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_11, CASE - WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.25 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_12, CASE - WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.1 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_13, CASE - WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.01 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_14, CASE - WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.5 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_15, CASE - WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.9 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_9 - FROM _S0 _S0 + FROM "_S0" "_S0" JOIN TPCH.REGION REGION - ON REGION.r_regionkey = _S0.N_REGIONKEY - LEFT JOIN _S5 _S5 - ON _S0.N_NATIONKEY = _S5.C_NATIONKEY + ON REGION.r_regionkey = "_S0".N_REGIONKEY + LEFT JOIN "_S5" "_S5" + ON "_S0".N_NATIONKEY = "_S5".C_NATIONKEY ) SELECT ANY_VALUE(R_NAME) AS region_name, @@ -74,7 +74,7 @@ SELECT MAX(EXPR_13) AS orders_90_percent, MAX(EXPR_14) AS orders_99_percent, MAX(O_TOTALPRICE) AS orders_max -FROM _T1 +FROM "_T1" GROUP BY N_NATIONKEY ORDER BY diff --git a/tests/test_sql_refsols/quantile_function_test_4_oracle.sql b/tests/test_sql_refsols/quantile_function_test_4_oracle.sql index 1e74b3980..84a3f2f3c 100644 --- a/tests/test_sql_refsols/quantile_function_test_4_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_4_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT n_name AS N_NAME, n_nationkey AS N_NATIONKEY, @@ -7,59 +7,59 @@ WITH _S0 AS ( ORDER BY 1 NULLS FIRST FETCH FIRST 5 ROWS ONLY -), _S5 AS ( +), "_S5" AS ( SELECT CUSTOMER.c_nationkey AS C_NATIONKEY, ORDERS.o_totalprice AS O_TOTALPRICE FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000272' -), _T1 AS ( +), "_T1" AS ( SELECT - _S0.N_NAME, - _S0.N_NATIONKEY, - _S5.O_TOTALPRICE, + "_S0".N_NAME, + "_S0".N_NATIONKEY, + "_S5".O_TOTALPRICE, REGION.r_name AS R_NAME, CASE - WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.99 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_10, CASE - WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.75 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_11, CASE - WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.25 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_12, CASE - WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.1 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_13, CASE - WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.01 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_14, CASE - WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.5 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_15, CASE - WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.9 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_9 - FROM _S0 _S0 + FROM "_S0" "_S0" JOIN TPCH.REGION REGION - ON REGION.r_regionkey = _S0.N_REGIONKEY - LEFT JOIN _S5 _S5 - ON _S0.N_NATIONKEY = _S5.C_NATIONKEY + ON REGION.r_regionkey = "_S0".N_REGIONKEY + LEFT JOIN "_S5" "_S5" + ON "_S0".N_NATIONKEY = "_S5".C_NATIONKEY ) SELECT ANY_VALUE(R_NAME) AS region_name, @@ -73,7 +73,7 @@ SELECT MAX(EXPR_13) AS orders_90_percent, MAX(EXPR_14) AS orders_99_percent, MAX(O_TOTALPRICE) AS orders_max -FROM _T1 +FROM "_T1" GROUP BY N_NATIONKEY ORDER BY diff --git a/tests/test_sql_refsols/quantile_test_1_oracle.sql b/tests/test_sql_refsols/quantile_test_1_oracle.sql index e44b1431c..ff802f162 100644 --- a/tests/test_sql_refsols/quantile_test_1_oracle.sql +++ b/tests/test_sql_refsols/quantile_test_1_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT CASE WHEN FLOOR(0.3 * COUNT(o_totalprice) OVER ()) < ROW_NUMBER() OVER (ORDER BY o_totalprice DESC NULLS LAST) @@ -11,4 +11,4 @@ WITH _T0 AS ( ) SELECT MAX(EXPR_1) AS seventieth_order_price -FROM _T0 +FROM "_T0" diff --git a/tests/test_sql_refsols/quantile_test_2_oracle.sql b/tests/test_sql_refsols/quantile_test_2_oracle.sql index 3c129aed5..2e1484ac1 100644 --- a/tests/test_sql_refsols/quantile_test_2_oracle.sql +++ b/tests/test_sql_refsols/quantile_test_2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT n_name AS N_NAME, n_nationkey AS N_NATIONKEY, @@ -7,7 +7,7 @@ WITH _S0 AS ( ORDER BY 1 NULLS FIRST FETCH FIRST 5 ROWS ONLY -), _S5 AS ( +), "_S5" AS ( SELECT CUSTOMER.c_nationkey AS C_NATIONKEY, ORDERS.o_totalprice AS O_TOTALPRICE @@ -15,52 +15,52 @@ WITH _S0 AS ( JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 -), _T1 AS ( +), "_T1" AS ( SELECT - _S0.N_NAME, - _S0.N_NATIONKEY, - _S5.O_TOTALPRICE, + "_S0".N_NAME, + "_S0".N_NATIONKEY, + "_S5".O_TOTALPRICE, REGION.r_name AS R_NAME, CASE - WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.99 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_10, CASE - WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.75 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_11, CASE - WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.25 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_12, CASE - WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.1 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_13, CASE - WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.01 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_14, CASE - WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.5 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_15, CASE - WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) - THEN _S5.O_TOTALPRICE + WHEN FLOOR(0.9 * COUNT("_S5".O_TOTALPRICE) OVER (PARTITION BY "_S5".C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY "_S5".C_NATIONKEY ORDER BY "_S5".O_TOTALPRICE DESC NULLS LAST) + THEN "_S5".O_TOTALPRICE ELSE NULL END AS EXPR_9 - FROM _S0 _S0 + FROM "_S0" "_S0" JOIN TPCH.REGION REGION - ON REGION.r_regionkey = _S0.N_REGIONKEY - LEFT JOIN _S5 _S5 - ON _S0.N_NATIONKEY = _S5.C_NATIONKEY + ON REGION.r_regionkey = "_S0".N_REGIONKEY + LEFT JOIN "_S5" "_S5" + ON "_S0".N_NATIONKEY = "_S5".C_NATIONKEY ) SELECT ANY_VALUE(R_NAME) AS region_name, @@ -74,7 +74,7 @@ SELECT MAX(EXPR_13) AS orders_90_percent, MAX(EXPR_14) AS orders_99_percent, MAX(O_TOTALPRICE) AS orders_max -FROM _T1 +FROM "_T1" GROUP BY N_NATIONKEY ORDER BY diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql index 6ffb981b0..fb40dce74 100644 --- a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -1,83 +1,83 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT pr_name AS PR_NAME, pr_release AS PR_RELEASE FROM MAIN.PRODUCTS WHERE pr_name = 'RubyCopper-Star' -), _S1 AS ( +), "_S1" AS ( SELECT ca_dt AS CA_DT FROM MAIN.CALENDAR -), _S7 AS ( +), "_S7" AS ( SELECT - _S3.CA_DT, + "_S3".CA_DT, COUNT(*) AS N_ROWS - FROM _T2 _T4 - JOIN _S1 _S3 - ON _S3.CA_DT < TRUNC(DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S3.CA_DT >= _T4.PR_RELEASE + FROM "_T2" "_T4" + JOIN "_S1" "_S3" + ON "_S3".CA_DT < TRUNC(DATE_ADD(CAST("_T4".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S3".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON DEVICES.de_product_id = 800544 - AND _S3.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + AND "_S3".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') GROUP BY - _S3.CA_DT -), _S22 AS ( + "_S3".CA_DT +), "_S22" AS ( SELECT - TRUNC(CAST(_S1.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, - SUM(_S7.N_ROWS) AS SUM_N_ROWS - FROM _T2 _T2 - JOIN _S1 _S1 - ON _S1.CA_DT < TRUNC(DATE_ADD(CAST(_T2.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S1.CA_DT >= _T2.PR_RELEASE - LEFT JOIN _S7 _S7 - ON _S1.CA_DT = _S7.CA_DT + TRUNC(CAST("_S1".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + SUM("_S7".N_ROWS) AS SUM_N_ROWS + FROM "_T2" "_T2" + JOIN "_S1" "_S1" + ON "_S1".CA_DT < TRUNC(DATE_ADD(CAST("_T2".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S1".CA_DT >= "_T2".PR_RELEASE + LEFT JOIN "_S7" "_S7" + ON "_S1".CA_DT = "_S7".CA_DT GROUP BY - TRUNC(CAST(_S1.CA_DT AS TIMESTAMP), 'QUARTER') -), _S13 AS ( + TRUNC(CAST("_S1".CA_DT AS TIMESTAMP), 'QUARTER') +), "_S13" AS ( SELECT DISTINCT - TRUNC(CAST(_S11.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER - FROM _T2 _T10 - JOIN _S1 _S11 - ON _S11.CA_DT < TRUNC(DATE_ADD(CAST(_T10.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S11.CA_DT >= _T10.PR_RELEASE -), _S17 AS ( + TRUNC(CAST("_S11".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + FROM "_T2" "_T10" + JOIN "_S1" "_S11" + ON "_S11".CA_DT < TRUNC(DATE_ADD(CAST("_T10".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S11".CA_DT >= "_T10".PR_RELEASE +), "_S17" AS ( SELECT - _S15.CA_DT - FROM _T2 _T11 - JOIN _S1 _S15 - ON _S15.CA_DT < TRUNC(DATE_ADD(CAST(_T11.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') - AND _S15.CA_DT >= _T11.PR_RELEASE -), _S23 AS ( + "_S15".CA_DT + FROM "_T2" "_T11" + JOIN "_S1" "_S15" + ON "_S15".CA_DT < TRUNC(DATE_ADD(CAST("_T11".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND "_S15".CA_DT >= "_T11".PR_RELEASE +), "_S23" AS ( SELECT - _S13.QUARTER, + "_S13".QUARTER, COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID FROM MAIN.PRODUCTS PRODUCTS JOIN MAIN.COUNTRIES COUNTRIES ON COUNTRIES.co_name = 'CN' - CROSS JOIN _S13 _S13 - JOIN _S17 _S17 - ON _S13.QUARTER = TRUNC(CAST(_S17.CA_DT AS TIMESTAMP), 'QUARTER') + CROSS JOIN "_S13" "_S13" + JOIN "_S17" "_S17" + ON "_S13".QUARTER = TRUNC(CAST("_S17".CA_DT AS TIMESTAMP), 'QUARTER') JOIN MAIN.INCIDENTS INCIDENTS ON COUNTRIES.co_id = INCIDENTS.in_repair_country_id - AND _S17.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + AND "_S17".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = 800544 WHERE PRODUCTS.pr_name = 'RubyCopper-Star' GROUP BY - _S13.QUARTER + "_S13".QUARTER ) SELECT - _S22.QUARTER AS quarter, - NVL(_S23.NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, - NVL(_S22.SUM_N_ROWS, 0) AS n_sold, + "_S22".QUARTER AS quarter, + NVL("_S23".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + NVL("_S22".SUM_N_ROWS, 0) AS n_sold, ROUND( - SUM(NVL(_S23.NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY _S22.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S22.SUM_N_ROWS, 0)) OVER (ORDER BY _S22.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(NVL("_S23".NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY "_S22".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL("_S22".SUM_N_ROWS, 0)) OVER (ORDER BY "_S22".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS quarter_cum -FROM _S22 _S22 -LEFT JOIN _S23 _S23 - ON _S22.QUARTER = _S23.QUARTER +FROM "_S22" "_S22" +LEFT JOIN "_S23" "_S23" + ON "_S22".QUARTER = "_S23".QUARTER ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/quarter_function_test_oracle.sql b/tests/test_sql_refsols/quarter_function_test_oracle.sql index 09ae15616..6b387d252 100644 --- a/tests/test_sql_refsols/quarter_function_test_oracle.sql +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -1,17 +1,17 @@ SELECT - 1 AS _expr0, - 1 AS _expr1, - 1 AS _expr2, - 2 AS _expr3, - 2 AS _expr4, - 2 AS _expr5, - 3 AS _expr6, - 3 AS _expr7, - 3 AS _expr8, - 4 AS _expr9, - 4 AS _expr10, - 4 AS _expr11, - 1 AS _expr12, + 1 AS "_expr0", + 1 AS "_expr1", + 1 AS "_expr2", + 2 AS "_expr3", + 2 AS "_expr4", + 2 AS "_expr5", + 3 AS "_expr6", + 3 AS "_expr7", + 3 AS "_expr8", + 4 AS "_expr9", + 4 AS "_expr10", + 4 AS "_expr11", + 1 AS "_expr12", TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_jan, TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_feb, TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_mar, @@ -55,4 +55,4 @@ SELECT DATEDIFF(CAST('2023-04-01' AS TIMESTAMP), CAST('2023-03-31' AS TIMESTAMP), QUARTER) AS q_diff11, DATEDIFF(CAST('2024-01-01' AS TIMESTAMP), CAST('2023-12-31' AS TIMESTAMP), QUARTER) AS q_diff12 FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql index fcfa12355..4ea752361 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT c_nationkey AS C_NATIONKEY, COUNT(*) AS N_ROWS @@ -8,10 +8,10 @@ WITH _S1 AS ( ) SELECT NATION.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY _S1.N_ROWS DESC, REGION.r_name) AS rank + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY "_S1".N_ROWS DESC, REGION.r_name) AS rank FROM TPCH.NATION NATION -JOIN _S1 _S1 - ON NATION.n_nationkey = _S1.C_NATIONKEY +JOIN "_S1" "_S1" + ON NATION.n_nationkey = "_S1".C_NATIONKEY JOIN TPCH.REGION REGION ON NATION.n_regionkey = REGION.r_regionkey ORDER BY diff --git a/tests/test_sql_refsols/rank_with_filters_a_oracle.sql b/tests/test_sql_refsols/rank_with_filters_a_oracle.sql index 1fbbd4d7d..f119c68fd 100644 --- a/tests/test_sql_refsols/rank_with_filters_a_oracle.sql +++ b/tests/test_sql_refsols/rank_with_filters_a_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT ROW_NUMBER() OVER (ORDER BY c_acctbal DESC, c_name) AS R, c_name AS C_NAME @@ -7,6 +7,6 @@ WITH _T0 AS ( SELECT C_NAME AS n, R AS r -FROM _T0 +FROM "_T0" WHERE C_NAME LIKE '%0' AND R <= 30 diff --git a/tests/test_sql_refsols/rank_with_filters_b_oracle.sql b/tests/test_sql_refsols/rank_with_filters_b_oracle.sql index 1fbbd4d7d..f119c68fd 100644 --- a/tests/test_sql_refsols/rank_with_filters_b_oracle.sql +++ b/tests/test_sql_refsols/rank_with_filters_b_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT ROW_NUMBER() OVER (ORDER BY c_acctbal DESC, c_name) AS R, c_name AS C_NAME @@ -7,6 +7,6 @@ WITH _T0 AS ( SELECT C_NAME AS n, R AS r -FROM _T0 +FROM "_T0" WHERE C_NAME LIKE '%0' AND R <= 30 diff --git a/tests/test_sql_refsols/rank_with_filters_c_oracle.sql b/tests/test_sql_refsols/rank_with_filters_c_oracle.sql index d113d63e3..46a40cb73 100644 --- a/tests/test_sql_refsols/rank_with_filters_c_oracle.sql +++ b/tests/test_sql_refsols/rank_with_filters_c_oracle.sql @@ -1,22 +1,22 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT DISTINCT p_size AS P_SIZE FROM TPCH.PART ORDER BY 1 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY -), _T AS ( +), "_T" AS ( SELECT PART.p_size AS SIZE_1, PART.p_name AS P_NAME, - ROW_NUMBER() OVER (PARTITION BY _S0.P_SIZE ORDER BY PART.p_retailprice DESC, PART.p_partkey) AS _W - FROM _S0 _S0 + ROW_NUMBER() OVER (PARTITION BY "_S0".P_SIZE ORDER BY PART.p_retailprice DESC, PART.p_partkey) AS "_W" + FROM "_S0" "_S0" JOIN TPCH.PART PART - ON PART.p_size = _S0.P_SIZE + ON PART.p_size = "_S0".P_SIZE ) SELECT P_NAME AS pname, SIZE_1 AS psize -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql index e91ee8eb7..e664803e5 100644 --- a/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql +++ b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, NATION.n_regionkey AS N_REGIONKEY, @@ -44,7 +44,7 @@ WITH _T1 AS ( FROM TPCH.NATION NATION JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_nationkey = NATION.n_nationkey -), _S3 AS ( +), "_S3" AS ( SELECT N_REGIONKEY, AVG(EXPR_5) AS AVG_EXPR_5, @@ -52,19 +52,19 @@ WITH _T1 AS ( AVG(EXPR_7) AS AVG_EXPR_7, COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS COUNT_NEGATIVE_ACCTBAL, COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS COUNT_NON_NEGATIVE_ACCTBAL - FROM _T1 + FROM "_T1" GROUP BY N_REGIONKEY ) SELECT REGION.r_name AS region_name, - _S3.COUNT_NEGATIVE_ACCTBAL AS n_red_acctbal, - _S3.COUNT_NON_NEGATIVE_ACCTBAL AS n_black_acctbal, - _S3.AVG_EXPR_7 AS median_red_acctbal, - _S3.AVG_EXPR_5 AS median_black_acctbal, - _S3.AVG_EXPR_6 AS median_overall_acctbal + "_S3".COUNT_NEGATIVE_ACCTBAL AS n_red_acctbal, + "_S3".COUNT_NON_NEGATIVE_ACCTBAL AS n_black_acctbal, + "_S3".AVG_EXPR_7 AS median_red_acctbal, + "_S3".AVG_EXPR_5 AS median_black_acctbal, + "_S3".AVG_EXPR_6 AS median_overall_acctbal FROM TPCH.REGION REGION -JOIN _S3 _S3 - ON REGION.r_regionkey = _S3.N_REGIONKEY +JOIN "_S3" "_S3" + ON REGION.r_regionkey = "_S3".N_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql index 9474cda47..b94477187 100644 --- a/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql +++ b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql @@ -1,35 +1,35 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT CUSTOMER.c_custkey AS C_CUSTKEY, NATION.n_regionkey AS N_REGIONKEY, - ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS _W + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS "_W" FROM TPCH.NATION NATION JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_nationkey = NATION.n_nationkey -), _S3 AS ( +), "_S3" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY o_custkey -), _S5 AS ( +), "_S5" AS ( SELECT - _T.N_REGIONKEY, - SUM(_S3.N_ROWS) AS SUM_N_ROWS - FROM _T _T - JOIN _S3 _S3 - ON _S3.O_CUSTKEY = _T.C_CUSTKEY + "_T".N_REGIONKEY, + SUM("_S3".N_ROWS) AS SUM_N_ROWS + FROM "_T" "_T" + JOIN "_S3" "_S3" + ON "_S3".O_CUSTKEY = "_T".C_CUSTKEY WHERE - _T._W = 1 + "_T"."_W" = 1 GROUP BY - _T.N_REGIONKEY + "_T".N_REGIONKEY ) SELECT REGION.r_name AS region_name, - NVL(_S5.SUM_N_ROWS, 0) AS n_orders + NVL("_S5".SUM_N_ROWS, 0) AS n_orders FROM TPCH.REGION REGION -LEFT JOIN _S5 _S5 - ON REGION.r_regionkey = _S5.N_REGIONKEY +LEFT JOIN "_S5" "_S5" + ON REGION.r_regionkey = "_S5".N_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql index d00707e28..47d9ebde7 100644 --- a/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql +++ b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql @@ -1,40 +1,40 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT NATION.n_regionkey AS N_REGIONKEY, ORDERS.o_orderkey AS O_ORDERKEY, - ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY ORDERS.o_orderdate, ORDERS.o_orderkey) AS _W + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY ORDERS.o_orderdate, ORDERS.o_orderkey) AS "_W" FROM TPCH.NATION NATION JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_nationkey = NATION.n_nationkey JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 -), _T_2 AS ( +), "_T_2" AS ( SELECT LINEITEM.l_partkey AS L_PARTKEY, - _T.N_REGIONKEY, - ROW_NUMBER() OVER (PARTITION BY _T.N_REGIONKEY ORDER BY LINEITEM.l_quantity DESC, LINEITEM.l_linenumber) AS _W - FROM _T _T + "_T".N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY "_T".N_REGIONKEY ORDER BY LINEITEM.l_quantity DESC, LINEITEM.l_linenumber) AS "_W" + FROM "_T" "_T" JOIN TPCH.LINEITEM LINEITEM ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 - AND LINEITEM.l_orderkey = _T.O_ORDERKEY + AND LINEITEM.l_orderkey = "_T".O_ORDERKEY WHERE - _T._W = 1 -), _S9 AS ( + "_T"."_W" = 1 +), "_S9" AS ( SELECT - _T.N_REGIONKEY, + "_T".N_REGIONKEY, PART.p_name AS P_NAME - FROM _T_2 _T + FROM "_T_2" "_T" JOIN TPCH.PART PART - ON PART.p_partkey = _T.L_PARTKEY + ON PART.p_partkey = "_T".L_PARTKEY WHERE - _T._W = 1 + "_T"."_W" = 1 ) SELECT REGION.r_name AS region_name, - _S9.P_NAME AS part_name + "_S9".P_NAME AS part_name FROM TPCH.REGION REGION -LEFT JOIN _S9 _S9 - ON REGION.r_regionkey = _S9.N_REGIONKEY +LEFT JOIN "_S9" "_S9" + ON REGION.r_regionkey = "_S9".N_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql b/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql index 89e211219..a6bb8b585 100644 --- a/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql +++ b/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql @@ -1,22 +1,22 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT ps_suppkey AS PS_SUPPKEY, COUNT(*) AS N_ROWS FROM TPCH.PARTSUPP GROUP BY ps_suppkey -), _T AS ( +), "_T" AS ( SELECT SUPPLIER.s_name AS S_NAME, - NTILE(1000) OVER (PARTITION BY NATION.n_regionkey ORDER BY _S3.N_ROWS, SUPPLIER.s_name) AS _W + NTILE(1000) OVER (PARTITION BY NATION.n_regionkey ORDER BY "_S3".N_ROWS, SUPPLIER.s_name) AS "_W" FROM TPCH.NATION NATION JOIN TPCH.SUPPLIER SUPPLIER ON NATION.n_nationkey = SUPPLIER.s_nationkey - JOIN _S3 _S3 - ON SUPPLIER.s_suppkey = _S3.PS_SUPPKEY + JOIN "_S3" "_S3" + ON SUPPLIER.s_suppkey = "_S3".PS_SUPPKEY ) SELECT S_NAME AS name -FROM _T +FROM "_T" WHERE - _W = 1000 + "_W" = 1000 diff --git a/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql b/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql index 2a70de0b6..03bd1de47 100644 --- a/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql +++ b/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql @@ -1,13 +1,13 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT CUSTOMER.c_custkey AS C_CUSTKEY, - ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC) AS "_W" FROM TPCH.NATION NATION JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_nationkey = NATION.n_nationkey ) SELECT C_CUSTKEY AS key -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/richest_customer_per_region_oracle.sql b/tests/test_sql_refsols/richest_customer_per_region_oracle.sql index ee2c3e38b..29c6d2b5a 100644 --- a/tests/test_sql_refsols/richest_customer_per_region_oracle.sql +++ b/tests/test_sql_refsols/richest_customer_per_region_oracle.sql @@ -1,10 +1,10 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_name AS C_NAME, NATION.n_name AS N_NAME, REGION.r_name AS R_NAME, - ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS _W + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS "_W" FROM TPCH.REGION REGION JOIN TPCH.NATION NATION ON NATION.n_regionkey = REGION.r_regionkey @@ -16,6 +16,6 @@ SELECT N_NAME AS nation_name, C_NAME AS customer_name, C_ACCTBAL AS balance -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/simple_cross_10_oracle.sql b/tests/test_sql_refsols/simple_cross_10_oracle.sql index 5f99c59f3..837218a07 100644 --- a/tests/test_sql_refsols/simple_cross_10_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_10_oracle.sql @@ -1,26 +1,26 @@ -WITH _S4 AS ( +WITH "_S4" AS ( SELECT r_name AS R_NAME, r_regionkey AS R_REGIONKEY FROM TPCH.REGION -), _S5 AS ( +), "_S5" AS ( SELECT - _S0.R_REGIONKEY, + "_S0".R_REGIONKEY, COUNT(*) AS N_ROWS - FROM _S4 _S0 - JOIN _S4 _S1 - ON _S0.R_NAME <> _S1.R_NAME + FROM "_S4" "_S0" + JOIN "_S4" "_S1" + ON "_S0".R_NAME <> "_S1".R_NAME JOIN TPCH.NATION NATION - ON NATION.n_regionkey = _S1.R_REGIONKEY - AND SUBSTR(NATION.n_name, 1, 1) = SUBSTR(_S0.R_NAME, 1, 1) + ON NATION.n_regionkey = "_S1".R_REGIONKEY + AND SUBSTR(NATION.n_name, 1, 1) = SUBSTR("_S0".R_NAME, 1, 1) GROUP BY - _S0.R_REGIONKEY + "_S0".R_REGIONKEY ) SELECT - _S4.R_NAME AS region_name, - NVL(_S5.N_ROWS, 0) AS n_other_nations -FROM _S4 _S4 -LEFT JOIN _S5 _S5 - ON _S4.R_REGIONKEY = _S5.R_REGIONKEY + "_S4".R_NAME AS region_name, + NVL("_S5".N_ROWS, 0) AS n_other_nations +FROM "_S4" "_S4" +LEFT JOIN "_S5" "_S5" + ON "_S4".R_REGIONKEY = "_S5".R_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_11_oracle.sql b/tests/test_sql_refsols/simple_cross_11_oracle.sql index 02b789cc3..bcff0304d 100644 --- a/tests/test_sql_refsols/simple_cross_11_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_11_oracle.sql @@ -1,14 +1,14 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT o_orderdate AS O_ORDERDATE FROM TPCH.ORDERS -), _S1 AS ( +), "_S1" AS ( SELECT MIN(O_ORDERDATE) AS MIN_O_ORDERDATE - FROM _S0 + FROM "_S0" ) SELECT COUNT(*) AS n -FROM _S0 _S0 -JOIN _S1 _S1 - ON _S0.O_ORDERDATE = _S1.MIN_O_ORDERDATE +FROM "_S0" "_S0" +JOIN "_S1" "_S1" + ON "_S0".O_ORDERDATE = "_S1".MIN_O_ORDERDATE diff --git a/tests/test_sql_refsols/simple_cross_12_oracle.sql b/tests/test_sql_refsols/simple_cross_12_oracle.sql index 321a655d8..b2f248ad4 100644 --- a/tests/test_sql_refsols/simple_cross_12_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_12_oracle.sql @@ -1,17 +1,17 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT DISTINCT o_orderpriority AS O_ORDERPRIORITY FROM TPCH.ORDERS -), _S1 AS ( +), "_S1" AS ( SELECT DISTINCT c_mktsegment AS C_MKTSEGMENT FROM TPCH.CUSTOMER ) SELECT - _S0.O_ORDERPRIORITY AS order_priority, - _S1.C_MKTSEGMENT AS market_segment -FROM _S0 _S0 -CROSS JOIN _S1 _S1 + "_S0".O_ORDERPRIORITY AS order_priority, + "_S1".C_MKTSEGMENT AS market_segment +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_13_oracle.sql b/tests/test_sql_refsols/simple_cross_13_oracle.sql index 13cd201da..73e3b545d 100644 --- a/tests/test_sql_refsols/simple_cross_13_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_13_oracle.sql @@ -7,4 +7,4 @@ SELECT 'fizzbuzz' AS f, 'yay' AS g FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/simple_cross_14_oracle.sql b/tests/test_sql_refsols/simple_cross_14_oracle.sql index 6f424b217..79d91e1fe 100644 --- a/tests/test_sql_refsols/simple_cross_14_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_14_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT n_regionkey AS N_REGIONKEY, COUNT(*) AS N_ROWS @@ -11,9 +11,9 @@ WITH _S1 AS ( SELECT REGION.r_name AS region_name, 'foo' AS x, - NVL(_S1.N_ROWS, 0) AS n + NVL("_S1".N_ROWS, 0) AS n FROM TPCH.REGION REGION -LEFT JOIN _S1 _S1 - ON REGION.r_regionkey = _S1.N_REGIONKEY +LEFT JOIN "_S1" "_S1" + ON REGION.r_regionkey = "_S1".N_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_15_oracle.sql b/tests/test_sql_refsols/simple_cross_15_oracle.sql index bfbf7ff38..15bea6351 100644 --- a/tests/test_sql_refsols/simple_cross_15_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_15_oracle.sql @@ -1,33 +1,33 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT r_name AS R_NAME FROM TPCH.REGION -), _S0 AS ( +), "_S0" AS ( SELECT DISTINCT CASE WHEN R_NAME LIKE '%A%' THEN 'A' ELSE '*' END AS A - FROM _T1 -), _S1 AS ( + FROM "_T1" +), "_S1" AS ( SELECT DISTINCT CASE WHEN R_NAME LIKE '%E%' THEN 'E' ELSE '*' END AS E - FROM _T1 -), _S3 AS ( + FROM "_T1" +), "_S3" AS ( SELECT DISTINCT CASE WHEN R_NAME LIKE '%I%' THEN 'I' ELSE '*' END AS I - FROM _T1 -), _S5 AS ( + FROM "_T1" +), "_S5" AS ( SELECT DISTINCT CASE WHEN R_NAME LIKE '%O%' THEN 'O' ELSE '*' END AS O - FROM _T1 + FROM "_T1" ) SELECT - _S0.A AS a, - _S1.E AS e, - _S3.I AS i, - _S5.O AS o -FROM _S0 _S0 -CROSS JOIN _S1 _S1 -CROSS JOIN _S3 _S3 -CROSS JOIN _S5 _S5 + "_S0".A AS a, + "_S1".E AS e, + "_S3".I AS i, + "_S5".O AS o +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" +CROSS JOIN "_S3" "_S3" +CROSS JOIN "_S5" "_S5" ORDER BY 1 NULLS FIRST, 2 NULLS FIRST, diff --git a/tests/test_sql_refsols/simple_cross_16_oracle.sql b/tests/test_sql_refsols/simple_cross_16_oracle.sql index bc1b82df7..2ef37b6cb 100644 --- a/tests/test_sql_refsols/simple_cross_16_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_16_oracle.sql @@ -1,38 +1,38 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT c_acctbal AS C_ACCTBAL FROM TPCH.CUSTOMER -), _S1 AS ( +), "_S1" AS ( SELECT MIN(C_ACCTBAL) AS MIN_C_ACCTBAL - FROM _S0 -), _S4 AS ( + FROM "_S0" +), "_S4" AS ( SELECT COUNT(*) AS N_ROWS - FROM _S0 _S0 - JOIN _S1 _S1 - ON _S0.C_ACCTBAL <= ( - _S1.MIN_C_ACCTBAL + 10.0 + FROM "_S0" "_S0" + JOIN "_S1" "_S1" + ON "_S0".C_ACCTBAL <= ( + "_S1".MIN_C_ACCTBAL + 10.0 ) -), _S2 AS ( +), "_S2" AS ( SELECT s_acctbal AS S_ACCTBAL FROM TPCH.SUPPLIER -), _S3 AS ( +), "_S3" AS ( SELECT MAX(S_ACCTBAL) AS MAX_S_ACCTBAL - FROM _S2 -), _S5 AS ( + FROM "_S2" +), "_S5" AS ( SELECT COUNT(*) AS N_ROWS - FROM _S2 _S2 - JOIN _S3 _S3 - ON _S2.S_ACCTBAL >= ( - _S3.MAX_S_ACCTBAL - 10.0 + FROM "_S2" "_S2" + JOIN "_S3" "_S3" + ON "_S2".S_ACCTBAL >= ( + "_S3".MAX_S_ACCTBAL - 10.0 ) ) SELECT - _S4.N_ROWS AS n1, - _S5.N_ROWS AS n2 -FROM _S4 _S4 -CROSS JOIN _S5 _S5 + "_S4".N_ROWS AS n1, + "_S5".N_ROWS AS n2 +FROM "_S4" "_S4" +CROSS JOIN "_S5" "_S5" diff --git a/tests/test_sql_refsols/simple_cross_1_oracle.sql b/tests/test_sql_refsols/simple_cross_1_oracle.sql index ef278726f..7177e4a39 100644 --- a/tests/test_sql_refsols/simple_cross_1_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_1_oracle.sql @@ -1,13 +1,13 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT r_name AS R_NAME FROM TPCH.REGION ) SELECT - _S0.R_NAME AS r1, - _S1.R_NAME AS r2 -FROM _S0 _S0 -CROSS JOIN _S0 _S1 + "_S0".R_NAME AS r1, + "_S1".R_NAME AS r2 +FROM "_S0" "_S0" +CROSS JOIN "_S0" "_S1" ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_2_oracle.sql b/tests/test_sql_refsols/simple_cross_2_oracle.sql index 6c2142a43..a12207aec 100644 --- a/tests/test_sql_refsols/simple_cross_2_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_2_oracle.sql @@ -1,14 +1,14 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT r_name AS R_NAME FROM TPCH.REGION ) SELECT - _S0.R_NAME AS r1, - _S1.R_NAME AS r2 -FROM _S0 _S0 -JOIN _S0 _S1 - ON _S0.R_NAME <> _S1.R_NAME + "_S0".R_NAME AS r1, + "_S1".R_NAME AS r2 +FROM "_S0" "_S0" +JOIN "_S0" "_S1" + ON "_S0".R_NAME <> "_S1".R_NAME ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_3_oracle.sql b/tests/test_sql_refsols/simple_cross_3_oracle.sql index 25e3ec054..e366e84ac 100644 --- a/tests/test_sql_refsols/simple_cross_3_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT n_name AS N_NAME, n_nationkey AS N_NATIONKEY, @@ -6,18 +6,18 @@ WITH _S1 AS ( FROM TPCH.NATION ) SELECT - ANY_VALUE(_S1.N_NAME) AS supplier_nation, - ANY_VALUE(_S5.N_NAME) AS customer_nation, + ANY_VALUE("_S1".N_NAME) AS supplier_nation, + ANY_VALUE("_S5".N_NAME) AS customer_nation, COUNT(*) AS nation_combinations FROM TPCH.REGION REGION -JOIN _S1 _S1 - ON REGION.r_regionkey = _S1.N_REGIONKEY +JOIN "_S1" "_S1" + ON REGION.r_regionkey = "_S1".N_REGIONKEY JOIN TPCH.REGION REGION_2 ON REGION_2.r_name = 'AMERICA' -JOIN _S1 _S5 - ON REGION_2.r_regionkey = _S5.N_REGIONKEY +JOIN "_S1" "_S5" + ON REGION_2.r_regionkey = "_S5".N_REGIONKEY JOIN TPCH.CUSTOMER CUSTOMER - ON CUSTOMER.c_acctbal < 0 AND CUSTOMER.c_nationkey = _S5.N_NATIONKEY + ON CUSTOMER.c_acctbal < 0 AND CUSTOMER.c_nationkey = "_S5".N_NATIONKEY JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 4 @@ -26,11 +26,11 @@ JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_shipmode = 'SHIP' JOIN TPCH.SUPPLIER SUPPLIER ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey - AND SUPPLIER.s_nationkey = _S1.N_NATIONKEY + AND SUPPLIER.s_nationkey = "_S1".N_NATIONKEY WHERE REGION.r_name = 'ASIA' GROUP BY REGION_2.r_regionkey, - _S5.N_NATIONKEY, - _S1.N_NATIONKEY, + "_S5".N_NATIONKEY, + "_S1".N_NATIONKEY, REGION.r_regionkey diff --git a/tests/test_sql_refsols/simple_cross_4_oracle.sql b/tests/test_sql_refsols/simple_cross_4_oracle.sql index 57a293c02..c572b3049 100644 --- a/tests/test_sql_refsols/simple_cross_4_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_4_oracle.sql @@ -1,24 +1,24 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT r_name AS R_NAME, r_regionkey AS R_REGIONKEY FROM TPCH.REGION -), _S3 AS ( +), "_S3" AS ( SELECT - _S0.R_REGIONKEY, + "_S0".R_REGIONKEY, COUNT(*) AS N_ROWS - FROM _S2 _S0 + FROM "_S2" "_S0" JOIN TPCH.REGION REGION - ON REGION.r_name <> _S0.R_NAME - AND SUBSTR(REGION.r_name, 1, 1) = SUBSTR(_S0.R_NAME, 1, 1) + ON REGION.r_name <> "_S0".R_NAME + AND SUBSTR(REGION.r_name, 1, 1) = SUBSTR("_S0".R_NAME, 1, 1) GROUP BY - _S0.R_REGIONKEY + "_S0".R_REGIONKEY ) SELECT - _S2.R_NAME AS region_name, - NVL(_S3.N_ROWS, 0) AS n_other_regions -FROM _S2 _S2 -LEFT JOIN _S3 _S3 - ON _S2.R_REGIONKEY = _S3.R_REGIONKEY + "_S2".R_NAME AS region_name, + NVL("_S3".N_ROWS, 0) AS n_other_regions +FROM "_S2" "_S2" +LEFT JOIN "_S3" "_S3" + ON "_S2".R_REGIONKEY = "_S3".R_REGIONKEY ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_5_oracle.sql b/tests/test_sql_refsols/simple_cross_5_oracle.sql index 2bc07e3f9..54f4ba2de 100644 --- a/tests/test_sql_refsols/simple_cross_5_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_5_oracle.sql @@ -1,30 +1,30 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT p_container AS P_CONTAINER, p_size AS P_SIZE FROM TPCH.PART WHERE p_container LIKE 'LG%' -), _S6 AS ( +), "_S6" AS ( SELECT DISTINCT P_SIZE - FROM _T1 + FROM "_T1" ORDER BY 1 NULLS FIRST FETCH FIRST 10 ROWS ONLY -), _S0 AS ( +), "_S0" AS ( SELECT DISTINCT P_SIZE - FROM _T1 + FROM "_T1" ORDER BY 1 NULLS FIRST FETCH FIRST 10 ROWS ONLY -), _T4 AS ( +), "_T4" AS ( SELECT ORDERS.o_orderpriority AS O_ORDERPRIORITY, - _S0.P_SIZE, + "_S0".P_SIZE, SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY - FROM _S0 _S0 + FROM "_S0" "_S0" JOIN TPCH.ORDERS ORDERS ON EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1 AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 @@ -36,11 +36,11 @@ WITH _T1 AS ( JOIN TPCH.PART PART ON LINEITEM.l_partkey = PART.p_partkey AND PART.p_container LIKE 'LG%' - AND PART.p_size = _S0.P_SIZE + AND PART.p_size = "_S0".P_SIZE GROUP BY ORDERS.o_orderpriority, - _S0.P_SIZE -), _T AS ( + "_S0".P_SIZE +), "_T" AS ( SELECT O_ORDERPRIORITY, P_SIZE, @@ -51,9 +51,9 @@ WITH _T1 AS ( ) THEN NVL(SUM_L_QUANTITY, 0) ELSE NULL - END DESC) AS _W - FROM _T4 -), _S7 AS ( + END DESC) AS "_W" + FROM "_T4" +), "_S7" AS ( SELECT CASE WHEN ( @@ -64,16 +64,16 @@ WITH _T1 AS ( END AS TOTAL_QTY, O_ORDERPRIORITY, P_SIZE - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 ) SELECT - _S6.P_SIZE AS part_size, - _S7.O_ORDERPRIORITY AS best_order_priority, - _S7.TOTAL_QTY AS best_order_priority_qty -FROM _S6 _S6 -LEFT JOIN _S7 _S7 - ON _S6.P_SIZE = _S7.P_SIZE + "_S6".P_SIZE AS part_size, + "_S7".O_ORDERPRIORITY AS best_order_priority, + "_S7".TOTAL_QTY AS best_order_priority_qty +FROM "_S6" "_S6" +LEFT JOIN "_S7" "_S7" + ON "_S6".P_SIZE = "_S7".P_SIZE ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_6_oracle.sql b/tests/test_sql_refsols/simple_cross_6_oracle.sql index 8dcae710f..a3ab17391 100644 --- a/tests/test_sql_refsols/simple_cross_6_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_6_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT c_acctbal AS C_ACCTBAL, c_custkey AS C_CUSTKEY, @@ -10,8 +10,8 @@ WITH _T1 AS ( ) SELECT COUNT(*) AS n_pairs -FROM _T1 _T1 -JOIN _T1 _T2 - ON _T1.C_CUSTKEY < _T2.C_CUSTKEY - AND _T1.C_MKTSEGMENT = _T2.C_MKTSEGMENT - AND _T1.C_NATIONKEY = _T2.C_NATIONKEY +FROM "_T1" "_T1" +JOIN "_T1" "_T2" + ON "_T1".C_CUSTKEY < "_T2".C_CUSTKEY + AND "_T1".C_MKTSEGMENT = "_T2".C_MKTSEGMENT + AND "_T1".C_NATIONKEY = "_T2".C_NATIONKEY diff --git a/tests/test_sql_refsols/simple_cross_7_oracle.sql b/tests/test_sql_refsols/simple_cross_7_oracle.sql index 811e73f42..e41a0c336 100644 --- a/tests/test_sql_refsols/simple_cross_7_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_7_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT PART.p_partkey AS P_PARTKEY, COUNT(*) AS N_ROWS @@ -18,10 +18,10 @@ WITH _S3 AS ( ) SELECT PART.p_partkey AS original_part_key, - NVL(_S3.N_ROWS, 0) AS n_other_parts + NVL("_S3".N_ROWS, 0) AS n_other_parts FROM TPCH.PART PART -LEFT JOIN _S3 _S3 - ON PART.p_partkey = _S3.P_PARTKEY +LEFT JOIN "_S3" "_S3" + ON PART.p_partkey = "_S3".P_PARTKEY WHERE PART.p_brand = 'Brand#35' AND PART.p_mfgr = 'Manufacturer#3' diff --git a/tests/test_sql_refsols/simple_cross_8_oracle.sql b/tests/test_sql_refsols/simple_cross_8_oracle.sql index 53e6d09d3..f33acc021 100644 --- a/tests/test_sql_refsols/simple_cross_8_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_8_oracle.sql @@ -1,43 +1,43 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT r_name AS R_NAME, r_regionkey AS R_REGIONKEY FROM TPCH.REGION -), _S3 AS ( +), "_S3" AS ( SELECT n_nationkey AS N_NATIONKEY, n_regionkey AS N_REGIONKEY FROM TPCH.NATION -), _S15 AS ( +), "_S15" AS ( SELECT - _S13.R_NAME, + "_S13".R_NAME, SUPPLIER.s_suppkey AS S_SUPPKEY FROM TPCH.SUPPLIER SUPPLIER - JOIN _S3 _S11 - ON SUPPLIER.s_nationkey = _S11.N_NATIONKEY - JOIN _S0 _S13 - ON _S11.N_REGIONKEY = _S13.R_REGIONKEY + JOIN "_S3" "_S11" + ON SUPPLIER.s_nationkey = "_S11".N_NATIONKEY + JOIN "_S0" "_S13" + ON "_S11".N_REGIONKEY = "_S13".R_REGIONKEY WHERE SUPPLIER.s_acctbal < 0 ) SELECT - ANY_VALUE(_S0.R_NAME) AS supplier_region, - ANY_VALUE(_S1.R_NAME) AS customer_region, + ANY_VALUE("_S0".R_NAME) AS supplier_region, + ANY_VALUE("_S1".R_NAME) AS customer_region, COUNT(*) AS region_combinations -FROM _S0 _S0 -CROSS JOIN _S0 _S1 -JOIN _S3 _S3 - ON _S1.R_REGIONKEY = _S3.N_REGIONKEY +FROM "_S0" "_S0" +CROSS JOIN "_S0" "_S1" +JOIN "_S3" "_S3" + ON "_S1".R_REGIONKEY = "_S3".N_REGIONKEY JOIN TPCH.CUSTOMER CUSTOMER - ON CUSTOMER.c_mktsegment = 'AUTOMOBILE' AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY + ON CUSTOMER.c_mktsegment = 'AUTOMOBILE' AND CUSTOMER.c_nationkey = "_S3".N_NATIONKEY JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000007' JOIN TPCH.LINEITEM LINEITEM ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 3 AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1998 AND LINEITEM.l_orderkey = ORDERS.o_orderkey -JOIN _S15 _S15 - ON LINEITEM.l_suppkey = _S15.S_SUPPKEY AND _S0.R_NAME = _S15.R_NAME +JOIN "_S15" "_S15" + ON LINEITEM.l_suppkey = "_S15".S_SUPPKEY AND "_S0".R_NAME = "_S15".R_NAME GROUP BY - _S1.R_REGIONKEY, - _S0.R_REGIONKEY + "_S1".R_REGIONKEY, + "_S0".R_REGIONKEY diff --git a/tests/test_sql_refsols/simple_cross_9_oracle.sql b/tests/test_sql_refsols/simple_cross_9_oracle.sql index 222c97abc..eb6916e36 100644 --- a/tests/test_sql_refsols/simple_cross_9_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_9_oracle.sql @@ -1,24 +1,24 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT r_name AS R_NAME, r_regionkey AS R_REGIONKEY FROM TPCH.REGION -), _S1 AS ( +), "_S1" AS ( SELECT n_name AS N_NAME, n_regionkey AS N_REGIONKEY FROM TPCH.NATION ) SELECT - _S1.N_NAME AS n1, - _S5.N_NAME AS n2 -FROM _S0 _S0 -JOIN _S1 _S1 - ON _S0.R_REGIONKEY = _S1.N_REGIONKEY -JOIN _S0 _S3 - ON _S0.R_NAME = _S3.R_NAME -JOIN _S1 _S5 - ON _S1.N_NAME <> _S5.N_NAME AND _S3.R_REGIONKEY = _S5.N_REGIONKEY + "_S1".N_NAME AS n1, + "_S5".N_NAME AS n2 +FROM "_S0" "_S0" +JOIN "_S1" "_S1" + ON "_S0".R_REGIONKEY = "_S1".N_REGIONKEY +JOIN "_S0" "_S3" + ON "_S0".R_NAME = "_S3".R_NAME +JOIN "_S1" "_S5" + ON "_S1".N_NAME <> "_S5".N_NAME AND "_S3".R_REGIONKEY = "_S5".N_REGIONKEY ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql index fecf9d3d9..4c127a17b 100644 --- a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql +++ b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql @@ -22,4 +22,4 @@ SELECT CAST('0.0' AS CLOB) AS s8, CAST('abc def' AS CLOB) AS s9 FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql index c7c17cd9d..332ecf40c 100644 --- a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql +++ b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql @@ -26,4 +26,4 @@ SELECT GREATEST('', 'alphabet soup', 'Hello World') AS l8, NULL AS l9 FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/simplification_3_oracle.sql b/tests/test_sql_refsols/simplification_3_oracle.sql index 222dd74fb..8b3f19301 100644 --- a/tests/test_sql_refsols/simplification_3_oracle.sql +++ b/tests/test_sql_refsols/simplification_3_oracle.sql @@ -1,4 +1,4 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT ABS(CAST(sbcustpostalcode AS INT)) AS EXPR_13, ROW_NUMBER() OVER (ORDER BY sbcustname) AS RANK, @@ -23,7 +23,7 @@ WITH _T2 AS ( 0.1 ) AS RSUM2 FROM MAIN.SBCUSTOMER -), _T1 AS ( +), "_T1" AS ( SELECT RANK, RAVG1, @@ -52,7 +52,7 @@ WITH _T2 AS ( THEN EXPR_13 ELSE NULL END AS EXPR_16 - FROM _T2 + FROM "_T2" ) SELECT TRUE AS s00, @@ -92,4 +92,4 @@ SELECT ROUND(SUM(RCNT2), 2) AS s34, ANY_VALUE(RSIZ1) AS s35, ROUND(SUM(RSIZ2), 2) AS s36 -FROM _T1 +FROM "_T1" diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql index 3f14753b2..cc5ae425e 100644 --- a/tests/test_sql_refsols/simplification_4_oracle.sql +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -1,8 +1,8 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT sbtxdatetime AS SBTXDATETIME, - ROW_NUMBER() OVER (ORDER BY sbtxdatetime DESC) AS _W, - ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS _W_2 + ROW_NUMBER() OVER (ORDER BY sbtxdatetime DESC) AS "_W", + ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS "_W_2" FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 @@ -114,6 +114,6 @@ SELECT TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s102, TO_DATE('2025-01-06', 'YYYY-MM-DD') AS s103, TO_DATE('2025-01-06', 'YYYY-MM-DD') AS s104 -FROM _T +FROM "_T" WHERE - _W = 1 OR _W_2 = 1 + "_W" = 1 OR "_W_2" = 1 diff --git a/tests/test_sql_refsols/singular1_oracle.sql b/tests/test_sql_refsols/singular1_oracle.sql index 111125469..ea9d1ce08 100644 --- a/tests/test_sql_refsols/singular1_oracle.sql +++ b/tests/test_sql_refsols/singular1_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT n_name AS N_NAME, n_regionkey AS N_REGIONKEY @@ -8,7 +8,7 @@ WITH _S1 AS ( ) SELECT REGION.r_name AS name, - _S1.N_NAME AS nation_4_name + "_S1".N_NAME AS nation_4_name FROM TPCH.REGION REGION -LEFT JOIN _S1 _S1 - ON REGION.r_regionkey = _S1.N_REGIONKEY +LEFT JOIN "_S1" "_S1" + ON REGION.r_regionkey = "_S1".N_REGIONKEY diff --git a/tests/test_sql_refsols/singular2_oracle.sql b/tests/test_sql_refsols/singular2_oracle.sql index 295390f8d..f86a27fa3 100644 --- a/tests/test_sql_refsols/singular2_oracle.sql +++ b/tests/test_sql_refsols/singular2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT CUSTOMER.c_nationkey AS C_NATIONKEY, ORDERS.o_orderkey AS O_ORDERKEY @@ -10,7 +10,7 @@ WITH _S3 AS ( ) SELECT NATION.n_name AS name, - _S3.O_ORDERKEY AS okey + "_S3".O_ORDERKEY AS okey FROM TPCH.NATION NATION -LEFT JOIN _S3 _S3 - ON NATION.n_nationkey = _S3.C_NATIONKEY +LEFT JOIN "_S3" "_S3" + ON NATION.n_nationkey = "_S3".C_NATIONKEY diff --git a/tests/test_sql_refsols/singular3_oracle.sql b/tests/test_sql_refsols/singular3_oracle.sql index f56d232d2..aeba1984f 100644 --- a/tests/test_sql_refsols/singular3_oracle.sql +++ b/tests/test_sql_refsols/singular3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT c_custkey AS C_CUSTKEY, c_name AS C_NAME @@ -6,24 +6,24 @@ WITH _S0 AS ( ORDER BY 2 NULLS FIRST FETCH FIRST 5 ROWS ONLY -), _T AS ( +), "_T" AS ( SELECT o_custkey AS O_CUSTKEY, o_orderdate AS O_ORDERDATE, - ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS "_W" FROM TPCH.ORDERS -), _S1 AS ( +), "_S1" AS ( SELECT O_CUSTKEY, O_ORDERDATE - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 ) SELECT - _S0.C_NAME AS name -FROM _S0 _S0 -LEFT JOIN _S1 _S1 - ON _S0.C_CUSTKEY = _S1.O_CUSTKEY + "_S0".C_NAME AS name +FROM "_S0" "_S0" +LEFT JOIN "_S1" "_S1" + ON "_S0".C_CUSTKEY = "_S1".O_CUSTKEY ORDER BY - _S1.O_ORDERDATE + "_S1".O_ORDERDATE diff --git a/tests/test_sql_refsols/singular4_oracle.sql b/tests/test_sql_refsols/singular4_oracle.sql index 679675cac..1c8f5a555 100644 --- a/tests/test_sql_refsols/singular4_oracle.sql +++ b/tests/test_sql_refsols/singular4_oracle.sql @@ -1,26 +1,26 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT o_custkey AS O_CUSTKEY, o_orderdate AS O_ORDERDATE, - ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS _W + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS "_W" FROM TPCH.ORDERS WHERE o_orderpriority = '1-URGENT' -), _S1 AS ( +), "_S1" AS ( SELECT O_CUSTKEY, O_ORDERDATE - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 ) SELECT CUSTOMER.c_name AS name FROM TPCH.CUSTOMER CUSTOMER -LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY WHERE CUSTOMER.c_nationkey = 6 ORDER BY - NVL(_S1.O_ORDERDATE, TO_DATE('2000-01-01', 'YYYY-MM-DD')) + NVL("_S1".O_ORDERDATE, TO_DATE('2000-01-01', 'YYYY-MM-DD')) FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular5_oracle.sql b/tests/test_sql_refsols/singular5_oracle.sql index 63c7d6a08..933f4d53a 100644 --- a/tests/test_sql_refsols/singular5_oracle.sql +++ b/tests/test_sql_refsols/singular5_oracle.sql @@ -1,4 +1,4 @@ -WITH _T3 AS ( +WITH "_T3" AS ( SELECT p_brand AS P_BRAND, p_container AS P_CONTAINER, @@ -6,41 +6,41 @@ WITH _T3 AS ( FROM TPCH.PART WHERE p_brand = 'Brand#13' -), _T AS ( +), "_T" AS ( SELECT LINEITEM.l_shipdate AS L_SHIPDATE, - _T7.P_PARTKEY, - ROW_NUMBER() OVER (PARTITION BY _T7.P_CONTAINER ORDER BY LINEITEM.l_extendedprice DESC, LINEITEM.l_shipdate) AS _W - FROM _T3 _T7 + "_T7".P_PARTKEY, + ROW_NUMBER() OVER (PARTITION BY "_T7".P_CONTAINER ORDER BY LINEITEM.l_extendedprice DESC, LINEITEM.l_shipdate) AS "_W" + FROM "_T3" "_T7" JOIN TPCH.LINEITEM LINEITEM - ON LINEITEM.l_partkey = _T7.P_PARTKEY + ON LINEITEM.l_partkey = "_T7".P_PARTKEY AND LINEITEM.l_shipmode = 'RAIL' AND LINEITEM.l_tax = 0 -), _S3 AS ( +), "_S3" AS ( SELECT P_PARTKEY, ANY_VALUE(L_SHIPDATE) AS ANYTHING_L_SHIPDATE, COUNT(*) AS N_ROWS - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 GROUP BY P_PARTKEY -), _T1 AS ( +), "_T1" AS ( SELECT - _T3.P_CONTAINER, - MAX(_S3.ANYTHING_L_SHIPDATE) AS MAX_ANYTHING_L_SHIPDATE, - SUM(_S3.N_ROWS) AS SUM_N_ROWS - FROM _T3 _T3 - LEFT JOIN _S3 _S3 - ON _S3.P_PARTKEY = _T3.P_PARTKEY + "_T3".P_CONTAINER, + MAX("_S3".ANYTHING_L_SHIPDATE) AS MAX_ANYTHING_L_SHIPDATE, + SUM("_S3".N_ROWS) AS SUM_N_ROWS + FROM "_T3" "_T3" + LEFT JOIN "_S3" "_S3" + ON "_S3".P_PARTKEY = "_T3".P_PARTKEY GROUP BY - _T3.P_CONTAINER + "_T3".P_CONTAINER ) SELECT P_CONTAINER AS container, MAX_ANYTHING_L_SHIPDATE AS highest_price_ship_date -FROM _T1 +FROM "_T1" WHERE SUM_N_ROWS <> 0 ORDER BY diff --git a/tests/test_sql_refsols/singular6_oracle.sql b/tests/test_sql_refsols/singular6_oracle.sql index ea0c68aed..207c4b677 100644 --- a/tests/test_sql_refsols/singular6_oracle.sql +++ b/tests/test_sql_refsols/singular6_oracle.sql @@ -1,11 +1,11 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT LINEITEM.l_receiptdate AS L_RECEIPTDATE, LINEITEM.l_suppkey AS L_SUPPKEY, ORDERS.o_custkey AS O_CUSTKEY, ROW_NUMBER() OVER (PARTITION BY ORDERS.o_custkey ORDER BY LINEITEM.l_receiptdate, LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount - ) DESC) AS _W + ) DESC) AS "_W" FROM TPCH.ORDERS ORDERS JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_orderkey = ORDERS.o_orderkey @@ -14,13 +14,13 @@ WITH _T AS ( ) SELECT CUSTOMER.c_name AS name, - _T.L_RECEIPTDATE AS receipt_date, + "_T".L_RECEIPTDATE AS receipt_date, NATION.n_name AS nation_name FROM TPCH.CUSTOMER CUSTOMER -JOIN _T _T - ON CUSTOMER.c_custkey = _T.O_CUSTKEY AND _T._W = 1 +JOIN "_T" "_T" + ON CUSTOMER.c_custkey = "_T".O_CUSTKEY AND "_T"."_W" = 1 JOIN TPCH.SUPPLIER SUPPLIER - ON SUPPLIER.s_suppkey = _T.L_SUPPKEY + ON SUPPLIER.s_suppkey = "_T".L_SUPPKEY JOIN TPCH.NATION NATION ON NATION.n_nationkey = SUPPLIER.s_nationkey WHERE diff --git a/tests/test_sql_refsols/singular7_oracle.sql b/tests/test_sql_refsols/singular7_oracle.sql index 7764a3836..aa135b2cd 100644 --- a/tests/test_sql_refsols/singular7_oracle.sql +++ b/tests/test_sql_refsols/singular7_oracle.sql @@ -1,46 +1,46 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT l_partkey AS L_PARTKEY, l_suppkey AS L_SUPPKEY FROM TPCH.LINEITEM WHERE EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 -), _T4 AS ( +), "_T4" AS ( SELECT PARTSUPP.ps_suppkey AS PS_SUPPKEY, ANY_VALUE(PART.p_name) AS ANYTHING_P_NAME, - COUNT(_S3.L_SUPPKEY) AS COUNT_L_SUPPKEY + COUNT("_S3".L_SUPPKEY) AS COUNT_L_SUPPKEY FROM TPCH.PARTSUPP PARTSUPP JOIN TPCH.PART PART ON PART.p_brand = 'Brand#13' AND PART.p_partkey = PARTSUPP.ps_partkey - LEFT JOIN _S3 _S3 - ON PARTSUPP.ps_partkey = _S3.L_PARTKEY AND PARTSUPP.ps_suppkey = _S3.L_SUPPKEY + LEFT JOIN "_S3" "_S3" + ON PARTSUPP.ps_partkey = "_S3".L_PARTKEY AND PARTSUPP.ps_suppkey = "_S3".L_SUPPKEY GROUP BY PARTSUPP.ps_partkey, PARTSUPP.ps_suppkey -), _T AS ( +), "_T" AS ( SELECT PS_SUPPKEY, ANYTHING_P_NAME, COUNT_L_SUPPKEY, - ROW_NUMBER() OVER (PARTITION BY PS_SUPPKEY ORDER BY NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) DESC, ANYTHING_P_NAME) AS _W - FROM _T4 -), _S5 AS ( + ROW_NUMBER() OVER (PARTITION BY PS_SUPPKEY ORDER BY NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) DESC, ANYTHING_P_NAME) AS "_W" + FROM "_T4" +), "_S5" AS ( SELECT NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) AS N_ORDERS, ANYTHING_P_NAME, PS_SUPPKEY - FROM _T + FROM "_T" WHERE - _W = 1 + "_W" = 1 ) SELECT SUPPLIER.s_name AS supplier_name, - _S5.ANYTHING_P_NAME AS part_name, - _S5.N_ORDERS AS n_orders + "_S5".ANYTHING_P_NAME AS part_name, + "_S5".N_ORDERS AS n_orders FROM TPCH.SUPPLIER SUPPLIER -LEFT JOIN _S5 _S5 - ON SUPPLIER.s_suppkey = _S5.PS_SUPPKEY +LEFT JOIN "_S5" "_S5" + ON SUPPLIER.s_suppkey = "_S5".PS_SUPPKEY WHERE SUPPLIER.s_nationkey = 20 ORDER BY diff --git a/tests/test_sql_refsols/smoke_c_oracle.sql b/tests/test_sql_refsols/smoke_c_oracle.sql index cbd04a49e..7d3caa12e 100644 --- a/tests/test_sql_refsols/smoke_c_oracle.sql +++ b/tests/test_sql_refsols/smoke_c_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT c_acctbal AS C_ACCTBAL, c_mktsegment AS C_MKTSEGMENT, @@ -42,4 +42,4 @@ SELECT SUM(CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS p, MAX(EXPR_30) AS q, AVG(EXPR_31) AS r -FROM _T1 +FROM "_T1" diff --git a/tests/test_sql_refsols/string_format_specifiers_oracle.sql b/tests/test_sql_refsols/string_format_specifiers_oracle.sql index 3b50033b2..acb6e4483 100644 --- a/tests/test_sql_refsols/string_format_specifiers_oracle.sql +++ b/tests/test_sql_refsols/string_format_specifiers_oracle.sql @@ -15,4 +15,4 @@ SELECT TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), '.FF') AS d14, TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'TZH:TZM') AS d15 FROM (VALUES - (NULL)) AS _Q_0(_COL_0) + (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/supplier_best_part_oracle.sql b/tests/test_sql_refsols/supplier_best_part_oracle.sql index 369d48ea3..c596df042 100644 --- a/tests/test_sql_refsols/supplier_best_part_oracle.sql +++ b/tests/test_sql_refsols/supplier_best_part_oracle.sql @@ -1,4 +1,4 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT l_partkey AS L_PARTKEY, l_suppkey AS L_SUPPKEY, @@ -10,27 +10,27 @@ WITH _S2 AS ( GROUP BY l_partkey, l_suppkey -), _T AS ( +), "_T" AS ( SELECT - _S2.L_SUPPKEY, - _S2.N_ROWS, + "_S2".L_SUPPKEY, + "_S2".N_ROWS, PART.p_name AS P_NAME, - _S2.SUM_L_QUANTITY, - ROW_NUMBER() OVER (PARTITION BY _S2.L_SUPPKEY ORDER BY NVL(_S2.SUM_L_QUANTITY, 0) DESC) AS _W - FROM _S2 _S2 + "_S2".SUM_L_QUANTITY, + ROW_NUMBER() OVER (PARTITION BY "_S2".L_SUPPKEY ORDER BY NVL("_S2".SUM_L_QUANTITY, 0) DESC) AS "_W" + FROM "_S2" "_S2" JOIN TPCH.PART PART - ON PART.p_partkey = _S2.L_PARTKEY + ON PART.p_partkey = "_S2".L_PARTKEY ) SELECT SUPPLIER.s_name AS supplier_name, - _T.P_NAME AS part_name, - NVL(_T.SUM_L_QUANTITY, 0) AS total_quantity, - _T.N_ROWS AS n_shipments + "_T".P_NAME AS part_name, + NVL("_T".SUM_L_QUANTITY, 0) AS total_quantity, + "_T".N_ROWS AS n_shipments FROM TPCH.SUPPLIER SUPPLIER JOIN TPCH.NATION NATION ON NATION.n_name = 'FRANCE' AND NATION.n_nationkey = SUPPLIER.s_nationkey -JOIN _T _T - ON SUPPLIER.s_suppkey = _T.L_SUPPKEY AND _T._W = 1 +JOIN "_T" "_T" + ON SUPPLIER.s_suppkey = "_T".L_SUPPKEY AND "_T"."_W" = 1 ORDER BY 3 DESC NULLS LAST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql index be7ec1a8b..b95a33666 100644 --- a/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql +++ b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql @@ -1,4 +1,4 @@ -WITH _S7 AS ( +WITH "_S7" AS ( SELECT LINEITEM.l_quantity AS L_QUANTITY, LINEITEM.l_suppkey AS L_SUPPKEY @@ -11,12 +11,12 @@ WITH _S7 AS ( EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) < 7 AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 AND LINEITEM.l_shipmode = 'SHIP' -), _T0 AS ( +), "_T0" AS ( SELECT ANY_VALUE(NATION.n_name) AS ANYTHING_N_NAME, ANY_VALUE(SUPPLIER.s_name) AS ANYTHING_S_NAME, ANY_VALUE(SUPPLIER.s_nationkey) AS ANYTHING_S_NATIONKEY, - SUM(_S7.L_QUANTITY) AS SUM_L_QUANTITY + SUM("_S7".L_QUANTITY) AS SUM_L_QUANTITY FROM TPCH.NATION NATION JOIN TPCH.REGION REGION ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' @@ -24,8 +24,8 @@ WITH _S7 AS ( ON NATION.n_nationkey = SUPPLIER.s_nationkey AND SUPPLIER.s_acctbal >= 8000.0 AND SUPPLIER.s_comment LIKE '%careful%' - LEFT JOIN _S7 _S7 - ON SUPPLIER.s_suppkey = _S7.L_SUPPKEY + LEFT JOIN "_S7" "_S7" + ON SUPPLIER.s_suppkey = "_S7".L_SUPPKEY GROUP BY SUPPLIER.s_suppkey ) @@ -40,7 +40,7 @@ SELECT THEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) ELSE NULL END AS national_qty_pct -FROM _T0 +FROM "_T0" ORDER BY 4 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql index 6968355a0..a874e454b 100644 --- a/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql +++ b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql @@ -1,4 +1,4 @@ -WITH _S7 AS ( +WITH "_S7" AS ( SELECT INCIDENTS.in_device_id AS IN_DEVICE_ID, COUNT(*) AS N_ROWS @@ -11,14 +11,14 @@ WITH _S7 AS ( SELECT COUNTRIES.co_name AS country_name, PRODUCTS.pr_name AS product_name, - ROUND(NVL(SUM(_S7.N_ROWS), 0) / COUNT(*), 2) AS ir + ROUND(NVL(SUM("_S7".N_ROWS), 0) / COUNT(*), 2) AS ir FROM MAIN.COUNTRIES COUNTRIES JOIN MAIN.DEVICES DEVICES ON COUNTRIES.co_id = DEVICES.de_production_country_id JOIN MAIN.PRODUCTS PRODUCTS ON DEVICES.de_product_id = PRODUCTS.pr_id -LEFT JOIN _S7 _S7 - ON DEVICES.de_id = _S7.IN_DEVICE_ID +LEFT JOIN "_S7" "_S7" + ON DEVICES.de_id = "_S7".IN_DEVICE_ID GROUP BY COUNTRIES.co_name, PRODUCTS.pr_name diff --git a/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql b/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql index a392b1a3c..39824a9b5 100644 --- a/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql +++ b/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql @@ -1,12 +1,12 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.COUNTRIES ) SELECT COUNTRIES.co_name AS name, - _S1.N_ROWS AS n_other_countries + "_S1".N_ROWS AS n_other_countries FROM MAIN.COUNTRIES COUNTRIES -CROSS JOIN _S1 _S1 +CROSS JOIN "_S1" "_S1" ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql index 3fc67dd77..3f92d0bd2 100644 --- a/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql +++ b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql @@ -1,45 +1,45 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT co_id AS CO_ID, co_name AS CO_NAME FROM MAIN.COUNTRIES -), _S2 AS ( +), "_S2" AS ( SELECT co_id AS CO_ID FROM MAIN.COUNTRIES -), _T1 AS ( +), "_T1" AS ( SELECT - ANY_VALUE(_S3.CO_ID) AS ANYTHING__ID_3, - ANY_VALUE(_S2.CO_ID) AS ANYTHING_CO_ID, + ANY_VALUE("_S3".CO_ID) AS ANYTHING__ID_3, + ANY_VALUE("_S2".CO_ID) AS ANYTHING_CO_ID, COUNT(INCIDENTS.in_device_id) AS COUNT_IN_DEVICE_ID - FROM _S2 _S2 - CROSS JOIN _S2 _S3 + FROM "_S2" "_S2" + CROSS JOIN "_S2" "_S3" JOIN MAIN.DEVICES DEVICES - ON DEVICES.de_production_country_id = _S2.CO_ID - AND DEVICES.de_purchase_country_id = _S3.CO_ID + ON DEVICES.de_production_country_id = "_S2".CO_ID + AND DEVICES.de_purchase_country_id = "_S3".CO_ID LEFT JOIN MAIN.INCIDENTS INCIDENTS ON DEVICES.de_id = INCIDENTS.in_device_id GROUP BY DEVICES.de_id -), _S9 AS ( +), "_S9" AS ( SELECT ANYTHING__ID_3, ANYTHING_CO_ID, COUNT(*) AS N_ROWS, SUM(COUNT_IN_DEVICE_ID) AS SUM_N_ROWS - FROM _T1 + FROM "_T1" GROUP BY ANYTHING__ID_3, ANYTHING_CO_ID ) SELECT - _S0.CO_NAME AS factory_country, - _S1.CO_NAME AS purchase_country, - ROUND(NVL(_S9.SUM_N_ROWS, 0) / NVL(_S9.N_ROWS, 0), 2) AS ir -FROM _S0 _S0 -CROSS JOIN _S0 _S1 -LEFT JOIN _S9 _S9 - ON _S0.CO_ID = _S9.ANYTHING_CO_ID AND _S1.CO_ID = _S9.ANYTHING__ID_3 + "_S0".CO_NAME AS factory_country, + "_S1".CO_NAME AS purchase_country, + ROUND(NVL("_S9".SUM_N_ROWS, 0) / NVL("_S9".N_ROWS, 0), 2) AS ir +FROM "_S0" "_S0" +CROSS JOIN "_S0" "_S1" +LEFT JOIN "_S9" "_S9" + ON "_S0".CO_ID = "_S9".ANYTHING_CO_ID AND "_S1".CO_ID = "_S9".ANYTHING__ID_3 ORDER BY 3 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql index 015d0f98f..615b82e2d 100644 --- a/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql +++ b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql @@ -1,72 +1,72 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT in_device_id AS IN_DEVICE_ID FROM MAIN.INCIDENTS -), _S1 AS ( +), "_S1" AS ( SELECT IN_DEVICE_ID, COUNT(*) AS N_ROWS - FROM _T2 + FROM "_T2" GROUP BY IN_DEVICE_ID -), _S3 AS ( +), "_S3" AS ( SELECT DEVICES.de_production_country_id AS DE_PRODUCTION_COUNTRY_ID, COUNT(*) AS N_ROWS, - SUM(_S1.N_ROWS) AS SUM_N_ROWS + SUM("_S1".N_ROWS) AS SUM_N_ROWS FROM MAIN.DEVICES DEVICES - LEFT JOIN _S1 _S1 - ON DEVICES.de_id = _S1.IN_DEVICE_ID + LEFT JOIN "_S1" "_S1" + ON DEVICES.de_id = "_S1".IN_DEVICE_ID GROUP BY DEVICES.de_production_country_id -), _S5 AS ( +), "_S5" AS ( SELECT IN_DEVICE_ID, COUNT(*) AS N_ROWS - FROM _T2 + FROM "_T2" GROUP BY IN_DEVICE_ID -), _S7 AS ( +), "_S7" AS ( SELECT DEVICES.de_purchase_country_id AS DE_PURCHASE_COUNTRY_ID, COUNT(*) AS N_ROWS, - SUM(_S5.N_ROWS) AS SUM_N_ROWS + SUM("_S5".N_ROWS) AS SUM_N_ROWS FROM MAIN.DEVICES DEVICES - LEFT JOIN _S5 _S5 - ON DEVICES.de_id = _S5.IN_DEVICE_ID + LEFT JOIN "_S5" "_S5" + ON DEVICES.de_id = "_S5".IN_DEVICE_ID GROUP BY DEVICES.de_purchase_country_id -), _T5 AS ( +), "_T5" AS ( SELECT ANY_VALUE(USERS.us_country_id) AS ANYTHING_US_COUNTRY_ID, - COUNT(_S11.IN_DEVICE_ID) AS COUNT_IN_DEVICE_ID + COUNT("_S11".IN_DEVICE_ID) AS COUNT_IN_DEVICE_ID FROM MAIN.USERS USERS JOIN MAIN.DEVICES DEVICES ON DEVICES.de_owner_id = USERS.us_id - LEFT JOIN _T2 _S11 - ON DEVICES.de_id = _S11.IN_DEVICE_ID + LEFT JOIN "_T2" "_S11" + ON DEVICES.de_id = "_S11".IN_DEVICE_ID GROUP BY DEVICES.de_id -), _S13 AS ( +), "_S13" AS ( SELECT ANYTHING_US_COUNTRY_ID, COUNT(*) AS N_ROWS, SUM(COUNT_IN_DEVICE_ID) AS SUM_N_ROWS - FROM _T5 + FROM "_T5" GROUP BY ANYTHING_US_COUNTRY_ID ) SELECT COUNTRIES.co_name AS country_name, - ROUND(NVL(_S3.SUM_N_ROWS, 0) / _S3.N_ROWS, 2) AS made_ir, - ROUND(NVL(_S7.SUM_N_ROWS, 0) / _S7.N_ROWS, 2) AS sold_ir, - ROUND(NVL(_S13.SUM_N_ROWS, 0) / NVL(_S13.N_ROWS, 0), 2) AS user_ir + ROUND(NVL("_S3".SUM_N_ROWS, 0) / "_S3".N_ROWS, 2) AS made_ir, + ROUND(NVL("_S7".SUM_N_ROWS, 0) / "_S7".N_ROWS, 2) AS sold_ir, + ROUND(NVL("_S13".SUM_N_ROWS, 0) / NVL("_S13".N_ROWS, 0), 2) AS user_ir FROM MAIN.COUNTRIES COUNTRIES -JOIN _S3 _S3 - ON COUNTRIES.co_id = _S3.DE_PRODUCTION_COUNTRY_ID -JOIN _S7 _S7 - ON COUNTRIES.co_id = _S7.DE_PURCHASE_COUNTRY_ID -LEFT JOIN _S13 _S13 - ON COUNTRIES.co_id = _S13.ANYTHING_US_COUNTRY_ID +JOIN "_S3" "_S3" + ON COUNTRIES.co_id = "_S3".DE_PRODUCTION_COUNTRY_ID +JOIN "_S7" "_S7" + ON COUNTRIES.co_id = "_S7".DE_PURCHASE_COUNTRY_ID +LEFT JOIN "_S13" "_S13" + ON COUNTRIES.co_id = "_S13".ANYTHING_US_COUNTRY_ID ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql index 453472e15..313f27c5a 100644 --- a/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql +++ b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql @@ -1,4 +1,4 @@ -WITH _S5 AS ( +WITH "_S5" AS ( SELECT INCIDENTS.in_error_id AS IN_ERROR_ID, COUNT(*) AS N_ROWS @@ -13,10 +13,10 @@ WITH _S5 AS ( SELECT ERRORS.er_name AS error, ROUND(( - 100.0 * NVL(_S5.N_ROWS, 0) - ) / SUM(NVL(_S5.N_ROWS, 0)) OVER (), 2) AS pct + 100.0 * NVL("_S5".N_ROWS, 0) + ) / SUM(NVL("_S5".N_ROWS, 0)) OVER (), 2) AS pct FROM MAIN.ERRORS ERRORS -LEFT JOIN _S5 _S5 - ON ERRORS.er_id = _S5.IN_ERROR_ID +LEFT JOIN "_S5" "_S5" + ON ERRORS.er_id = "_S5".IN_ERROR_ID ORDER BY 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql index bd6ad7122..89f70b5c5 100644 --- a/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql +++ b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql @@ -1,4 +1,4 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT ANY_VALUE(DEVICES.de_production_country_id) AS ANYTHING_DE_PRODUCTION_COUNTRY_ID, COUNT(INCIDENTS.in_device_id) AS COUNT_IN_DEVICE_ID @@ -9,20 +9,20 @@ WITH _T2 AS ( ON DEVICES.de_id = INCIDENTS.in_device_id GROUP BY DEVICES.de_id -), _S5 AS ( +), "_S5" AS ( SELECT NVL(SUM(COUNT_IN_DEVICE_ID), 0) AS SUM_N_INCIDENTS, ANYTHING_DE_PRODUCTION_COUNTRY_ID, COUNT(*) AS N_ROWS - FROM _T2 + FROM "_T2" GROUP BY ANYTHING_DE_PRODUCTION_COUNTRY_ID ) SELECT COUNTRIES.co_name AS country, - ROUND(NVL(_S5.SUM_N_INCIDENTS, 0) / NVL(_S5.N_ROWS, 0), 2) AS ir + ROUND(NVL("_S5".SUM_N_INCIDENTS, 0) / NVL("_S5".N_ROWS, 0), 2) AS ir FROM MAIN.COUNTRIES COUNTRIES -LEFT JOIN _S5 _S5 - ON COUNTRIES.co_id = _S5.ANYTHING_DE_PRODUCTION_COUNTRY_ID +LEFT JOIN "_S5" "_S5" + ON COUNTRIES.co_id = "_S5".ANYTHING_DE_PRODUCTION_COUNTRY_ID ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql index d95ee89cb..c6d1a9a99 100644 --- a/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql +++ b/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql @@ -1,13 +1,13 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.INCIDENTS -), _S1 AS ( +), "_S1" AS ( SELECT COUNT(*) AS N_ROWS FROM MAIN.DEVICES ) SELECT - ROUND(_S0.N_ROWS / _S1.N_ROWS, 2) AS ir -FROM _S0 _S0 -CROSS JOIN _S1 _S1 + ROUND("_S0".N_ROWS / "_S1".N_ROWS, 2) AS ir +FROM "_S0" "_S0" +CROSS JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql index ddcd91706..386e41d20 100644 --- a/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql +++ b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql @@ -1,41 +1,41 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT de_product_id AS DE_PRODUCT_ID, COUNT(*) AS N_ROWS FROM MAIN.DEVICES GROUP BY de_product_id -), _S1 AS ( +), "_S1" AS ( SELECT pr_id AS PR_ID, pr_release AS PR_RELEASE FROM MAIN.PRODUCTS -), _S6 AS ( +), "_S6" AS ( SELECT - EXTRACT(YEAR FROM CAST(_S1.PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, - SUM(_S0.N_ROWS) AS SUM_N_ROWS - FROM _S0 _S0 - JOIN _S1 _S1 - ON _S0.DE_PRODUCT_ID = _S1.PR_ID + EXTRACT(YEAR FROM CAST("_S1".PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + SUM("_S0".N_ROWS) AS SUM_N_ROWS + FROM "_S0" "_S0" + JOIN "_S1" "_S1" + ON "_S0".DE_PRODUCT_ID = "_S1".PR_ID GROUP BY - EXTRACT(YEAR FROM CAST(_S1.PR_RELEASE AS DATETIME)) -), _S7 AS ( + EXTRACT(YEAR FROM CAST("_S1".PR_RELEASE AS DATETIME)) +), "_S7" AS ( SELECT - EXTRACT(YEAR FROM CAST(_S3.PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, COUNT(*) AS N_ROWS FROM MAIN.DEVICES DEVICES - JOIN _S1 _S3 - ON DEVICES.de_product_id = _S3.PR_ID + JOIN "_S1" "_S3" + ON DEVICES.de_product_id = "_S3".PR_ID JOIN MAIN.INCIDENTS INCIDENTS ON DEVICES.de_id = INCIDENTS.in_device_id GROUP BY - EXTRACT(YEAR FROM CAST(_S3.PR_RELEASE AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATETIME)) ) SELECT - _S6.YEAR_PR_RELEASE AS year, - ROUND(NVL(_S7.N_ROWS, 0) / _S6.SUM_N_ROWS, 2) AS ir -FROM _S6 _S6 -LEFT JOIN _S7 _S7 - ON _S6.YEAR_PR_RELEASE = _S7.YEAR_PR_RELEASE + "_S6".YEAR_PR_RELEASE AS year, + ROUND(NVL("_S7".N_ROWS, 0) / "_S6".SUM_N_ROWS, 2) AS ir +FROM "_S6" "_S6" +LEFT JOIN "_S7" "_S7" + ON "_S6".YEAR_PR_RELEASE = "_S7".YEAR_PR_RELEASE ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql index 84a771042..ce0801521 100644 --- a/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql +++ b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT in_device_id AS IN_DEVICE_ID, COUNT(*) AS N_ROWS @@ -8,12 +8,12 @@ WITH _S3 AS ( ) SELECT PRODUCTS.pr_brand AS brand, - ROUND(NVL(SUM(_S3.N_ROWS), 0) / COUNT(*), 2) AS ir + ROUND(NVL(SUM("_S3".N_ROWS), 0) / COUNT(*), 2) AS ir FROM MAIN.DEVICES DEVICES JOIN MAIN.PRODUCTS PRODUCTS ON DEVICES.de_product_id = PRODUCTS.pr_id -LEFT JOIN _S3 _S3 - ON DEVICES.de_id = _S3.IN_DEVICE_ID +LEFT JOIN "_S3" "_S3" + ON DEVICES.de_id = "_S3".IN_DEVICE_ID GROUP BY PRODUCTS.pr_brand ORDER BY diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql index 7e5e503b8..a7a0aa0f3 100644 --- a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -1,56 +1,56 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT ca_dt AS CA_DT FROM MAIN.CALENDAR WHERE EXTRACT(YEAR FROM CAST(ca_dt AS DATETIME)) IN (2020, 2021) -), _T5 AS ( +), "_T5" AS ( SELECT co_id AS CO_ID, co_name AS CO_NAME FROM MAIN.COUNTRIES WHERE co_name = 'CN' -), _S7 AS ( +), "_S7" AS ( SELECT - _T4.CA_DT, + "_T4".CA_DT, COUNT(*) AS N_ROWS - FROM _T2 _T4 + FROM "_T2" "_T4" JOIN MAIN.CALENDAR CALENDAR - ON CALENDAR.ca_dt >= DATE_SUB(CAST(_T4.CA_DT AS TIMESTAMP), 6, MONTH) + ON CALENDAR.ca_dt >= DATE_SUB(CAST("_T4".CA_DT AS TIMESTAMP), 6, MONTH) JOIN MAIN.DEVICES DEVICES ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') - JOIN _T5 _T5 - ON DEVICES.de_production_country_id = _T5.CO_ID + JOIN "_T5" "_T5" + ON DEVICES.de_production_country_id = "_T5".CO_ID GROUP BY - _T4.CA_DT -), _S15 AS ( + "_T4".CA_DT +), "_S15" AS ( SELECT - _T7.CA_DT, + "_T7".CA_DT, COUNT(*) AS N_ROWS - FROM _T2 _T7 + FROM "_T2" "_T7" JOIN MAIN.INCIDENTS INCIDENTS - ON _T7.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_T7".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id - JOIN _T5 _T8 - ON DEVICES.de_production_country_id = _T8.CO_ID + JOIN "_T5" "_T8" + ON DEVICES.de_production_country_id = "_T8".CO_ID GROUP BY - _T7.CA_DT -), _T0 AS ( + "_T7".CA_DT +), "_T0" AS ( SELECT - EXTRACT(MONTH FROM CAST(_T2.CA_DT AS DATETIME)) AS MONTH_CA_DT, - EXTRACT(YEAR FROM CAST(_T2.CA_DT AS DATETIME)) AS YEAR_CA_DT, - SUM(_S7.N_ROWS) AS SUM_EXPR_3, - SUM(_S15.N_ROWS) AS SUM_N_ROWS - FROM _T2 _T2 - LEFT JOIN _S7 _S7 - ON _S7.CA_DT = _T2.CA_DT - LEFT JOIN _S15 _S15 - ON _S15.CA_DT = _T2.CA_DT + EXTRACT(MONTH FROM CAST("_T2".CA_DT AS DATETIME)) AS MONTH_CA_DT, + EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM("_S7".N_ROWS) AS SUM_EXPR_3, + SUM("_S15".N_ROWS) AS SUM_N_ROWS + FROM "_T2" "_T2" + LEFT JOIN "_S7" "_S7" + ON "_S7".CA_DT = "_T2".CA_DT + LEFT JOIN "_S15" "_S15" + ON "_S15".CA_DT = "_T2".CA_DT GROUP BY - EXTRACT(MONTH FROM CAST(_T2.CA_DT AS DATETIME)), - EXTRACT(YEAR FROM CAST(_T2.CA_DT AS DATETIME)) + EXTRACT(MONTH FROM CAST("_T2".CA_DT AS DATETIME)), + EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATETIME)) ) SELECT LISTAGG( @@ -65,6 +65,6 @@ SELECT ROUND(( 1000000.0 * NVL(SUM_N_ROWS, 0) ) / NVL(SUM_EXPR_3, 0), 2) AS ir -FROM _T0 +FROM "_T0" ORDER BY MONTH_CA_DT NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql index 17ed6ecf1..8479e10e0 100644 --- a/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql +++ b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql @@ -1,18 +1,18 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT in_device_id AS IN_DEVICE_ID, COUNT(*) AS N_ROWS FROM MAIN.INCIDENTS GROUP BY in_device_id -), _S3 AS ( +), "_S3" AS ( SELECT DEVICES.de_product_id AS DE_PRODUCT_ID, COUNT(*) AS N_ROWS, - SUM(_S1.N_ROWS) AS SUM_N_ROWS + SUM("_S1".N_ROWS) AS SUM_N_ROWS FROM MAIN.DEVICES DEVICES - LEFT JOIN _S1 _S1 - ON DEVICES.de_id = _S1.IN_DEVICE_ID + LEFT JOIN "_S1" "_S1" + ON DEVICES.de_id = "_S1".IN_DEVICE_ID GROUP BY DEVICES.de_product_id ) @@ -20,10 +20,10 @@ SELECT PRODUCTS.pr_name AS product, PRODUCTS.pr_brand AS product_brand, PRODUCTS.pr_type AS product_type, - ROUND(NVL(_S3.SUM_N_ROWS, 0) / _S3.N_ROWS, 2) AS ir + ROUND(NVL("_S3".SUM_N_ROWS, 0) / "_S3".N_ROWS, 2) AS ir FROM MAIN.PRODUCTS PRODUCTS -JOIN _S3 _S3 - ON PRODUCTS.pr_id = _S3.DE_PRODUCT_ID +JOIN "_S3" "_S3" + ON PRODUCTS.pr_id = "_S3".DE_PRODUCT_ID ORDER BY 4 DESC NULLS LAST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql index f53d9460f..51aa465fa 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql @@ -1,83 +1,83 @@ -WITH _S14 AS ( +WITH "_S14" AS ( SELECT ANY_VALUE(pr_release) AS ANYTHING_PR_RELEASE FROM MAIN.PRODUCTS WHERE pr_name = 'GoldCopper-Star' -), _S6 AS ( +), "_S6" AS ( SELECT ca_dt AS CA_DT FROM MAIN.CALENDAR -), _T5 AS ( +), "_T5" AS ( SELECT pr_id AS PR_ID, pr_name AS PR_NAME FROM MAIN.PRODUCTS WHERE pr_name = 'GoldCopper-Star' -), _S7 AS ( +), "_S7" AS ( SELECT - _S0.CA_DT, + "_S0".CA_DT, COUNT(*) AS N_ROWS - FROM _S6 _S0 + FROM "_S6" "_S0" JOIN MAIN.INCIDENTS INCIDENTS - ON _S0.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_S0".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id - JOIN _T5 _T5 - ON DEVICES.de_product_id = _T5.PR_ID + JOIN "_T5" "_T5" + ON DEVICES.de_product_id = "_T5".PR_ID GROUP BY - _S0.CA_DT -), _S13 AS ( + "_S0".CA_DT +), "_S13" AS ( SELECT - _S8.CA_DT, + "_S8".CA_DT, COUNT(*) AS N_ROWS - FROM _S6 _S8 + FROM "_S6" "_S8" JOIN MAIN.DEVICES DEVICES - ON _S8.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') - JOIN _T5 _T7 - ON DEVICES.de_product_id = _T7.PR_ID + ON "_S8".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN "_T5" "_T7" + ON DEVICES.de_product_id = "_T7".PR_ID GROUP BY - _S8.CA_DT -), _S15 AS ( + "_S8".CA_DT +), "_S15" AS ( SELECT - EXTRACT(YEAR FROM CAST(_S6.CA_DT AS DATETIME)) AS YEAR_CA_DT, - SUM(_S7.N_ROWS) AS SUM_EXPR_4, - SUM(_S13.N_ROWS) AS SUM_N_ROWS - FROM _S6 _S6 - LEFT JOIN _S7 _S7 - ON _S6.CA_DT = _S7.CA_DT - LEFT JOIN _S13 _S13 - ON _S13.CA_DT = _S6.CA_DT + EXTRACT(YEAR FROM CAST("_S6".CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM("_S7".N_ROWS) AS SUM_EXPR_4, + SUM("_S13".N_ROWS) AS SUM_N_ROWS + FROM "_S6" "_S6" + LEFT JOIN "_S7" "_S7" + ON "_S6".CA_DT = "_S7".CA_DT + LEFT JOIN "_S13" "_S13" + ON "_S13".CA_DT = "_S6".CA_DT GROUP BY - EXTRACT(YEAR FROM CAST(_S6.CA_DT AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S6".CA_DT AS DATETIME)) ) SELECT - _S15.YEAR_CA_DT - EXTRACT(YEAR FROM CAST(_S14.ANYTHING_PR_RELEASE AS DATETIME)) AS years_since_release, + "_S15".YEAR_CA_DT - EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATETIME)) AS years_since_release, ROUND( - SUM(NVL(_S15.SUM_EXPR_4, 0)) OVER (ORDER BY _S15.YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S15.SUM_N_ROWS, 0)) OVER (ORDER BY _S15.YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(NVL("_S15".SUM_EXPR_4, 0)) OVER (ORDER BY "_S15".YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL("_S15".SUM_N_ROWS, 0)) OVER (ORDER BY "_S15".YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS cum_ir, ROUND( ( 100.0 * ( - NVL(_S15.SUM_N_ROWS, 0) - LAG(NVL(_S15.SUM_N_ROWS, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT) + NVL("_S15".SUM_N_ROWS, 0) - LAG(NVL("_S15".SUM_N_ROWS, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT) ) - ) / LAG(NVL(_S15.SUM_N_ROWS, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT), + ) / LAG(NVL("_S15".SUM_N_ROWS, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT), 2 ) AS pct_bought_change, ROUND( ( 100.0 * ( - NVL(_S15.SUM_EXPR_4, 0) - LAG(NVL(_S15.SUM_EXPR_4, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT) + NVL("_S15".SUM_EXPR_4, 0) - LAG(NVL("_S15".SUM_EXPR_4, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT) ) - ) / LAG(NVL(_S15.SUM_EXPR_4, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT), + ) / LAG(NVL("_S15".SUM_EXPR_4, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT), 2 ) AS pct_incident_change, - NVL(_S15.SUM_N_ROWS, 0) AS bought, - NVL(_S15.SUM_EXPR_4, 0) AS incidents -FROM _S14 _S14 -JOIN _S15 _S15 - ON _S15.YEAR_CA_DT >= EXTRACT(YEAR FROM CAST(_S14.ANYTHING_PR_RELEASE AS DATETIME)) + NVL("_S15".SUM_N_ROWS, 0) AS bought, + NVL("_S15".SUM_EXPR_4, 0) AS incidents +FROM "_S14" "_S14" +JOIN "_S15" "_S15" + ON "_S15".YEAR_CA_DT >= EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATETIME)) ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql index 175af7a5c..771f161fa 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql @@ -1,37 +1,37 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT ca_dt AS CA_DT FROM MAIN.CALENDAR -), _S3 AS ( +), "_S3" AS ( SELECT - _S0.CA_DT, + "_S0".CA_DT, COUNT(*) AS N_ROWS - FROM _S2 _S0 + FROM "_S2" "_S0" JOIN MAIN.DEVICES DEVICES - ON _S0.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON "_S0".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') GROUP BY - _S0.CA_DT -), _S7 AS ( + "_S0".CA_DT +), "_S7" AS ( SELECT - _S4.CA_DT, + "_S4".CA_DT, COUNT(*) AS N_ROWS - FROM _S2 _S4 + FROM "_S2" "_S4" JOIN MAIN.INCIDENTS INCIDENTS - ON _S4.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_S4".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') GROUP BY - _S4.CA_DT -), _T1 AS ( + "_S4".CA_DT +), "_T1" AS ( SELECT - EXTRACT(YEAR FROM CAST(_S2.CA_DT AS DATETIME)) AS YEAR_CA_DT, - SUM(_S3.N_ROWS) AS SUM_EXPR_3, - SUM(_S7.N_ROWS) AS SUM_N_ROWS - FROM _S2 _S2 - LEFT JOIN _S3 _S3 - ON _S2.CA_DT = _S3.CA_DT - LEFT JOIN _S7 _S7 - ON _S2.CA_DT = _S7.CA_DT + EXTRACT(YEAR FROM CAST("_S2".CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM("_S3".N_ROWS) AS SUM_EXPR_3, + SUM("_S7".N_ROWS) AS SUM_N_ROWS + FROM "_S2" "_S2" + LEFT JOIN "_S3" "_S3" + ON "_S2".CA_DT = "_S3".CA_DT + LEFT JOIN "_S7" "_S7" + ON "_S2".CA_DT = "_S7".CA_DT GROUP BY - EXTRACT(YEAR FROM CAST(_S2.CA_DT AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S2".CA_DT AS DATETIME)) ) SELECT YEAR_CA_DT AS yr, @@ -57,7 +57,7 @@ SELECT ) AS pct_incident_change, SUM_EXPR_3 AS bought, NVL(SUM_N_ROWS, 0) AS incidents -FROM _T1 +FROM "_T1" WHERE NOT SUM_EXPR_3 IS NULL AND SUM_EXPR_3 <> 0 ORDER BY diff --git a/tests/test_sql_refsols/time_threshold_reached_oracle.sql b/tests/test_sql_refsols/time_threshold_reached_oracle.sql index 3d399735d..0c29394fc 100644 --- a/tests/test_sql_refsols/time_threshold_reached_oracle.sql +++ b/tests/test_sql_refsols/time_threshold_reached_oracle.sql @@ -1,4 +1,4 @@ -WITH _T3 AS ( +WITH "_T3" AS ( SELECT sbtxdatetime AS SBTXDATETIME, ( @@ -7,18 +7,18 @@ WITH _T3 AS ( FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 -), _T AS ( +), "_T" AS ( SELECT SBTXDATETIME, - ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'DAY') ORDER BY PCT_OF_DAY) AS _W - FROM _T3 + ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'DAY') ORDER BY PCT_OF_DAY) AS "_W" + FROM "_T3" WHERE PCT_OF_DAY >= 50.0 ) SELECT SBTXDATETIME AS date_time -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/top_customers_by_orders_oracle.sql b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql index f42e449d6..565de3cbd 100644 --- a/tests/test_sql_refsols/top_customers_by_orders_oracle.sql +++ b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS @@ -8,10 +8,10 @@ WITH _S1 AS ( ) SELECT CUSTOMER.c_custkey AS customer_key, - NVL(_S1.N_ROWS, 0) AS n_orders + NVL("_S1".N_ROWS, 0) AS n_orders FROM TPCH.CUSTOMER CUSTOMER -LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ORDER BY 2 DESC NULLS LAST, 1 NULLS FIRST diff --git a/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql b/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql index 93cc2f7a8..b76487781 100644 --- a/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql +++ b/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql @@ -1,4 +1,4 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT l_linenumber AS L_LINENUMBER, l_orderkey AS L_ORDERKEY, @@ -9,26 +9,26 @@ WITH _S2 AS ( 2 NULLS FIRST, 1 NULLS FIRST FETCH FIRST 7 ROWS ONLY -), _S0 AS ( +), "_S0" AS ( SELECT ps_partkey AS PS_PARTKEY, ps_suppkey AS PS_SUPPKEY FROM TPCH.PARTSUPP ) SELECT - _S2.L_ORDERKEY AS order_key, - _S2.L_LINENUMBER AS line_number, + "_S2".L_ORDERKEY AS order_key, + "_S2".L_LINENUMBER AS line_number, PART.p_size AS part_size, SUPPLIER.s_nationkey AS supplier_nation -FROM _S2 _S2 -JOIN _S0 _S0 - ON _S0.PS_PARTKEY = _S2.L_PARTKEY AND _S0.PS_SUPPKEY = _S2.L_SUPPKEY +FROM "_S2" "_S2" +JOIN "_S0" "_S0" + ON "_S0".PS_PARTKEY = "_S2".L_PARTKEY AND "_S0".PS_SUPPKEY = "_S2".L_SUPPKEY JOIN TPCH.PART PART - ON PART.p_partkey = _S0.PS_PARTKEY -JOIN _S0 _S4 - ON _S2.L_PARTKEY = _S4.PS_PARTKEY AND _S2.L_SUPPKEY = _S4.PS_SUPPKEY + ON PART.p_partkey = "_S0".PS_PARTKEY +JOIN "_S0" "_S4" + ON "_S2".L_PARTKEY = "_S4".PS_PARTKEY AND "_S2".L_SUPPKEY = "_S4".PS_SUPPKEY JOIN TPCH.SUPPLIER SUPPLIER - ON SUPPLIER.s_suppkey = _S4.PS_SUPPKEY + ON SUPPLIER.s_suppkey = "_S4".PS_SUPPKEY ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql b/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql index 2ba9d5bfe..c5ac68ac1 100644 --- a/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql +++ b/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT ps_partkey AS PS_PARTKEY, ps_suppkey AS PS_SUPPKEY @@ -10,18 +10,18 @@ SELECT PART.p_size AS part_size, NATION.n_nationkey AS supplier_nation FROM TPCH.PART PART -JOIN _S1 _S1 - ON PART.p_partkey = _S1.PS_PARTKEY +JOIN "_S1" "_S1" + ON PART.p_partkey = "_S1".PS_PARTKEY CROSS JOIN TPCH.NATION NATION JOIN TPCH.SUPPLIER SUPPLIER ON NATION.n_nationkey = SUPPLIER.s_nationkey -JOIN _S1 _S7 - ON SUPPLIER.s_suppkey = _S7.PS_SUPPKEY +JOIN "_S1" "_S7" + ON SUPPLIER.s_suppkey = "_S7".PS_SUPPKEY JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_partkey = PART.p_partkey - AND LINEITEM.l_partkey = _S7.PS_PARTKEY - AND LINEITEM.l_suppkey = _S1.PS_SUPPKEY - AND LINEITEM.l_suppkey = _S7.PS_SUPPKEY + AND LINEITEM.l_partkey = "_S7".PS_PARTKEY + AND LINEITEM.l_suppkey = "_S1".PS_SUPPKEY + AND LINEITEM.l_suppkey = "_S7".PS_SUPPKEY ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q10_oracle.sql b/tests/test_sql_refsols/tpch_q10_oracle.sql index 36805543d..6bcc8bef3 100644 --- a/tests/test_sql_refsols/tpch_q10_oracle.sql +++ b/tests/test_sql_refsols/tpch_q10_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT ORDERS.o_custkey AS O_CUSTKEY, SUM(LINEITEM.l_extendedprice * ( @@ -16,15 +16,15 @@ WITH _S3 AS ( SELECT CUSTOMER.c_custkey AS C_CUSTKEY, CUSTOMER.c_name AS C_NAME, - NVL(_S3.SUM_EXPR, 0) AS REVENUE, + NVL("_S3".SUM_EXPR, 0) AS REVENUE, CUSTOMER.c_acctbal AS C_ACCTBAL, NATION.n_name AS N_NAME, CUSTOMER.c_address AS C_ADDRESS, CUSTOMER.c_phone AS C_PHONE, CUSTOMER.c_comment AS C_COMMENT FROM TPCH.CUSTOMER CUSTOMER -LEFT JOIN _S3 _S3 - ON CUSTOMER.c_custkey = _S3.O_CUSTKEY +LEFT JOIN "_S3" "_S3" + ON CUSTOMER.c_custkey = "_S3".O_CUSTKEY JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey ORDER BY diff --git a/tests/test_sql_refsols/tpch_q11_oracle.sql b/tests/test_sql_refsols/tpch_q11_oracle.sql index 97d323b64..fb0f113a0 100644 --- a/tests/test_sql_refsols/tpch_q11_oracle.sql +++ b/tests/test_sql_refsols/tpch_q11_oracle.sql @@ -1,43 +1,43 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT s_nationkey AS S_NATIONKEY, s_suppkey AS S_SUPPKEY FROM TPCH.SUPPLIER -), _T2 AS ( +), "_T2" AS ( SELECT n_name AS N_NAME, n_nationkey AS N_NATIONKEY FROM TPCH.NATION WHERE n_name = 'GERMANY' -), _S8 AS ( +), "_S8" AS ( SELECT SUM(PARTSUPP.ps_supplycost * PARTSUPP.ps_availqty) AS SUM_METRIC FROM TPCH.PARTSUPP PARTSUPP - JOIN _S0 _S0 - ON PARTSUPP.ps_suppkey = _S0.S_SUPPKEY - JOIN _T2 _T2 - ON _S0.S_NATIONKEY = _T2.N_NATIONKEY -), _S9 AS ( + JOIN "_S0" "_S0" + ON PARTSUPP.ps_suppkey = "_S0".S_SUPPKEY + JOIN "_T2" "_T2" + ON "_S0".S_NATIONKEY = "_T2".N_NATIONKEY +), "_S9" AS ( SELECT PARTSUPP.ps_partkey AS PS_PARTKEY, SUM(PARTSUPP.ps_supplycost * PARTSUPP.ps_availqty) AS SUM_EXPR FROM TPCH.PARTSUPP PARTSUPP - JOIN _S0 _S4 - ON PARTSUPP.ps_suppkey = _S4.S_SUPPKEY - JOIN _T2 _T4 - ON _S4.S_NATIONKEY = _T4.N_NATIONKEY + JOIN "_S0" "_S4" + ON PARTSUPP.ps_suppkey = "_S4".S_SUPPKEY + JOIN "_T2" "_T4" + ON "_S4".S_NATIONKEY = "_T4".N_NATIONKEY GROUP BY PARTSUPP.ps_partkey ) SELECT - _S9.PS_PARTKEY, - NVL(_S9.SUM_EXPR, 0) AS VALUE -FROM _S8 _S8 -JOIN _S9 _S9 + "_S9".PS_PARTKEY, + NVL("_S9".SUM_EXPR, 0) AS VALUE +FROM "_S8" "_S8" +JOIN "_S9" "_S9" ON ( - NVL(_S8.SUM_METRIC, 0) * 0.0001 - ) < NVL(_S9.SUM_EXPR, 0) + NVL("_S8".SUM_METRIC, 0) * 0.0001 + ) < NVL("_S9".SUM_EXPR, 0) ORDER BY 2 DESC NULLS LAST FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q13_oracle.sql b/tests/test_sql_refsols/tpch_q13_oracle.sql index 299744cfc..2d44a883a 100644 --- a/tests/test_sql_refsols/tpch_q13_oracle.sql +++ b/tests/test_sql_refsols/tpch_q13_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT o_custkey AS O_CUSTKEY, COUNT(*) AS N_ROWS @@ -9,13 +9,13 @@ WITH _S1 AS ( o_custkey ) SELECT - NVL(_S1.N_ROWS, 0) AS C_COUNT, + NVL("_S1".N_ROWS, 0) AS C_COUNT, COUNT(*) AS CUSTDIST FROM TPCH.CUSTOMER CUSTOMER -LEFT JOIN _S1 _S1 - ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY GROUP BY - NVL(_S1.N_ROWS, 0) + NVL("_S1".N_ROWS, 0) ORDER BY 2 DESC NULLS LAST, 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/tpch_q15_oracle.sql b/tests/test_sql_refsols/tpch_q15_oracle.sql index a684e9527..d625b081c 100644 --- a/tests/test_sql_refsols/tpch_q15_oracle.sql +++ b/tests/test_sql_refsols/tpch_q15_oracle.sql @@ -1,4 +1,4 @@ -WITH _T3 AS ( +WITH "_T3" AS ( SELECT l_discount AS L_DISCOUNT, l_extendedprice AS L_EXTENDEDPRICE, @@ -8,25 +8,25 @@ WITH _T3 AS ( WHERE l_shipdate < TO_DATE('1996-04-01', 'YYYY-MM-DD') AND l_shipdate >= TO_DATE('1996-01-01', 'YYYY-MM-DD') -), _T1 AS ( +), "_T1" AS ( SELECT SUM(L_EXTENDEDPRICE * ( 1 - L_DISCOUNT )) AS SUM_EXPR - FROM _T3 + FROM "_T3" GROUP BY L_SUPPKEY -), _S0 AS ( +), "_S0" AS ( SELECT MAX(NVL(SUM_EXPR, 0)) AS MAX_TOTAL_REVENUE - FROM _T1 -), _S3 AS ( + FROM "_T1" +), "_S3" AS ( SELECT L_SUPPKEY, SUM(L_EXTENDEDPRICE * ( 1 - L_DISCOUNT )) AS SUM_EXPR - FROM _T3 + FROM "_T3" GROUP BY L_SUPPKEY ) @@ -35,11 +35,11 @@ SELECT SUPPLIER.s_name AS S_NAME, SUPPLIER.s_address AS S_ADDRESS, SUPPLIER.s_phone AS S_PHONE, - NVL(_S3.SUM_EXPR, 0) AS TOTAL_REVENUE -FROM _S0 _S0 + NVL("_S3".SUM_EXPR, 0) AS TOTAL_REVENUE +FROM "_S0" "_S0" CROSS JOIN TPCH.SUPPLIER SUPPLIER -JOIN _S3 _S3 - ON SUPPLIER.s_suppkey = _S3.L_SUPPKEY - AND _S0.MAX_TOTAL_REVENUE = NVL(_S3.SUM_EXPR, 0) +JOIN "_S3" "_S3" + ON SUPPLIER.s_suppkey = "_S3".L_SUPPKEY + AND "_S0".MAX_TOTAL_REVENUE = NVL("_S3".SUM_EXPR, 0) ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q17_oracle.sql b/tests/test_sql_refsols/tpch_q17_oracle.sql index 553a5444e..94bf3569e 100644 --- a/tests/test_sql_refsols/tpch_q17_oracle.sql +++ b/tests/test_sql_refsols/tpch_q17_oracle.sql @@ -1,8 +1,8 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT LINEITEM.l_extendedprice AS L_EXTENDEDPRICE, LINEITEM.l_quantity AS L_QUANTITY, - AVG(CAST(LINEITEM.l_quantity AS DOUBLE PRECISION)) OVER (PARTITION BY LINEITEM.l_partkey) AS _W + AVG(CAST(LINEITEM.l_quantity AS DOUBLE PRECISION)) OVER (PARTITION BY LINEITEM.l_partkey) AS "_W" FROM TPCH.PART PART JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_partkey = PART.p_partkey @@ -11,8 +11,8 @@ WITH _T AS ( ) SELECT NVL(SUM(L_EXTENDEDPRICE), 0) / 7.0 AS AVG_YEARLY -FROM _T +FROM "_T" WHERE L_QUANTITY < ( - 0.2 * _W + 0.2 * "_W" ) diff --git a/tests/test_sql_refsols/tpch_q18_oracle.sql b/tests/test_sql_refsols/tpch_q18_oracle.sql index 56cc887f6..cadd65a24 100644 --- a/tests/test_sql_refsols/tpch_q18_oracle.sql +++ b/tests/test_sql_refsols/tpch_q18_oracle.sql @@ -1,4 +1,4 @@ -WITH _T1 AS ( +WITH "_T1" AS ( SELECT l_orderkey AS L_ORDERKEY, SUM(l_quantity) AS SUM_L_QUANTITY @@ -12,14 +12,14 @@ SELECT ORDERS.o_orderkey AS O_ORDERKEY, ORDERS.o_orderdate AS O_ORDERDATE, ORDERS.o_totalprice AS O_TOTALPRICE, - _T1.SUM_L_QUANTITY AS TOTAL_QUANTITY + "_T1".SUM_L_QUANTITY AS TOTAL_QUANTITY FROM TPCH.ORDERS ORDERS JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = ORDERS.o_custkey -JOIN _T1 _T1 - ON NOT _T1.SUM_L_QUANTITY IS NULL - AND ORDERS.o_orderkey = _T1.L_ORDERKEY - AND _T1.SUM_L_QUANTITY > 300 +JOIN "_T1" "_T1" + ON NOT "_T1".SUM_L_QUANTITY IS NULL + AND ORDERS.o_orderkey = "_T1".L_ORDERKEY + AND "_T1".SUM_L_QUANTITY > 300 ORDER BY 5 DESC NULLS LAST, 4 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q20_oracle.sql b/tests/test_sql_refsols/tpch_q20_oracle.sql index b331574c2..7bf6bfc3f 100644 --- a/tests/test_sql_refsols/tpch_q20_oracle.sql +++ b/tests/test_sql_refsols/tpch_q20_oracle.sql @@ -1,4 +1,4 @@ -WITH _S5 AS ( +WITH "_S5" AS ( SELECT LINEITEM.l_partkey AS L_PARTKEY, SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY @@ -19,11 +19,11 @@ JOIN TPCH.NATION NATION ON NATION.n_name = 'CANADA' AND NATION.n_nationkey = SUPPLIER.s_nationkey JOIN TPCH.PARTSUPP PARTSUPP ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey -JOIN _S5 _S5 +JOIN "_S5" "_S5" ON PARTSUPP.ps_availqty > ( - 0.5 * NVL(_S5.SUM_L_QUANTITY, 0) + 0.5 * NVL("_S5".SUM_L_QUANTITY, 0) ) - AND PARTSUPP.ps_partkey = _S5.L_PARTKEY + AND PARTSUPP.ps_partkey = "_S5".L_PARTKEY GROUP BY PARTSUPP.ps_suppkey ORDER BY diff --git a/tests/test_sql_refsols/tpch_q21_oracle.sql b/tests/test_sql_refsols/tpch_q21_oracle.sql index 691c66c38..5898784de 100644 --- a/tests/test_sql_refsols/tpch_q21_oracle.sql +++ b/tests/test_sql_refsols/tpch_q21_oracle.sql @@ -1,4 +1,4 @@ -WITH _T5 AS ( +WITH "_T5" AS ( SELECT l_commitdate AS L_COMMITDATE, l_linenumber AS L_LINENUMBER, @@ -8,45 +8,45 @@ WITH _T5 AS ( FROM TPCH.LINEITEM WHERE l_commitdate < l_receiptdate -), _T3 AS ( +), "_T3" AS ( SELECT - _T5.L_LINENUMBER, - _T5.L_ORDERKEY, + "_T5".L_LINENUMBER, + "_T5".L_ORDERKEY, ORDERS.o_orderkey AS O_ORDERKEY, - ANY_VALUE(_T5.L_SUPPKEY) AS ANYTHING_L_SUPPKEY, + ANY_VALUE("_T5".L_SUPPKEY) AS ANYTHING_L_SUPPKEY, ANY_VALUE(ORDERS.o_orderstatus) AS ANYTHING_O_ORDERSTATUS - FROM _T5 _T5 + FROM "_T5" "_T5" JOIN TPCH.ORDERS ORDERS - ON ORDERS.o_orderkey = _T5.L_ORDERKEY + ON ORDERS.o_orderkey = "_T5".L_ORDERKEY JOIN TPCH.LINEITEM LINEITEM - ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_suppkey <> _T5.L_SUPPKEY + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_suppkey <> "_T5".L_SUPPKEY GROUP BY - _T5.L_LINENUMBER, - _T5.L_ORDERKEY, + "_T5".L_LINENUMBER, + "_T5".L_ORDERKEY, ORDERS.o_orderkey -), _S11 AS ( +), "_S11" AS ( SELECT - _T3.ANYTHING_L_SUPPKEY - FROM _T3 _T3 - JOIN _T5 _T6 - ON _T3.L_LINENUMBER = _T6.L_LINENUMBER - AND _T3.L_ORDERKEY = _T6.L_ORDERKEY - AND _T3.O_ORDERKEY = _T6.L_ORDERKEY + "_T3".ANYTHING_L_SUPPKEY + FROM "_T3" "_T3" + JOIN "_T5" "_T6" + ON "_T3".L_LINENUMBER = "_T6".L_LINENUMBER + AND "_T3".L_ORDERKEY = "_T6".L_ORDERKEY + AND "_T3".O_ORDERKEY = "_T6".L_ORDERKEY JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate - AND LINEITEM.l_orderkey = _T6.L_ORDERKEY - AND LINEITEM.l_suppkey <> _T6.L_SUPPKEY + AND LINEITEM.l_orderkey = "_T6".L_ORDERKEY + AND LINEITEM.l_suppkey <> "_T6".L_SUPPKEY WHERE - _T3.ANYTHING_O_ORDERSTATUS = 'F' + "_T3".ANYTHING_O_ORDERSTATUS = 'F' ) SELECT ANY_VALUE(SUPPLIER.s_name) AS S_NAME, - NVL(NULLIF(COUNT(_S11.ANYTHING_L_SUPPKEY), 0), 0) AS NUMWAIT + NVL(NULLIF(COUNT("_S11".ANYTHING_L_SUPPKEY), 0), 0) AS NUMWAIT FROM TPCH.SUPPLIER SUPPLIER JOIN TPCH.NATION NATION ON NATION.n_name = 'SAUDI ARABIA' AND NATION.n_nationkey = SUPPLIER.s_nationkey -LEFT JOIN _S11 _S11 - ON SUPPLIER.s_suppkey = _S11.ANYTHING_L_SUPPKEY +LEFT JOIN "_S11" "_S11" + ON SUPPLIER.s_suppkey = "_S11".ANYTHING_L_SUPPKEY GROUP BY SUPPLIER.s_suppkey ORDER BY diff --git a/tests/test_sql_refsols/tpch_q22_oracle.sql b/tests/test_sql_refsols/tpch_q22_oracle.sql index 46aabefd2..9e7c79010 100644 --- a/tests/test_sql_refsols/tpch_q22_oracle.sql +++ b/tests/test_sql_refsols/tpch_q22_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT AVG(c_acctbal) AS AVG_C_ACCTBAL FROM TPCH.CUSTOMER @@ -10,9 +10,9 @@ SELECT SUBSTR(CUSTOMER.c_phone, 1, 2) AS CNTRY_CODE, COUNT(*) AS NUM_CUSTS, NVL(SUM(CUSTOMER.c_acctbal), 0) AS TOTACCTBAL -FROM _S0 _S0 +FROM "_S0" "_S0" JOIN TPCH.CUSTOMER CUSTOMER - ON CUSTOMER.c_acctbal > _S0.AVG_C_ACCTBAL + ON CUSTOMER.c_acctbal > "_S0".AVG_C_ACCTBAL AND SUBSTR(CUSTOMER.c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey diff --git a/tests/test_sql_refsols/tpch_q2_oracle.sql b/tests/test_sql_refsols/tpch_q2_oracle.sql index cc7b59fcd..41d3c710e 100644 --- a/tests/test_sql_refsols/tpch_q2_oracle.sql +++ b/tests/test_sql_refsols/tpch_q2_oracle.sql @@ -1,4 +1,4 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT NATION.n_name AS N_NAME, PART.p_mfgr AS P_MFGR, @@ -8,7 +8,7 @@ WITH _T AS ( SUPPLIER.s_comment AS S_COMMENT, SUPPLIER.s_name AS S_NAME, SUPPLIER.s_phone AS S_PHONE, - RANK() OVER (PARTITION BY PARTSUPP.ps_partkey ORDER BY PARTSUPP.ps_supplycost) AS _W + RANK() OVER (PARTITION BY PARTSUPP.ps_partkey ORDER BY PARTSUPP.ps_supplycost) AS "_W" FROM TPCH.PART PART JOIN TPCH.PARTSUPP PARTSUPP ON PART.p_partkey = PARTSUPP.ps_partkey @@ -30,9 +30,9 @@ SELECT S_ADDRESS, S_PHONE, S_COMMENT -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY 1 DESC NULLS LAST, 3 NULLS FIRST, diff --git a/tests/test_sql_refsols/tpch_q5_oracle.sql b/tests/test_sql_refsols/tpch_q5_oracle.sql index 0054cdbc7..a826fc523 100644 --- a/tests/test_sql_refsols/tpch_q5_oracle.sql +++ b/tests/test_sql_refsols/tpch_q5_oracle.sql @@ -1,4 +1,4 @@ -WITH _S11 AS ( +WITH "_S11" AS ( SELECT NATION.n_name AS N_NAME, SUPPLIER.s_suppkey AS S_SUPPKEY @@ -22,8 +22,8 @@ JOIN TPCH.ORDERS ORDERS AND ORDERS.o_orderdate >= TO_DATE('1994-01-01', 'YYYY-MM-DD') JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_orderkey = ORDERS.o_orderkey -JOIN _S11 _S11 - ON LINEITEM.l_suppkey = _S11.S_SUPPKEY AND NATION.n_name = _S11.N_NAME +JOIN "_S11" "_S11" + ON LINEITEM.l_suppkey = "_S11".S_SUPPKEY AND NATION.n_name = "_S11".N_NAME GROUP BY NATION.n_nationkey ORDER BY diff --git a/tests/test_sql_refsols/tpch_q7_oracle.sql b/tests/test_sql_refsols/tpch_q7_oracle.sql index 765fcc3ea..fd0229c77 100644 --- a/tests/test_sql_refsols/tpch_q7_oracle.sql +++ b/tests/test_sql_refsols/tpch_q7_oracle.sql @@ -1,4 +1,4 @@ -WITH _S9 AS ( +WITH "_S9" AS ( SELECT NATION.n_name AS N_NAME, ORDERS.o_orderkey AS O_ORDERKEY @@ -13,7 +13,7 @@ WITH _S9 AS ( ) SELECT NATION.n_name AS SUPP_NATION, - _S9.N_NAME AS CUST_NATION, + "_S9".N_NAME AS CUST_NATION, EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) AS L_YEAR, NVL(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount @@ -23,22 +23,22 @@ JOIN TPCH.SUPPLIER SUPPLIER ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey JOIN TPCH.NATION NATION ON NATION.n_nationkey = SUPPLIER.s_nationkey -JOIN _S9 _S9 - ON LINEITEM.l_orderkey = _S9.O_ORDERKEY +JOIN "_S9" "_S9" + ON LINEITEM.l_orderkey = "_S9".O_ORDERKEY AND ( NATION.n_name = 'FRANCE' OR NATION.n_name = 'GERMANY' ) AND ( - NATION.n_name = 'FRANCE' OR _S9.N_NAME = 'FRANCE' + NATION.n_name = 'FRANCE' OR "_S9".N_NAME = 'FRANCE' ) AND ( - NATION.n_name = 'GERMANY' OR _S9.N_NAME = 'GERMANY' + NATION.n_name = 'GERMANY' OR "_S9".N_NAME = 'GERMANY' ) WHERE EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) GROUP BY EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)), - _S9.N_NAME, + "_S9".N_NAME, NATION.n_name ORDER BY 1 NULLS FIRST, diff --git a/tests/test_sql_refsols/triple_partition_oracle.sql b/tests/test_sql_refsols/triple_partition_oracle.sql index e6f47e422..4dbe4b784 100644 --- a/tests/test_sql_refsols/triple_partition_oracle.sql +++ b/tests/test_sql_refsols/triple_partition_oracle.sql @@ -1,18 +1,18 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT n_nationkey AS N_NATIONKEY, n_regionkey AS N_REGIONKEY FROM TPCH.NATION -), _S5 AS ( +), "_S5" AS ( SELECT r_name AS R_NAME, r_regionkey AS R_REGIONKEY FROM TPCH.REGION -), _S14 AS ( +), "_S14" AS ( SELECT ORDERS.o_custkey AS O_CUSTKEY, PART.p_type AS P_TYPE, - _S5.R_NAME, + "_S5".R_NAME, COUNT(*) AS N_ROWS FROM TPCH.PART PART JOIN TPCH.LINEITEM LINEITEM @@ -21,10 +21,10 @@ WITH _S3 AS ( AND LINEITEM.l_partkey = PART.p_partkey JOIN TPCH.SUPPLIER SUPPLIER ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey - JOIN _S3 _S3 - ON SUPPLIER.s_nationkey = _S3.N_NATIONKEY - JOIN _S5 _S5 - ON _S3.N_REGIONKEY = _S5.R_REGIONKEY + JOIN "_S3" "_S3" + ON SUPPLIER.s_nationkey = "_S3".N_NATIONKEY + JOIN "_S5" "_S5" + ON "_S3".N_REGIONKEY = "_S5".R_REGIONKEY JOIN TPCH.ORDERS ORDERS ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 AND LINEITEM.l_orderkey = ORDERS.o_orderkey @@ -33,29 +33,29 @@ WITH _S3 AS ( GROUP BY ORDERS.o_custkey, PART.p_type, - _S5.R_NAME -), _T2 AS ( + "_S5".R_NAME +), "_T2" AS ( SELECT - _S13.R_NAME AS CUST_REGION, - _S14.R_NAME, - SUM(_S14.N_ROWS) AS SUM_N_ROWS - FROM _S14 _S14 + "_S13".R_NAME AS CUST_REGION, + "_S14".R_NAME, + SUM("_S14".N_ROWS) AS SUM_N_ROWS + FROM "_S14" "_S14" JOIN TPCH.CUSTOMER CUSTOMER - ON CUSTOMER.c_custkey = _S14.O_CUSTKEY - JOIN _S3 _S11 - ON CUSTOMER.c_nationkey = _S11.N_NATIONKEY - JOIN _S5 _S13 - ON _S11.N_REGIONKEY = _S13.R_REGIONKEY + ON CUSTOMER.c_custkey = "_S14".O_CUSTKEY + JOIN "_S3" "_S11" + ON CUSTOMER.c_nationkey = "_S11".N_NATIONKEY + JOIN "_S5" "_S13" + ON "_S11".N_REGIONKEY = "_S13".R_REGIONKEY GROUP BY - _S13.R_NAME, - _S14.P_TYPE, - _S14.R_NAME -), _T1 AS ( + "_S13".R_NAME, + "_S14".P_TYPE, + "_S14".R_NAME +), "_T1" AS ( SELECT R_NAME, MAX(SUM_N_ROWS) AS MAX_SUM_N_ROWS, SUM(SUM_N_ROWS) AS SUM_SUM_N_ROWS - FROM _T2 + FROM "_T2" GROUP BY CUST_REGION, R_NAME @@ -65,7 +65,7 @@ SELECT AVG(( 100.0 * MAX_SUM_N_ROWS ) / SUM_SUM_N_ROWS) AS avgpct -FROM _T1 +FROM "_T1" GROUP BY R_NAME ORDER BY diff --git a/tests/test_sql_refsols/user_range_collection_1_oracle.sql b/tests/test_sql_refsols/user_range_collection_1_oracle.sql index d59e1e4ab..e60277da3 100644 --- a/tests/test_sql_refsols/user_range_collection_1_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_1_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT p_size AS P_SIZE, COUNT(*) AS N_ROWS @@ -10,7 +10,7 @@ WITH _S1 AS ( ) SELECT COLUMN1 AS part_size, - NVL(_S1.N_ROWS, 0) AS n_parts + NVL("_S1".N_ROWS, 0) AS n_parts FROM (VALUES (1), (6), @@ -32,5 +32,5 @@ FROM (VALUES (86), (91), (96)) AS SIZES(PART_SIZE) -LEFT JOIN _S1 _S1 - ON COLUMN1 = _S1.P_SIZE +LEFT JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".P_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_2_oracle.sql b/tests/test_sql_refsols/user_range_collection_2_oracle.sql index 6a404df08..c89c71056 100644 --- a/tests/test_sql_refsols/user_range_collection_2_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT COLUMN1 AS X FROM (VALUES @@ -12,7 +12,7 @@ WITH _S0 AS ( (7), (8), (9)) AS A(X) -), _S1 AS ( +), "_S1" AS ( SELECT COLUMN1 AS Y FROM (VALUES @@ -517,31 +517,31 @@ WITH _S0 AS ( (996), (998), (1000)) AS B(Y) -), _S4 AS ( +), "_S4" AS ( SELECT - _S0.X, + "_S0".X, COUNT(*) AS N_ROWS - FROM _S0 _S0 - JOIN _S1 _S1 - ON CAST(_S1.Y AS CLOB) LIKE CONCAT(CAST(_S0.X AS CLOB), '%') + FROM "_S0" "_S0" + JOIN "_S1" "_S1" + ON CAST("_S1".Y AS CLOB) LIKE CONCAT(CAST("_S0".X AS CLOB), '%') GROUP BY - _S0.X -), _S5 AS ( + "_S0".X +), "_S5" AS ( SELECT - _S2.X, + "_S2".X, COUNT(*) AS N_ROWS - FROM _S0 _S2 - JOIN _S1 _S3 - ON CAST(_S3.Y AS CLOB) LIKE CONCAT('%', CAST(_S2.X AS CLOB)) + FROM "_S0" "_S2" + JOIN "_S1" "_S3" + ON CAST("_S3".Y AS CLOB) LIKE CONCAT('%', CAST("_S2".X AS CLOB)) GROUP BY - _S2.X + "_S2".X ) SELECT - _S4.X AS x, - _S4.N_ROWS AS n_prefix, - _S5.N_ROWS AS n_suffix -FROM _S4 _S4 -JOIN _S5 _S5 - ON _S4.X = _S5.X + "_S4".X AS x, + "_S4".N_ROWS AS n_prefix, + "_S5".N_ROWS AS n_suffix +FROM "_S4" "_S4" +JOIN "_S5" "_S5" + ON "_S4".X = "_S5".X ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_3_oracle.sql b/tests/test_sql_refsols/user_range_collection_3_oracle.sql index 6a404df08..c89c71056 100644 --- a/tests/test_sql_refsols/user_range_collection_3_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -1,4 +1,4 @@ -WITH _S0 AS ( +WITH "_S0" AS ( SELECT COLUMN1 AS X FROM (VALUES @@ -12,7 +12,7 @@ WITH _S0 AS ( (7), (8), (9)) AS A(X) -), _S1 AS ( +), "_S1" AS ( SELECT COLUMN1 AS Y FROM (VALUES @@ -517,31 +517,31 @@ WITH _S0 AS ( (996), (998), (1000)) AS B(Y) -), _S4 AS ( +), "_S4" AS ( SELECT - _S0.X, + "_S0".X, COUNT(*) AS N_ROWS - FROM _S0 _S0 - JOIN _S1 _S1 - ON CAST(_S1.Y AS CLOB) LIKE CONCAT(CAST(_S0.X AS CLOB), '%') + FROM "_S0" "_S0" + JOIN "_S1" "_S1" + ON CAST("_S1".Y AS CLOB) LIKE CONCAT(CAST("_S0".X AS CLOB), '%') GROUP BY - _S0.X -), _S5 AS ( + "_S0".X +), "_S5" AS ( SELECT - _S2.X, + "_S2".X, COUNT(*) AS N_ROWS - FROM _S0 _S2 - JOIN _S1 _S3 - ON CAST(_S3.Y AS CLOB) LIKE CONCAT('%', CAST(_S2.X AS CLOB)) + FROM "_S0" "_S2" + JOIN "_S1" "_S3" + ON CAST("_S3".Y AS CLOB) LIKE CONCAT('%', CAST("_S2".X AS CLOB)) GROUP BY - _S2.X + "_S2".X ) SELECT - _S4.X AS x, - _S4.N_ROWS AS n_prefix, - _S5.N_ROWS AS n_suffix -FROM _S4 _S4 -JOIN _S5 _S5 - ON _S4.X = _S5.X + "_S4".X AS x, + "_S4".N_ROWS AS n_prefix, + "_S5".N_ROWS AS n_suffix +FROM "_S4" "_S4" +JOIN "_S5" "_S5" + ON "_S4".X = "_S5".X ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_4_oracle.sql b/tests/test_sql_refsols/user_range_collection_4_oracle.sql index 917651b58..d8d33a848 100644 --- a/tests/test_sql_refsols/user_range_collection_4_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_4_oracle.sql @@ -1,9 +1,9 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT PART.p_name AS P_NAME, PART.p_retailprice AS P_RETAILPRICE, COLUMN1 AS PART_SIZE, - ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY PART.p_retailprice) AS _W + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY PART.p_retailprice) AS "_W" FROM (VALUES (1), (2), @@ -25,8 +25,8 @@ SELECT PART_SIZE AS part_size, P_NAME AS name, P_RETAILPRICE AS retail_price -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_5_oracle.sql b/tests/test_sql_refsols/user_range_collection_5_oracle.sql index c00aa9e8a..c2f088997 100644 --- a/tests/test_sql_refsols/user_range_collection_5_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -1,4 +1,4 @@ -WITH _S2 AS ( +WITH "_S2" AS ( SELECT COLUMN1 AS PART_SIZE FROM (VALUES @@ -14,23 +14,23 @@ WITH _S2 AS ( (46), (51), (56)) AS SIZES(PART_SIZE) -), _S3 AS ( +), "_S3" AS ( SELECT - _S0.PART_SIZE, + "_S0".PART_SIZE, COUNT(*) AS N_ROWS - FROM _S2 _S0 + FROM "_S2" "_S0" JOIN TPCH.PART PART ON PART.p_name LIKE '%almond%' AND PART.p_size <= ( - _S0.PART_SIZE + 4 + "_S0".PART_SIZE + 4 ) - AND PART.p_size >= _S0.PART_SIZE + AND PART.p_size >= "_S0".PART_SIZE GROUP BY - _S0.PART_SIZE + "_S0".PART_SIZE ) SELECT - _S2.PART_SIZE AS part_size, - NVL(_S3.N_ROWS, 0) AS n_parts -FROM _S2 _S2 -LEFT JOIN _S3 _S3 - ON _S2.PART_SIZE = _S3.PART_SIZE + "_S2".PART_SIZE AS part_size, + NVL("_S3".N_ROWS, 0) AS n_parts +FROM "_S2" "_S2" +LEFT JOIN "_S3" "_S3" + ON "_S2".PART_SIZE = "_S3".PART_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_6_oracle.sql b/tests/test_sql_refsols/user_range_collection_6_oracle.sql index 3970ed5f9..71abb2b31 100644 --- a/tests/test_sql_refsols/user_range_collection_6_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_6_oracle.sql @@ -1,4 +1,4 @@ -WITH _S5 AS ( +WITH "_S5" AS ( SELECT EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, COUNT(DISTINCT ORDERS.o_custkey) AS NDISTINCT_O_CUSTKEY @@ -14,7 +14,7 @@ WITH _S5 AS ( ) SELECT COLUMN1 AS year, - NVL(_S5.NDISTINCT_O_CUSTKEY, 0) AS n_orders + NVL("_S5".NDISTINCT_O_CUSTKEY, 0) AS n_orders FROM (VALUES (1990), (1991), @@ -27,7 +27,7 @@ FROM (VALUES (1998), (1999), (2000)) AS YEARS(YEAR) -LEFT JOIN _S5 _S5 - ON COLUMN1 = _S5.YEAR_O_ORDERDATE +LEFT JOIN "_S5" "_S5" + ON COLUMN1 = "_S5".YEAR_O_ORDERDATE ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/wealthiest_supplier_oracle.sql b/tests/test_sql_refsols/wealthiest_supplier_oracle.sql index 90f4b244b..e134a6c91 100644 --- a/tests/test_sql_refsols/wealthiest_supplier_oracle.sql +++ b/tests/test_sql_refsols/wealthiest_supplier_oracle.sql @@ -1,13 +1,13 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT s_acctbal AS S_ACCTBAL, s_name AS S_NAME, - ROW_NUMBER() OVER (ORDER BY s_acctbal DESC, s_name) AS _W + ROW_NUMBER() OVER (ORDER BY s_acctbal DESC, s_name) AS "_W" FROM TPCH.SUPPLIER ) SELECT S_NAME AS name, S_ACCTBAL AS account_balance -FROM _T +FROM "_T" WHERE - _W = 1 + "_W" = 1 diff --git a/tests/test_sql_refsols/window_filter_order_10_oracle.sql b/tests/test_sql_refsols/window_filter_order_10_oracle.sql index 8396bf098..647afeae1 100644 --- a/tests/test_sql_refsols/window_filter_order_10_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_10_oracle.sql @@ -1,7 +1,7 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT ORDERS.o_totalprice AS O_TOTALPRICE, - AVG(CAST(NULL AS INT)) OVER () AS _W + AVG(CAST(NULL AS INT)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' @@ -10,8 +10,8 @@ WITH _T AS ( ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE O_TOTALPRICE < ( - 0.05 * _W + 0.05 * "_W" ) diff --git a/tests/test_sql_refsols/window_filter_order_1_oracle.sql b/tests/test_sql_refsols/window_filter_order_1_oracle.sql index ea21ffd40..e6e3eccd5 100644 --- a/tests/test_sql_refsols/window_filter_order_1_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_1_oracle.sql @@ -1,27 +1,27 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 -), _T2 AS ( +), "_T2" AS ( SELECT - COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' - LEFT JOIN _S3 _S3 - ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + LEFT JOIN "_S3" "_S3" + ON CUSTOMER.c_custkey = "_S3".O_CUSTKEY GROUP BY CUSTOMER.c_custkey -), _T AS ( +), "_T" AS ( SELECT COUNT_O_CUSTKEY, - AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W - FROM _T2 + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS "_W" + FROM "_T2" ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_2_oracle.sql b/tests/test_sql_refsols/window_filter_order_2_oracle.sql index ea21ffd40..e6e3eccd5 100644 --- a/tests/test_sql_refsols/window_filter_order_2_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_2_oracle.sql @@ -1,27 +1,27 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 -), _T2 AS ( +), "_T2" AS ( SELECT - COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' - LEFT JOIN _S3 _S3 - ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + LEFT JOIN "_S3" "_S3" + ON CUSTOMER.c_custkey = "_S3".O_CUSTKEY GROUP BY CUSTOMER.c_custkey -), _T AS ( +), "_T" AS ( SELECT COUNT_O_CUSTKEY, - AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W - FROM _T2 + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS "_W" + FROM "_T2" ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_3_oracle.sql b/tests/test_sql_refsols/window_filter_order_3_oracle.sql index ea21ffd40..e6e3eccd5 100644 --- a/tests/test_sql_refsols/window_filter_order_3_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_3_oracle.sql @@ -1,27 +1,27 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 -), _T2 AS ( +), "_T2" AS ( SELECT - COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' - LEFT JOIN _S3 _S3 - ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + LEFT JOIN "_S3" "_S3" + ON CUSTOMER.c_custkey = "_S3".O_CUSTKEY GROUP BY CUSTOMER.c_custkey -), _T AS ( +), "_T" AS ( SELECT COUNT_O_CUSTKEY, - AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W - FROM _T2 + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS "_W" + FROM "_T2" ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_4_oracle.sql b/tests/test_sql_refsols/window_filter_order_4_oracle.sql index ad1bb5f16..8a0aa7bdf 100644 --- a/tests/test_sql_refsols/window_filter_order_4_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_4_oracle.sql @@ -1,4 +1,4 @@ -WITH _T2 AS ( +WITH "_T2" AS ( SELECT COUNT(*) AS N_ROWS FROM TPCH.CUSTOMER CUSTOMER @@ -9,14 +9,14 @@ WITH _T2 AS ( AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 GROUP BY ORDERS.o_custkey -), _T AS ( +), "_T" AS ( SELECT N_ROWS, - AVG(CAST(N_ROWS AS DOUBLE PRECISION)) OVER () AS _W - FROM _T2 + AVG(CAST(N_ROWS AS DOUBLE PRECISION)) OVER () AS "_W" + FROM "_T2" ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - N_ROWS < _W + N_ROWS < "_W" diff --git a/tests/test_sql_refsols/window_filter_order_5_oracle.sql b/tests/test_sql_refsols/window_filter_order_5_oracle.sql index ce69c4193..3176c19dd 100644 --- a/tests/test_sql_refsols/window_filter_order_5_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_5_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT 1 AS EXPR_0, c_acctbal AS C_ACCTBAL, @@ -6,19 +6,19 @@ WITH _S1 AS ( FROM TPCH.CUSTOMER WHERE c_mktsegment = 'BUILDING' -), _T AS ( +), "_T" AS ( SELECT - _S1.C_ACCTBAL, - _S1.EXPR_0, - AVG(CAST(NVL(_S1.C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS _W + "_S1".C_ACCTBAL, + "_S1".EXPR_0, + AVG(CAST(NVL("_S1".C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS - LEFT JOIN _S1 _S1 - ON ORDERS.o_custkey = _S1.C_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON ORDERS.o_custkey = "_S1".C_CUSTKEY WHERE EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - NOT EXPR_0 IS NULL AND C_ACCTBAL < _W + NOT EXPR_0 IS NULL AND C_ACCTBAL < "_W" diff --git a/tests/test_sql_refsols/window_filter_order_6_oracle.sql b/tests/test_sql_refsols/window_filter_order_6_oracle.sql index ce69c4193..3176c19dd 100644 --- a/tests/test_sql_refsols/window_filter_order_6_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_6_oracle.sql @@ -1,4 +1,4 @@ -WITH _S1 AS ( +WITH "_S1" AS ( SELECT 1 AS EXPR_0, c_acctbal AS C_ACCTBAL, @@ -6,19 +6,19 @@ WITH _S1 AS ( FROM TPCH.CUSTOMER WHERE c_mktsegment = 'BUILDING' -), _T AS ( +), "_T" AS ( SELECT - _S1.C_ACCTBAL, - _S1.EXPR_0, - AVG(CAST(NVL(_S1.C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS _W + "_S1".C_ACCTBAL, + "_S1".EXPR_0, + AVG(CAST(NVL("_S1".C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS - LEFT JOIN _S1 _S1 - ON ORDERS.o_custkey = _S1.C_CUSTKEY + LEFT JOIN "_S1" "_S1" + ON ORDERS.o_custkey = "_S1".C_CUSTKEY WHERE EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - NOT EXPR_0 IS NULL AND C_ACCTBAL < _W + NOT EXPR_0 IS NULL AND C_ACCTBAL < "_W" diff --git a/tests/test_sql_refsols/window_filter_order_7_oracle.sql b/tests/test_sql_refsols/window_filter_order_7_oracle.sql index 2029ce75a..05ffe9a6d 100644 --- a/tests/test_sql_refsols/window_filter_order_7_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_7_oracle.sql @@ -1,7 +1,7 @@ -WITH _T AS ( +WITH "_T" AS ( SELECT CUSTOMER.c_acctbal AS C_ACCTBAL, - AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER () AS _W + AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' @@ -10,6 +10,6 @@ WITH _T AS ( ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - C_ACCTBAL < _W + C_ACCTBAL < "_W" diff --git a/tests/test_sql_refsols/window_filter_order_8_oracle.sql b/tests/test_sql_refsols/window_filter_order_8_oracle.sql index ef696f888..599f6fa7d 100644 --- a/tests/test_sql_refsols/window_filter_order_8_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_8_oracle.sql @@ -1,30 +1,30 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 AND EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 -), _T2 AS ( +), "_T2" AS ( SELECT ANY_VALUE(CUSTOMER.c_acctbal) AS ANYTHING_C_ACCTBAL, - COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'FRANCE' - LEFT JOIN _S3 _S3 - ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + LEFT JOIN "_S3" "_S3" + ON CUSTOMER.c_custkey = "_S3".O_CUSTKEY GROUP BY CUSTOMER.c_custkey -), _T AS ( +), "_T" AS ( SELECT ANYTHING_C_ACCTBAL, COUNT_O_CUSTKEY, - SUM(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0)) OVER () AS _W - FROM _T2 + SUM(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0)) OVER () AS "_W" + FROM "_T2" ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) IS NULL AND ANYTHING_C_ACCTBAL < _W + NULLIF(COUNT_O_CUSTKEY, 0) IS NULL AND ANYTHING_C_ACCTBAL < "_W" diff --git a/tests/test_sql_refsols/window_filter_order_9_oracle.sql b/tests/test_sql_refsols/window_filter_order_9_oracle.sql index 2113cdbbd..17ab358bc 100644 --- a/tests/test_sql_refsols/window_filter_order_9_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_9_oracle.sql @@ -1,4 +1,4 @@ -WITH _S3 AS ( +WITH "_S3" AS ( SELECT 1 AS EXPR_0, NVL(SUM(ORDERS.o_totalprice), 0) AS TOTAL_SPENT, @@ -10,21 +10,21 @@ WITH _S3 AS ( CUSTOMER.c_mktsegment = 'BUILDING' GROUP BY CUSTOMER.c_custkey -), _T AS ( +), "_T" AS ( SELECT - _S3.EXPR_0, + "_S3".EXPR_0, ORDERS.o_totalprice AS O_TOTALPRICE, - AVG(CAST(_S3.TOTAL_SPENT AS DOUBLE PRECISION)) OVER () AS _W + AVG(CAST("_S3".TOTAL_SPENT AS DOUBLE PRECISION)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS - LEFT JOIN _S3 _S3 - ON ORDERS.o_custkey = _S3.C_CUSTKEY + LEFT JOIN "_S3" "_S3" + ON ORDERS.o_custkey = "_S3".C_CUSTKEY WHERE ORDERS.o_clerk = 'Clerk#000000001' ) SELECT COUNT(*) AS n -FROM _T +FROM "_T" WHERE EXPR_0 IS NULL AND O_TOTALPRICE < ( - 0.05 * _W + 0.05 * "_W" ) diff --git a/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql index 4e0924cbc..a8cbe61c9 100644 --- a/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql +++ b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql @@ -1,4 +1,4 @@ -WITH _T0 AS ( +WITH "_T0" AS ( SELECT EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, COUNT(*) AS N_ROWS @@ -12,6 +12,6 @@ SELECT ( 100.0 * CAST(N_ROWS - LAG(N_ROWS, 1) OVER (ORDER BY YEAR_O_ORDERDATE) AS DOUBLE PRECISION) ) / LAG(N_ROWS, 1) OVER (ORDER BY YEAR_O_ORDERDATE) AS pct_change -FROM _T0 +FROM "_T0" ORDER BY 1 NULLS FIRST From ce5227ec740804b6f46b97c8884daa7a5d1613e1 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 13 Feb 2026 13:01:40 -0600 Subject: [PATCH 11/48] coalesce fixed and metadata fixed --- .../oracle_transform_bindings.py | 46 ++++++++++++++----- .../oracle_custom_datasets_graphs.json | 6 +-- tests/test_metadata/oracle_defog_graphs.json | 2 +- 3 files changed, 39 insertions(+), 15 deletions(-) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index 95174cc8c..2a6c70682 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -21,7 +21,6 @@ class OracleTransformBindings(BaseTransformBindings): PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { pydop.ABS: "ABS", - pydop.DEFAULT_TO: "NVL", pydop.LARGEST: "GREATEST", pydop.SMALLEST: "LEAST", pydop.STRIP: "TRIM", @@ -45,14 +44,39 @@ def convert_call_to_sqlglot( return sqlglot_expressions.Anonymous( this=self.PYDOP_TO_ORACLE_FUNC[operator], expressions=args ) + match operator: + case pydop.DEFAULT_TO: + # sqlglot convert COALESCE in NVL for Oracle, which is fine for + # 2 args but with more sqlglot doesn't handle it correctly. + return self.convert_default_to(args, types) + return super().convert_call_to_sqlglot(operator, args, types) + def convert_default_to( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + """ + Convert a DEFAULT_TO PyDough function in COALESCE handling correctly + more than 2 arguments. + + Sqlglot converts COALESCE in NVL for Oracle. For 2+ args this becomes a + nested NVL call. + + Args: + `args`: The arguments for the COALESE expression. + `types`: The PyDough types of the arguments. + + Returns: + COALESCE expression with its arguments correctly handled + """ + return sqlglot_expressions.Coalesce(this=args[0], expressions=args[1:]) + def convert_slice( self, args: list[SQLGlotExpression], types: list[PyDoughType] ) -> SQLGlotExpression: """ Convert a PyDough slice operation to a SQLGlot expression. - MySQL uses the SUBSTRING function for slicing. + Oracle uses the SUBSTR function for slicing. Outline of the logic: - If the start index is None, it defaults to 1 (1-based indexing). @@ -61,23 +85,23 @@ def convert_slice( - b = stop index match (a, b): case (None, None): - return SUBSTRING(x, 1) + return SUBSTR(x, 1) case (+a, None): - return SUBSTRING(x, a + 1) + return SUBSTR(x, a + 1) case (-a, None): - return SUBSTRING(x, a) + return SUBSTR(x, a) case (None, +b): - return SUBSTRING(x, 1, b) + return SUBSTR(x, 1, b) case (None, -b): - return SUBSTRING(x, 1, LENGTH(x) + b) + return SUBSTR(x, 1, LENGTH(x) + b) case (+a, +b): - return SUBSTRING(x, a + 1, GREATEST(b - a, 0)) + return SUBSTR(x, a + 1, GREATEST(b - a, 0)) case (-a, -b): - return SUBSTRING(x, a, GREATEST(b - a, 0)) + return SUBSTR(x, a, GREATEST(b - a, 0)) case (+a, -b): - return SUBSTRING(x, a + 1, GREATEST(LENGTH(x) + b - a, 0)) + return SUBSTR(x, a + 1, GREATEST(LENGTH(x) + b - a, 0)) case (-a, +b): - return SUBSTRING(x, a, b - GREATEST(LENGTH(x) + a, 0)) + return SUBSTR(x, a, b - GREATEST(LENGTH(x) + a, 0)) """ assert len(args) == 4 diff --git a/tests/test_metadata/oracle_custom_datasets_graphs.json b/tests/test_metadata/oracle_custom_datasets_graphs.json index a6c721079..af67c08a5 100644 --- a/tests/test_metadata/oracle_custom_datasets_graphs.json +++ b/tests/test_metadata/oracle_custom_datasets_graphs.json @@ -515,7 +515,7 @@ { "name": "def_", "type": "table column", - "column name": "def", + "column name": "\"def\"", "data type": "numeric", "description": "Column name normalized from Python reserved word 'DEF'", "sample values": [ @@ -656,7 +656,7 @@ { "name": "del_", "type": "table column", - "column name": "del", + "column name": "\"del\"", "data type": "numeric", "description": "Column name normalized from 'del'", "sample values": [ @@ -700,7 +700,7 @@ { "name": "str_", "type": "table column", - "column name": "str", + "column name": "\"str\"", "data type": "numeric", "description": "Column name normalized from Python reserved word 'str'", "sample values": [ diff --git a/tests/test_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json index 5ae1d3fed..f93107589 100644 --- a/tests/test_metadata/oracle_defog_graphs.json +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -3888,7 +3888,7 @@ { "name": "year", "type": "table column", - "column name": "year", + "column name": "year_pub", "data type": "numeric", "description": "The year when the publication was published", "sample values": [2021, 2020], From cefdbccc220eaabf7d33d32aef151d3a02a1cadb Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 18 Feb 2026 11:27:38 -0600 Subject: [PATCH 12/48] datediff implementation, dayofweek and daysfromstart --- .../sqlglot_relational_expression_visitor.py | 29 ++- .../oracle_transform_bindings.py | 182 ++++++++++++++++++ tests/test_pipeline_oracle.py | 9 +- 3 files changed, 213 insertions(+), 7 deletions(-) diff --git a/pydough/sqlglot/sqlglot_relational_expression_visitor.py b/pydough/sqlglot/sqlglot_relational_expression_visitor.py index b812a1bd9..ab8b150ef 100644 --- a/pydough/sqlglot/sqlglot_relational_expression_visitor.py +++ b/pydough/sqlglot/sqlglot_relational_expression_visitor.py @@ -347,15 +347,17 @@ def visit_literal_expression(self, literal_expression: LiteralExpression) -> Non # specific dialect is responsible for translating into its own logic. # Rather than have that logic show up in the ANSI sql text, we will # instead create the CAST calls ourselves. + date: datetime.date + dt: datetime.datetime if self._dialect == DatabaseDialect.ANSI: if isinstance(literal_expression.value, datetime.date): - date: datetime.date = literal_expression.value + date = literal_expression.value literal = sqlglot_expressions.Cast( this=sqlglot_expressions.convert(date.strftime("%Y-%m-%d")), to=sqlglot_expressions.DataType.build("DATE"), ) if isinstance(literal_expression.value, datetime.datetime): - dt: datetime.datetime = literal_expression.value + dt = literal_expression.value if dt.tzinfo is not None: raise PyDoughSQLException( "PyDough does not yet support datetime values with a timezone" @@ -364,6 +366,29 @@ def visit_literal_expression(self, literal_expression: LiteralExpression) -> Non this=sqlglot_expressions.convert(dt.isoformat(sep=" ")), to=sqlglot_expressions.DataType.build("TIMESTAMP"), ) + elif self._dialect == DatabaseDialect.ORACLE: + if isinstance(literal_expression.value, datetime.date): + date = literal_expression.value + literal = sqlglot_expressions.Anonymous( + this="TO_DATE", + expressions=[ + sqlglot_expressions.convert(date.strftime("%Y-%m-%d")), + sqlglot_expressions.Literal.string("YYYY-MM-DD"), + ], + ) + if isinstance(literal_expression.value, datetime.datetime): + dt = literal_expression.value + if dt.tzinfo is not None: + raise PyDoughSQLException( + "PyDough does not yet support datetime values with a timezone" + ) + literal = sqlglot_expressions.Anonymous( + this="TO_TIMESTAMP", + expressions=[ + sqlglot_expressions.convert(dt.isoformat(sep=" ")), + sqlglot_expressions.Literal.string("YYYY-MM-DD HH24:MI:SS"), + ], + ) self._stack.append(literal) def visit_correlated_reference( diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index 2a6c70682..ad4204b8c 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -12,6 +12,10 @@ from pydough.types import PyDoughType from .base_transform_bindings import BaseTransformBindings +from .sqlglot_transform_utils import ( + DateTimeUnit, + apply_parens, +) class OracleTransformBindings(BaseTransformBindings): @@ -19,6 +23,18 @@ class OracleTransformBindings(BaseTransformBindings): Subclass of BaseTransformBindings for the Oracle dialect. """ + @property + def dialect_dow_mapping(self) -> dict[str, int]: + return { + "Sunday": 1, + "Monday": 2, + "Tuesday": 3, + "Wednesday": 4, + "Thursday": 5, + "Friday": 6, + "Saturday": 7, + } + PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { pydop.ABS: "ABS", pydop.LARGEST: "GREATEST", @@ -329,3 +345,169 @@ def convert_get_part( ], ) return result + + def convert_datediff( + self, + args: list[SQLGlotExpression], + types: list[PyDoughType], + ) -> SQLGlotExpression: + assert len(args) == 3 + # Check if unit is a string. + if not (isinstance(args[0], sqlglot_expressions.Literal) and args[0].is_string): + raise ValueError( + f"Unsupported argument for DATEDIFF: {args[0]!r}. It should be a string literal." + ) + date1 = self.make_datetime_arg(args[1]) + date2 = self.make_datetime_arg(args[2]) + + unit: DateTimeUnit | None = DateTimeUnit.from_string(args[0].this) + if unit is None: + raise ValueError(f"Unsupported argument '{unit}' for DATEDIFF.") + + year_diff: SQLGlotExpression = sqlglot_expressions.Sub( + this=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="YEAR"), expression=date2 + ), + expression=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="YEAR"), expression=date1 + ), + ) + + match unit: + case DateTimeUnit.YEAR: + # EXTRACT(YEAR FROM date2) - EXTRACT(YEAR FROM date1) + return year_diff + case DateTimeUnit.QUARTER: + # (EXTRACT(YEAR FROM date2) - EXTRACT(YEAR FROM date1)) * 4 + + # (EXTRACT(QUATER FROM date2) - EXTRACT(QUARTER FROM date1)) + quarter_diff: SQLGlotExpression = sqlglot_expressions.Sub( + this=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="QUARTER"), expression=date2 + ), + expression=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="QUARTER"), expression=date1 + ), + ) + + return sqlglot_expressions.Add( + this=sqlglot_expressions.Mul( + this=apply_parens(year_diff), + expression=sqlglot_expressions.Literal.number(4), + ), + expression=apply_parens(quarter_diff), + ) + + case DateTimeUnit.MONTH: + # EXTRACT(YEAR FROM date2) - EXTRACT(YEAR FROM date1)) * 12 + + # (EXTRACT(MONTH FROM date2) - EXTRACT(MONTH FROM date1)) + month_diff: SQLGlotExpression = sqlglot_expressions.Sub( + this=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="MONTH"), expression=date2 + ), + expression=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="MONTH"), expression=date1 + ), + ) + return sqlglot_expressions.Add( + this=sqlglot_expressions.Mul( + this=apply_parens(year_diff), + expression=sqlglot_expressions.Literal.number(12), + ), + expression=apply_parens(month_diff), + ) + + case DateTimeUnit.WEEK: + # raw_delta = number of days between date1 and date2 + # dow1 = DAYOFWEEK(date1) + # dow2 = DAYOFWEEK(date2) + # result = INTEGER((raw_delta + dow1 - dow2) / 7) + raw_delta: SQLGlotExpression = sqlglot_expressions.Sub( + this=sqlglot_expressions.Cast( + this=date2, to=sqlglot_expressions.DataType(this="DATE") + ), + expression=sqlglot_expressions.Cast( + this=date1, to=sqlglot_expressions.DataType(this="DATE") + ), + ) + + dow1: SQLGlotExpression = self.convert_dayofweek([date1], [types[1]]) + dow2: SQLGlotExpression = self.convert_dayofweek([date2], [types[2]]) + + division: SQLGlotExpression = sqlglot_expressions.Div( + this=apply_parens( + sqlglot_expressions.Add( + this=raw_delta, + expression=sqlglot_expressions.Sub( + this=dow1, expression=dow2 + ), + ) + ), + expression=sqlglot_expressions.Literal.number(7), + ) + + return sqlglot_expressions.Anonymous( + this="FLOOR", expressions=[division] + ) + + case DateTimeUnit.DAY: + # TRUNC*date2 - date1) -> in Oracle this will return the difference in + # days as a number + return sqlglot_expressions.Anonymous( + this="TRUNC", + expressions=[ + sqlglot_expressions.Sub(this=date2, expression=date1), + ], + ) + + case DateTimeUnit.HOUR: + # TRUNC((date2 - date1) * 24) + hours_diff: SQLGlotExpression = sqlglot_expressions.Mul( + this=sqlglot_expressions.Sub(this=date2, expression=date1), + expression=sqlglot_expressions.Literal.number(24), + ) + return sqlglot_expressions.Anonymous( + this="TRUNC", expressions=[hours_diff] + ) + + case DateTimeUnit.MINUTE: + # TRUNC((date2 - date1) * 24 * 60) + minute_diff = sqlglot_expressions.Mul( + this=sqlglot_expressions.Sub(this=date2, expression=date1), + expression=sqlglot_expressions.Literal.number(24 * 60), + ) + return sqlglot_expressions.Anonymous( + this="TRUNC", expressions=[minute_diff] + ) + + case DateTimeUnit.SECOND: + # TRUNC((date2 - date1) * 24 * 60 * 60) + second_diff: SQLGlotExpression = sqlglot_expressions.Mul( + this=sqlglot_expressions.Sub(this=date2, expression=date1), + expression=sqlglot_expressions.Literal.number(24 * 60 * 60), + ) + return sqlglot_expressions.Anonymous( + this="TRUNC", expressions=[second_diff] + ) + + case _: + raise ValueError(f"Unsupported argument '{unit}' for DATEDIFF.") + + def dialect_day_of_week(self, base: SQLGlotExpression) -> SQLGlotExpression: + return sqlglot_expressions.ToChar( + this=base, + format=sqlglot_expressions.Literal.string("D"), + ) + + def days_from_start_of_week(self, base: SQLGlotExpression) -> SQLGlotExpression: + offset: int = (-self.start_of_week_offset) % 7 - 1 + dow_expr: SQLGlotExpression = self.dialect_day_of_week(base) + + return sqlglot_expressions.Mod( + this=apply_parens( + sqlglot_expressions.Add( + this=dow_expr, + expression=sqlglot_expressions.Literal.number(offset), + ) + ), + expression=sqlglot_expressions.Literal.number(7), + ) diff --git a/tests/test_pipeline_oracle.py b/tests/test_pipeline_oracle.py index 6211e4221..4a94d7c0d 100644 --- a/tests/test_pipeline_oracle.py +++ b/tests/test_pipeline_oracle.py @@ -169,23 +169,22 @@ def test_pipeline_e2e_oracle_tpch_simple_week( dayofweeks.append(dayofweek) # Create dictionary for DataFrame - data_dict = {"weeks_diff": [weeks_diff]} + data_dict = {"WEEKS_DIFF": [weeks_diff]} # Add start of week columns for i in range(len(dates)): - data_dict[f"sow{i + 1}"] = [sows[i]] + data_dict[f"SOW{i + 1}"] = [sows[i]] # Add day name columns for i in range(len(dates)): - data_dict[f"dayname{i + 1}"] = [daynames[i]] + data_dict[f"DAYNAME{i + 1}"] = [daynames[i]] # Add day of week columns for i in range(len(dates)): - data_dict[f"dayofweek{i + 1}"] = [dayofweeks[i]] + data_dict[f"DAYOFWEEK{i + 1}"] = [dayofweeks[i]] # Create DataFrame with expected results expected_df = pd.DataFrame(data_dict) - for col_name in result.columns: result[col_name], expected_df[col_name] = harmonize_types( result[col_name], expected_df[col_name] From 23017f7953f2faf161687e919f0ec3ca1ba7a49a Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Thu, 19 Feb 2026 15:44:29 -0600 Subject: [PATCH 13/48] dates fixed, refsol files updated --- .../sqlglot_relational_expression_visitor.py | 6 +- .../oracle_transform_bindings.py | 215 +++++++++++--- tests/test_metadata/oracle_defog_graphs.json | 2 +- .../defog_test_functions.py | 3 +- .../test_sql_refsols/agg_partition_oracle.sql | 2 +- .../agg_simplification_1_oracle.sql | 2 +- .../agg_simplification_2_oracle.sql | 2 +- .../aggregation_analytics_1_oracle.sql | 4 +- .../aggregation_analytics_2_oracle.sql | 4 +- .../aggregation_analytics_3_oracle.sql | 4 +- .../aggregation_functions_oracle.sql | 2 +- ...rnative_quarter_cum_ir_analysis_oracle.sql | 12 +- .../avg_gap_prev_urgent_same_clerk_oracle.sql | 6 +- .../avg_order_diff_per_customer_oracle.sql | 6 +- .../bad_child_reuse_1_oracle.sql | 2 +- .../bad_child_reuse_4_oracle.sql | 4 +- .../bad_child_reuse_5_oracle.sql | 2 +- .../casting_functions_oracle.sql | 4 +- .../conditional_functions_oracle.sql | 2 +- .../country_x_year_analysis_oracle.sql | 10 +- .../country_x_year_combos_oracle.sql | 4 +- .../cumulative_stock_analysis_oracle.sql | 4 +- .../customer_largest_order_deltas_oracle.sql | 8 +- .../customer_most_recent_orders_oracle.sql | 2 +- tests/test_sql_refsols/datediff_oracle.sql | 28 +- .../datetime_current_oracle.sql | 10 +- .../datetime_functions_oracle.sql | 61 ++-- .../datetime_relative_oracle.sql | 20 +- .../datetime_sampler_oracle.sql | 278 +++++++++--------- .../defog_academic_gen13_oracle.sql | 2 +- .../defog_academic_gen15_oracle.sql | 2 +- .../defog_academic_gen17_oracle.sql | 2 +- .../defog_academic_gen18_oracle.sql | 2 +- .../defog_academic_gen19_oracle.sql | 2 +- .../defog_academic_gen2_oracle.sql | 2 +- .../defog_academic_gen7_oracle.sql | 2 +- .../defog_broker_adv10_oracle.sql | 14 +- .../defog_broker_adv14_oracle.sql | 4 +- .../defog_broker_adv15_oracle.sql | 2 +- .../defog_broker_adv16_oracle.sql | 9 +- .../defog_broker_adv1_oracle.sql | 2 +- .../defog_broker_adv2_oracle.sql | 4 +- .../defog_broker_adv3_oracle.sql | 2 +- .../defog_broker_adv5_oracle.sql | 71 +++-- .../defog_broker_adv6_oracle.sql | 4 +- .../defog_broker_adv7_oracle.sql | 158 ++++++---- .../defog_broker_adv8_oracle.sql | 8 +- .../defog_broker_adv9_oracle.sql | 10 +- .../defog_broker_basic1_oracle.sql | 6 +- .../defog_broker_basic3_oracle.sql | 4 +- .../defog_broker_gen1_oracle.sql | 4 +- .../defog_broker_gen2_oracle.sql | 2 +- .../defog_broker_gen3_oracle.sql | 8 +- .../defog_broker_gen4_oracle.sql | 2 +- .../defog_broker_gen5_oracle.sql | 4 +- .../defog_dealership_adv10_oracle.sql | 7 +- .../defog_dealership_adv11_oracle.sql | 6 +- .../defog_dealership_adv14_oracle.sql | 4 +- .../defog_dealership_adv16_oracle.sql | 2 +- .../defog_dealership_adv1_oracle.sql | 32 +- .../defog_dealership_adv2_oracle.sql | 4 +- .../defog_dealership_adv3_oracle.sql | 2 +- .../defog_dealership_adv4_oracle.sql | 6 +- .../defog_dealership_adv5_oracle.sql | 4 +- .../defog_dealership_basic10_oracle.sql | 8 +- .../defog_dealership_basic5_oracle.sql | 6 +- .../defog_dealership_basic6_oracle.sql | 2 +- .../defog_dealership_basic7_oracle.sql | 2 +- .../defog_dealership_basic8_oracle.sql | 4 +- .../defog_dealership_gen1_oracle.sql | 2 +- .../defog_dealership_gen2_oracle.sql | 2 +- .../defog_dealership_gen4_oracle.sql | 2 +- .../defog_dealership_gen5_oracle.sql | 4 +- .../defog_dermtreatment_adv15_oracle.sql | 8 +- .../defog_dermtreatment_adv16_oracle.sql | 2 +- .../defog_dermtreatment_adv5_oracle.sql | 8 +- .../defog_dermtreatment_adv7_oracle.sql | 6 +- .../defog_dermtreatment_adv8_oracle.sql | 33 ++- .../defog_dermtreatment_adv9_oracle.sql | 148 +++++++--- .../defog_dermtreatment_basic1_oracle.sql | 4 +- .../defog_dermtreatment_basic2_oracle.sql | 2 +- .../defog_dermtreatment_basic3_oracle.sql | 2 +- .../defog_dermtreatment_gen1_oracle.sql | 8 +- .../defog_dermtreatment_gen2_oracle.sql | 21 +- .../defog_dermtreatment_gen3_oracle.sql | 4 +- .../defog_dermtreatment_gen4_oracle.sql | 8 +- .../defog_dermtreatment_gen5_oracle.sql | 2 +- .../defog_ewallet_adv11_ansi.sql | 4 +- .../defog_ewallet_adv11_mysql.sql | 4 +- .../defog_ewallet_adv11_oracle.sql | 12 +- .../defog_ewallet_adv11_postgres.sql | 4 +- .../defog_ewallet_adv11_snowflake.sql | 4 +- .../defog_ewallet_adv12_oracle.sql | 2 +- .../defog_ewallet_adv13_oracle.sql | 4 +- .../defog_ewallet_adv15_oracle.sql | 12 +- .../defog_ewallet_adv1_oracle.sql | 2 +- .../defog_ewallet_adv2_oracle.sql | 10 +- .../defog_ewallet_adv4_oracle.sql | 6 +- .../defog_ewallet_adv5_oracle.sql | 4 +- .../defog_ewallet_adv8_oracle.sql | 4 +- .../defog_ewallet_adv9_oracle.sql | 6 +- .../defog_ewallet_basic10_oracle.sql | 6 +- .../defog_ewallet_basic1_oracle.sql | 2 +- .../defog_ewallet_basic8_oracle.sql | 2 +- .../defog_ewallet_basic9_oracle.sql | 2 +- .../defog_ewallet_gen2_oracle.sql | 4 +- .../defog_ewallet_gen3_oracle.sql | 6 +- .../defog_ewallet_gen4_oracle.sql | 4 +- .../defog_ewallet_gen5_oracle.sql | 4 +- .../defog_restaurants_gen11_oracle.sql | 2 +- .../defog_restaurants_gen12_oracle.sql | 2 +- .../defog_restaurants_gen13_oracle.sql | 2 +- .../defog_restaurants_gen14_oracle.sql | 2 +- .../defog_restaurants_gen15_oracle.sql | 2 +- .../division_by_zero_database_oracle.sql | 6 + .../division_by_zero_null_oracle.sql | 6 + .../division_by_zero_zero_oracle.sql | 6 + .../division_complex_operands_null_oracle.sql | 10 + .../division_complex_operands_zero_oracle.sql | 16 + .../division_iff_false_branch_null_oracle.sql | 6 + .../division_iff_false_branch_zero_oracle.sql | 10 + .../division_iff_true_branch_null_oracle.sql | 6 + .../division_iff_true_branch_zero_oracle.sql | 10 + .../division_keep_if_denom_null_oracle.sql | 6 + .../division_keep_if_denom_zero_oracle.sql | 10 + .../division_multiple_ops_null_oracle.sql | 8 + .../division_multiple_ops_zero_oracle.sql | 6 + .../test_sql_refsols/double_cross_oracle.sql | 108 +++++-- .../double_partition_oracle.sql | 6 +- .../epoch_culture_events_info_oracle.sql | 16 +- .../epoch_event_gap_per_era_oracle.sql | 14 +- .../epoch_events_per_season_oracle.sql | 6 +- .../epoch_first_event_per_era_oracle.sql | 4 +- .../epoch_intra_season_searches_oracle.sql | 41 +-- ...t_popular_search_engine_per_tod_oracle.sql | 4 +- .../epoch_num_predawn_cold_war_oracle.sql | 8 +- .../epoch_pct_searches_per_tod_oracle.sql | 4 +- .../epoch_search_results_by_tod_oracle.sql | 4 +- .../epoch_summer_events_per_type_oracle.sql | 6 +- .../epoch_unique_users_per_engine_oracle.sql | 6 +- ...ch_users_most_cold_war_searches_oracle.sql | 4 +- .../first_order_in_year_oracle.sql | 4 +- .../function_sampler_oracle.sql | 5 +- .../has_equals_one_oracle.sql | 5 + .../hasnot_equals_one_oracle.sql | 17 ++ .../highest_priority_per_year_oracle.sql | 4 +- .../hour_minute_day_oracle.sql | 8 +- .../keywords_alias_reserved_word_oracle.sql | 2 +- ...keywords_expr_call_quoted_names_oracle.sql | 2 +- .../keywords_python_sql_reserved_oracle.sql | 2 +- .../month_year_sliding_windows_oracle.sql | 24 +- .../nation_best_order_oracle.sql | 2 +- .../odate_and_rdate_avggap_oracle.sql | 6 +- .../order_info_per_priority_oracle.sql | 2 +- .../order_quarter_test_oracle.sql | 28 +- .../orders_versus_first_orders_oracle.sql | 2 +- .../part_cross_part_a_oracle.sql | 2 +- .../part_cross_part_b_oracle.sql | 6 +- .../part_cross_part_c_oracle.sql | 6 +- .../part_reduced_size_oracle.sql | 15 +- .../parts_quantity_increase_95_96_oracle.sql | 10 +- .../quantile_function_test_1_oracle.sql | 2 +- .../quantile_function_test_2_oracle.sql | 2 +- .../quantile_function_test_3_oracle.sql | 2 +- .../quantile_test_1_oracle.sql | 2 +- .../quantile_test_2_oracle.sql | 2 +- .../quarter_cum_ir_analysis_oracle.sql | 14 +- .../quarter_function_test_oracle.sql | 82 ++++-- ...ion_orders_from_nations_richest_oracle.sql | 2 +- ...onal_first_order_best_line_part_oracle.sql | 4 +- .../simple_cross_10_oracle.sql | 2 +- .../simple_cross_14_oracle.sql | 2 +- .../simple_cross_3_oracle.sql | 4 +- .../simple_cross_4_oracle.sql | 2 +- .../simple_cross_5_oracle.sql | 8 +- .../simple_cross_7_oracle.sql | 2 +- .../simple_cross_8_oracle.sql | 4 +- .../simple_int_float_string_cast_oracle.sql | 18 +- .../simple_smallest_or_largest_oracle.sql | 12 +- .../simplification_1_oracle.sql | 2 +- .../simplification_2_oracle.sql | 2 +- .../simplification_3_oracle.sql | 16 +- .../simplification_4_oracle.sql | 44 +-- tests/test_sql_refsols/singular4_oracle.sql | 2 +- tests/test_sql_refsols/singular7_oracle.sql | 6 +- tests/test_sql_refsols/smoke_a_oracle.sql | 48 +-- tests/test_sql_refsols/smoke_b_oracle.sql | 146 ++++++--- tests/test_sql_refsols/smoke_c_oracle.sql | 6 +- ...saction_week_sampler_friday_one_oracle.sql | 20 +- ...action_week_sampler_friday_zero_oracle.sql | 20 +- ...saction_week_sampler_monday_one_oracle.sql | 20 +- ...action_week_sampler_monday_zero_oracle.sql | 20 +- ...ction_week_sampler_saturday_one_oracle.sql | 20 +- ...tion_week_sampler_saturday_zero_oracle.sql | 20 +- ...saction_week_sampler_sunday_one_oracle.sql | 24 +- ...action_week_sampler_sunday_zero_oracle.sql | 22 +- ...ction_week_sampler_thursday_one_oracle.sql | 20 +- ...tion_week_sampler_thursday_zero_oracle.sql | 20 +- ...action_week_sampler_tuesday_one_oracle.sql | 20 +- ...ction_week_sampler_tuesday_zero_oracle.sql | 20 +- ...tion_week_sampler_wednesday_one_oracle.sql | 20 +- ...ion_week_sampler_wednesday_zero_oracle.sql | 20 +- .../string_format_specifiers_oracle.sql | 30 +- .../string_functions_oracle.sql | 5 +- .../supplier_best_part_oracle.sql | 6 +- .../supplier_pct_national_qty_oracle.sql | 12 +- ...battery_failure_rates_anomalies_oracle.sql | 2 +- ...ph_country_combination_analysis_oracle.sql | 2 +- ..._country_incident_rate_analysis_oracle.sql | 6 +- ...or_percentages_sun_set_by_error_oracle.sql | 9 +- ...rate_sun_set_by_factory_country_oracle.sql | 4 +- ...technograph_hot_purchase_window_oracle.sql | 6 +- ...h_incident_rate_by_release_year_oracle.sql | 10 +- ...nograph_incident_rate_per_brand_oracle.sql | 2 +- ...chnograph_monthly_incident_rate_oracle.sql | 41 ++- ...ograph_most_unreliable_products_oracle.sql | 2 +- ...ve_incident_rate_goldcopperstar_oracle.sql | 22 +- ...umulative_incident_rate_overall_oracle.sql | 12 +- .../time_threshold_reached_oracle.sql | 2 +- .../top_customers_by_orders_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q10_oracle.sql | 6 +- tests/test_sql_refsols/tpch_q11_oracle.sql | 6 +- tests/test_sql_refsols/tpch_q12_oracle.sql | 6 +- tests/test_sql_refsols/tpch_q13_oracle.sql | 4 +- tests/test_sql_refsols/tpch_q14_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q15_oracle.sql | 6 +- tests/test_sql_refsols/tpch_q17_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q19_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q1_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q20_oracle.sql | 4 +- tests/test_sql_refsols/tpch_q21_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q22_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q3_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q4_oracle.sql | 4 +- tests/test_sql_refsols/tpch_q5_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q6_oracle.sql | 2 +- tests/test_sql_refsols/tpch_q7_oracle.sql | 8 +- tests/test_sql_refsols/tpch_q8_oracle.sql | 10 +- tests/test_sql_refsols/tpch_q9_oracle.sql | 6 +- .../triple_partition_oracle.sql | 6 +- .../user_range_collection_1_oracle.sql | 2 +- .../user_range_collection_2_oracle.sql | 4 +- .../user_range_collection_3_oracle.sql | 4 +- .../user_range_collection_5_oracle.sql | 2 +- .../user_range_collection_6_oracle.sql | 6 +- tests/test_sql_refsols/week_offset_oracle.sql | 20 +- .../window_filter_order_1_oracle.sql | 6 +- .../window_filter_order_2_oracle.sql | 6 +- .../window_filter_order_3_oracle.sql | 6 +- .../window_filter_order_4_oracle.sql | 2 +- .../window_filter_order_5_oracle.sql | 4 +- .../window_filter_order_6_oracle.sql | 4 +- .../window_filter_order_7_oracle.sql | 2 +- .../window_filter_order_8_oracle.sql | 6 +- .../window_filter_order_9_oracle.sql | 2 +- .../year_month_nation_orders_oracle.sql | 8 +- .../yoy_change_in_num_orders_oracle.sql | 4 +- 257 files changed, 1919 insertions(+), 1167 deletions(-) create mode 100644 tests/test_sql_refsols/division_by_zero_database_oracle.sql create mode 100644 tests/test_sql_refsols/division_by_zero_null_oracle.sql create mode 100644 tests/test_sql_refsols/division_by_zero_zero_oracle.sql create mode 100644 tests/test_sql_refsols/division_complex_operands_null_oracle.sql create mode 100644 tests/test_sql_refsols/division_complex_operands_zero_oracle.sql create mode 100644 tests/test_sql_refsols/division_iff_false_branch_null_oracle.sql create mode 100644 tests/test_sql_refsols/division_iff_false_branch_zero_oracle.sql create mode 100644 tests/test_sql_refsols/division_iff_true_branch_null_oracle.sql create mode 100644 tests/test_sql_refsols/division_iff_true_branch_zero_oracle.sql create mode 100644 tests/test_sql_refsols/division_keep_if_denom_null_oracle.sql create mode 100644 tests/test_sql_refsols/division_keep_if_denom_zero_oracle.sql create mode 100644 tests/test_sql_refsols/division_multiple_ops_null_oracle.sql create mode 100644 tests/test_sql_refsols/division_multiple_ops_zero_oracle.sql create mode 100644 tests/test_sql_refsols/has_equals_one_oracle.sql create mode 100644 tests/test_sql_refsols/hasnot_equals_one_oracle.sql diff --git a/pydough/sqlglot/sqlglot_relational_expression_visitor.py b/pydough/sqlglot/sqlglot_relational_expression_visitor.py index ab8b150ef..454f844e0 100644 --- a/pydough/sqlglot/sqlglot_relational_expression_visitor.py +++ b/pydough/sqlglot/sqlglot_relational_expression_visitor.py @@ -383,9 +383,11 @@ def visit_literal_expression(self, literal_expression: LiteralExpression) -> Non "PyDough does not yet support datetime values with a timezone" ) literal = sqlglot_expressions.Anonymous( - this="TO_TIMESTAMP", + this="TO_DATE", expressions=[ - sqlglot_expressions.convert(dt.isoformat(sep=" ")), + sqlglot_expressions.convert( + literal_expression.value.strftime("%Y-%m-%d %H:%M:%S") + ), sqlglot_expressions.Literal.string("YYYY-MM-DD HH24:MI:SS"), ], ) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index ad4204b8c..90c1ee207 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -9,6 +9,7 @@ from sqlglot.expressions import Expression as SQLGlotExpression import pydough.pydough_operators as pydop +from pydough.errors.error_types import PyDoughSQLException from pydough.types import PyDoughType from .base_transform_bindings import BaseTransformBindings @@ -41,7 +42,6 @@ def dialect_dow_mapping(self) -> dict[str, int]: pydop.SMALLEST: "LEAST", pydop.STRIP: "TRIM", pydop.FIND: "INSTR", - pydop.JOIN_STRINGS: "LISTAGG", pydop.PERCENTILE: "PERCENTILE_CONT", } @@ -357,8 +357,15 @@ def convert_datediff( raise ValueError( f"Unsupported argument for DATEDIFF: {args[0]!r}. It should be a string literal." ) - date1 = self.make_datetime_arg(args[1]) - date2 = self.make_datetime_arg(args[2]) + + date1: SQLGlotExpression = sqlglot_expressions.Cast( + this=self.make_datetime_arg(args[1]), + to=sqlglot_expressions.DataType(this="DATE"), + ) + date2: SQLGlotExpression = sqlglot_expressions.Cast( + this=self.make_datetime_arg(args[2]), + to=sqlglot_expressions.DataType(this="DATE"), + ) unit: DateTimeUnit | None = DateTimeUnit.from_string(args[0].this) if unit is None: @@ -420,18 +427,13 @@ def convert_datediff( # raw_delta = number of days between date1 and date2 # dow1 = DAYOFWEEK(date1) # dow2 = DAYOFWEEK(date2) - # result = INTEGER((raw_delta + dow1 - dow2) / 7) + # result = FLOOR((raw_delta + dow1 - dow2) / 7) raw_delta: SQLGlotExpression = sqlglot_expressions.Sub( - this=sqlglot_expressions.Cast( - this=date2, to=sqlglot_expressions.DataType(this="DATE") - ), - expression=sqlglot_expressions.Cast( - this=date1, to=sqlglot_expressions.DataType(this="DATE") - ), + this=date2, expression=date1 ) - dow1: SQLGlotExpression = self.convert_dayofweek([date1], [types[1]]) - dow2: SQLGlotExpression = self.convert_dayofweek([date2], [types[2]]) + dow1: SQLGlotExpression = self.convert_dayofweek([args[1]], [types[1]]) + dow2: SQLGlotExpression = self.convert_dayofweek([args[2]], [types[2]]) division: SQLGlotExpression = sqlglot_expressions.Div( this=apply_parens( @@ -450,44 +452,49 @@ def convert_datediff( ) case DateTimeUnit.DAY: - # TRUNC*date2 - date1) -> in Oracle this will return the difference in - # days as a number - return sqlglot_expressions.Anonymous( - this="TRUNC", - expressions=[ - sqlglot_expressions.Sub(this=date2, expression=date1), - ], - ) + # date2 - date1 + return sqlglot_expressions.Sub(this=date2, expression=date1) case DateTimeUnit.HOUR: - # TRUNC((date2 - date1) * 24) - hours_diff: SQLGlotExpression = sqlglot_expressions.Mul( - this=sqlglot_expressions.Sub(this=date2, expression=date1), - expression=sqlglot_expressions.Literal.number(24), + # (TRUNC(date2, 'HH24') - TRUNC(date1, 'HH24')) * 24 + hours_diff: SQLGlotExpression = sqlglot_expressions.Sub( + this=sqlglot_expressions.DateTrunc( + this=date2, unit=sqlglot_expressions.Literal.string("HH24") + ), + expression=sqlglot_expressions.DateTrunc( + this=date1, unit=sqlglot_expressions.Literal.string("HH24") + ), ) - return sqlglot_expressions.Anonymous( - this="TRUNC", expressions=[hours_diff] + return sqlglot_expressions.Mul( + this=apply_parens(hours_diff), + expression=sqlglot_expressions.Literal.number(24), ) case DateTimeUnit.MINUTE: - # TRUNC((date2 - date1) * 24 * 60) - minute_diff = sqlglot_expressions.Mul( - this=sqlglot_expressions.Sub(this=date2, expression=date1), - expression=sqlglot_expressions.Literal.number(24 * 60), + # (TRUNC(date2, 'MI') - TRUNC(date1, 'MI')) * 24 * 60 + minutes_diff: SQLGlotExpression = sqlglot_expressions.Sub( + this=sqlglot_expressions.DateTrunc( + this=date2, unit=sqlglot_expressions.Literal.string("MI") + ), + expression=sqlglot_expressions.DateTrunc( + this=date1, unit=sqlglot_expressions.Literal.string("MI") + ), ) - return sqlglot_expressions.Anonymous( - this="TRUNC", expressions=[minute_diff] + return sqlglot_expressions.Mul( + this=apply_parens(minutes_diff), + expression=sqlglot_expressions.Literal.number(24 * 60), ) case DateTimeUnit.SECOND: - # TRUNC((date2 - date1) * 24 * 60 * 60) + # (date2 - date1) * 24 * 60 * 60 + dates_sub: SQLGlotExpression = sqlglot_expressions.Sub( + this=date2, expression=date1 + ) second_diff: SQLGlotExpression = sqlglot_expressions.Mul( - this=sqlglot_expressions.Sub(this=date2, expression=date1), + this=apply_parens(dates_sub), expression=sqlglot_expressions.Literal.number(24 * 60 * 60), ) - return sqlglot_expressions.Anonymous( - this="TRUNC", expressions=[second_diff] - ) + return second_diff case _: raise ValueError(f"Unsupported argument '{unit}' for DATEDIFF.") @@ -511,3 +518,137 @@ def days_from_start_of_week(self, base: SQLGlotExpression) -> SQLGlotExpression: ), expression=sqlglot_expressions.Literal.number(7), ) + + def convert_current_timestamp(self) -> SQLGlotExpression: + """ + Create a SQLGlot expression to obtain the current timestamp removing the + timezone for Oracle. + SQL: + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) + """ + return sqlglot_expressions.Anonymous( + this="SYS_EXTRACT_UTC", + expressions=[ + sqlglot_expressions.Column( + this=sqlglot_expressions.Identifier(this="SYSTIMESTAMP") + ) + ], + ) + + def apply_datetime_offset( + self, base: SQLGlotExpression, amt: int, unit: DateTimeUnit + ) -> SQLGlotExpression: + new_expr: SQLGlotExpression | None = None + + if amt < 0: + amt *= -1 + + interval: SQLGlotExpression = ( + sqlglot_expressions.Anonymous( + this="NUMTODSINTERVAL", + expressions=[ + sqlglot_expressions.convert(amt), + sqlglot_expressions.Literal.string(unit.value), + ], + ) + if unit not in [DateTimeUnit.YEAR, DateTimeUnit.MONTH] + else sqlglot_expressions.Anonymous( + this="NUMTOYMINTERVAL", + expressions=[ + sqlglot_expressions.convert(amt), + sqlglot_expressions.Literal.string(unit.value), + ], + ) + ) + if amt > 0: + new_expr = sqlglot_expressions.Add(this=base, expression=interval) + elif amt < 0: + new_expr = sqlglot_expressions.Sub(this=base, expression=interval) + else: + new_expr = base + return new_expr + + def convert_join_strings( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + # args[0] is the delimiter, args[1:] are the strings to join + delim: SQLGlotExpression = args[0] + string_args: list[SQLGlotExpression] = args[1:] + + # Build a chain of NVL2(arg, delim || arg, NULL) expressions + concatenated: SQLGlotExpression | None = None + for arg in string_args: + # Create: NVL2(arg, delim || arg, NULL) + delim_and_arg = sqlglot_expressions.DPipe( + this=delim, + expression=arg, + safe=True, + ) + nvl2_expr = sqlglot_expressions.Anonymous( + this="NVL2", + expressions=[arg, delim_and_arg, sqlglot_expressions.Null()], + ) + + if concatenated is None: + concatenated = nvl2_expr + else: + concatenated = sqlglot_expressions.DPipe( + this=concatenated, expression=nvl2_expr, safe=True + ) + + # Wrap in LTRIM to remove the very first separator + result: SQLGlotExpression = sqlglot_expressions.Anonymous( + this="LTRIM", expressions=[concatenated, delim] + ) + return result + + def convert_extract_datetime( + self, + args: list[SQLGlotExpression], + types: list[PyDoughType], + unit: DateTimeUnit, + ) -> SQLGlotExpression: + assert len(args) == 1 + + cast_type: SQLGlotExpression = ( + "DATE" + if unit not in [DateTimeUnit.HOUR, DateTimeUnit.MINUTE, DateTimeUnit.SECOND] + else "TIMESTAMP" + ) + + return sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this=unit.value.upper()), + expression=sqlglot_expressions.Cast( + this=self.make_datetime_arg(args[0]), + to=sqlglot_expressions.DataType(this=cast_type), + ), + ) + + def convert_string( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + if len(args) == 1: + # Length defaults to 4000 which is the max length of a VARCHAR2 in + # Oracle + return sqlglot_expressions.Cast( + this=args[0], + to=sqlglot_expressions.DataType( + this=sqlglot_expressions.Var(this="VARCHAR"), + expressions=[ + sqlglot_expressions.DataTypeParam( + this=sqlglot_expressions.Literal.number(4000) + ) + ], + nested=False, + ), + ) + else: + assert len(args) == 2 + if ( + not isinstance(args[1], sqlglot_expressions.Literal) + or not args[1].is_string + ): + raise PyDoughSQLException( + f"STRING(X,Y) requires the second argument to be a string date format literal, but received {args[1]}" + ) + return sqlglot_expressions.ToChar(this=args[0], format=args[1]) diff --git a/tests/test_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json index f93107589..b77252d11 100644 --- a/tests/test_metadata/oracle_defog_graphs.json +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -2189,7 +2189,7 @@ { "name": "uid", "type": "table column", - "column name": "uid", + "column name": "\"UID\"", "data type": "numeric", "description": "The unique identifier for each user in the system", "sample values": [1, 3, 5, 10, 11], diff --git a/tests/test_pydough_functions/defog_test_functions.py b/tests/test_pydough_functions/defog_test_functions.py index 853f83668..22743c719 100644 --- a/tests/test_pydough_functions/defog_test_functions.py +++ b/tests/test_pydough_functions/defog_test_functions.py @@ -1449,7 +1449,8 @@ def impl_defog_ewallet_adv11(): duration first. """ selected_sessions = sessions.WHERE( - (session_start >= "2023-06-01") & (session_end < "2023-06-08") + (session_start >= DATETIME("2023-06-01")) + & (session_end < DATETIME("2023-06-08")) ).CALCULATE(duration=DATEDIFF("seconds", session_start, session_end)) return ( users.WHERE(HAS(selected_sessions)) diff --git a/tests/test_sql_refsols/agg_partition_oracle.sql b/tests/test_sql_refsols/agg_partition_oracle.sql index 890272742..7c5cefcf7 100644 --- a/tests/test_sql_refsols/agg_partition_oracle.sql +++ b/tests/test_sql_refsols/agg_partition_oracle.sql @@ -3,7 +3,7 @@ WITH "_T0" AS ( COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) ) SELECT MAX(N_ROWS) AS best_year diff --git a/tests/test_sql_refsols/agg_simplification_1_oracle.sql b/tests/test_sql_refsols/agg_simplification_1_oracle.sql index 3c51f4bb7..550e70884 100644 --- a/tests/test_sql_refsols/agg_simplification_1_oracle.sql +++ b/tests/test_sql_refsols/agg_simplification_1_oracle.sql @@ -167,7 +167,7 @@ SELECT 0 AS su5, N_ROWS * 0.5 AS su6, 0 AS su7, - NVL(AUG_EXCHANGE, 0) AS su8, + COALESCE(AUG_EXCHANGE, 0) AS su8, N_ROWS AS co1, N_ROWS AS co2, N_ROWS AS co3, diff --git a/tests/test_sql_refsols/agg_simplification_2_oracle.sql b/tests/test_sql_refsols/agg_simplification_2_oracle.sql index e4dccb32c..b569bb108 100644 --- a/tests/test_sql_refsols/agg_simplification_2_oracle.sql +++ b/tests/test_sql_refsols/agg_simplification_2_oracle.sql @@ -3,7 +3,7 @@ SELECT COUNT(DISTINCT sbcustcity) AS a1, COUNT(*) AS a2, COUNT(CASE WHEN LOWER(sbcustname) LIKE 'j%' THEN sbcustname ELSE NULL END) AS a3, - NVL(SUM(CAST(sbcustpostalcode AS INT)), 0) AS a4, + COALESCE(SUM(CAST(sbcustpostalcode AS INT)), 0) AS a4, MIN(sbcustphone) AS a5, MAX(sbcustphone) AS a6, ANY_VALUE(LOWER(sbcuststate)) AS a7, diff --git a/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql index 82c4b5149..662cb96a0 100644 --- a/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql +++ b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql @@ -22,7 +22,7 @@ WITH "_T1" AS ( JOIN TPCH.PART PART ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) IN (1995, 1996) AND LINEITEM.l_partkey = PARTSUPP.ps_partkey AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey GROUP BY @@ -31,7 +31,7 @@ WITH "_T1" AS ( ) SELECT PART.p_name AS part_name, - ROUND(NVL("_S11".SUM_REVENUE, 0), 2) AS revenue_generated + ROUND(COALESCE("_S11".SUM_REVENUE, 0), 2) AS revenue_generated FROM TPCH.PARTSUPP PARTSUPP JOIN "_T1" "_T1" ON PARTSUPP.ps_suppkey = "_T1".S_SUPPKEY diff --git a/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql index 5c72d413f..97178b3c5 100644 --- a/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql +++ b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql @@ -15,7 +15,7 @@ WITH "_S6" AS ( JOIN TPCH.PART PART ON PART.p_container LIKE 'SM%' AND PART.p_partkey = PARTSUPP.ps_partkey JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) IN (1995, 1996) AND LINEITEM.l_partkey = PARTSUPP.ps_partkey AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey GROUP BY @@ -24,7 +24,7 @@ WITH "_S6" AS ( ) SELECT PART.p_name AS part_name, - ROUND(NVL("_S6".SUM_REVENUE, 0), 2) AS revenue_generated + ROUND(COALESCE("_S6".SUM_REVENUE, 0), 2) AS revenue_generated FROM "_S6" "_S6" JOIN TPCH.PART PART ON PART.p_partkey = "_S6".PS_PARTKEY diff --git a/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql index 9bd0e98cd..ec784947d 100644 --- a/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql +++ b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql @@ -16,7 +16,7 @@ WITH "_S6" AS ( JOIN TPCH.PART PART ON PART.p_container LIKE 'MED%' AND PART.p_partkey = PARTSUPP.ps_partkey JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1994 + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1994 AND LINEITEM.l_partkey = PARTSUPP.ps_partkey AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey GROUP BY @@ -25,7 +25,7 @@ WITH "_S6" AS ( ) SELECT PART.p_name AS part_name, - ROUND(NVL("_S6".SUM_REVENUE, 0) / NVL("_S6".SUM_L_QUANTITY, 0), 2) AS revenue_ratio + ROUND(COALESCE("_S6".SUM_REVENUE, 0) / COALESCE("_S6".SUM_L_QUANTITY, 0), 2) AS revenue_ratio FROM "_S6" "_S6" JOIN TPCH.PART PART ON PART.p_partkey = "_S6".PS_PARTKEY diff --git a/tests/test_sql_refsols/aggregation_functions_oracle.sql b/tests/test_sql_refsols/aggregation_functions_oracle.sql index 4f9084ea9..940847f0a 100644 --- a/tests/test_sql_refsols/aggregation_functions_oracle.sql +++ b/tests/test_sql_refsols/aggregation_functions_oracle.sql @@ -52,7 +52,7 @@ WITH "_S1" AS ( C_NATIONKEY ) SELECT - NVL(SUM_C_ACCTBAL, 0) AS sum_value, + COALESCE(SUM_C_ACCTBAL, 0) AS sum_value, AVG_C_ACCTBAL AS avg_value, AVG_EXPR_17 AS median_value, MIN_C_ACCTBAL AS min_value, diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql index 9fc3fc67b..ead79b626 100644 --- a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -14,7 +14,7 @@ WITH "_S0" AS ( TRUNC(CAST("_S0".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER FROM "_S0" "_S0" JOIN "_T2" "_T2" - ON "_S0".CA_DT < TRUNC(DATE_ADD(CAST("_T2".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S0".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S0".CA_DT >= "_T2".PR_RELEASE ), "_T5" AS ( SELECT @@ -36,7 +36,7 @@ WITH "_S0" AS ( COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID FROM "_S0" "_S2" JOIN "_T2" "_T4" - ON "_S2".CA_DT < TRUNC(DATE_ADD(CAST("_T4".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S2".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S2".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.INCIDENTS INCIDENTS ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') @@ -52,7 +52,7 @@ WITH "_S0" AS ( COUNT(*) AS N_ROWS FROM "_S0" "_S14" JOIN "_T2" "_T8" - ON "_S14".CA_DT < TRUNC(DATE_ADD(CAST("_T8".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S14".CA_DT < TRUNC(CAST("_T8".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S14".CA_DT >= "_T8".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') @@ -63,10 +63,10 @@ WITH "_S0" AS ( ) SELECT "_S12".QUARTER AS quarter, - NVL("_S13".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, - NVL("_S21".N_ROWS, 0) AS n_sold, + COALESCE("_S13".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + COALESCE("_S21".N_ROWS, 0) AS n_sold, ROUND( - SUM(NVL("_S13".NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY "_S12".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL("_S21".N_ROWS, 0)) OVER (ORDER BY "_S12".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(COALESCE("_S13".NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY "_S12".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(COALESCE("_S21".N_ROWS, 0)) OVER (ORDER BY "_S12".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS quarter_cum FROM "_S12" "_S12" diff --git a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql index 15f375aa7..467e6615c 100644 --- a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql +++ b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql @@ -1,10 +1,6 @@ WITH "_T0" AS ( SELECT - DATEDIFF( - CAST(o_orderdate AS DATETIME), - CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_clerk ORDER BY o_orderdate) AS DATETIME), - DAY - ) AS DELTA + CAST(o_orderdate AS DATE) - CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_clerk ORDER BY o_orderdate) AS DATE) AS DELTA FROM TPCH.ORDERS WHERE o_orderpriority = '1-URGENT' diff --git a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql index 53f926893..3c854bdb4 100644 --- a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql +++ b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql @@ -2,11 +2,7 @@ WITH "_T1" AS ( SELECT CUSTOMER.c_name AS C_NAME, ORDERS.o_custkey AS O_CUSTKEY, - DATEDIFF( - CAST(ORDERS.o_orderdate AS DATETIME), - CAST(LAG(ORDERS.o_orderdate, 1) OVER (PARTITION BY ORDERS.o_custkey ORDER BY ORDERS.o_orderdate) AS DATETIME), - DAY - ) AS DAY_DIFF + CAST(ORDERS.o_orderdate AS DATE) - CAST(LAG(ORDERS.o_orderdate, 1) OVER (PARTITION BY ORDERS.o_custkey ORDER BY ORDERS.o_orderdate) AS DATE) AS DAY_DIFF FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'JAPAN' diff --git a/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql index 40bb46190..b8d8ce13c 100644 --- a/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql @@ -14,7 +14,7 @@ WITH "_S1" AS ( ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST, - NVL("_S1".N_ROWS, 0) NULLS FIRST + COALESCE("_S1".N_ROWS, 0) NULLS FIRST FETCH FIRST 10 ROWS ONLY ) SELECT diff --git a/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql index 570830aaa..2de33d6b0 100644 --- a/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql @@ -10,7 +10,7 @@ WITH "_S1" AS ( CUSTOMER.c_acctbal AS C_ACCTBAL, CUSTOMER.c_custkey AS C_CUSTKEY, "_S1".N_ROWS, - AVG(CAST(NVL("_S1".N_ROWS, 0) AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey) AS "_W" + AVG(CAST(COALESCE("_S1".N_ROWS, 0) AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey) AS "_W" FROM TPCH.CUSTOMER CUSTOMER LEFT JOIN "_S1" "_S1" ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY @@ -20,7 +20,7 @@ SELECT N_ROWS AS n_orders FROM "_T" WHERE - N_ROWS <> 0 AND "_W" > NVL(N_ROWS, 0) + N_ROWS <> 0 AND "_W" > COALESCE(N_ROWS, 0) ORDER BY C_ACCTBAL DESC NULLS LAST FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql index 908f35406..93d05a844 100644 --- a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql @@ -24,7 +24,7 @@ WITH "_T2" AS ( ) SELECT "_S2".C_CUSTKEY AS cust_key, - NVL("_S2".N_ROWS, 0) AS n_orders + COALESCE("_S2".N_ROWS, 0) AS n_orders FROM "_S2" "_S2" JOIN "_T2" "_S3" ON "_S2".C_CUSTKEY = "_S3".O_CUSTKEY diff --git a/tests/test_sql_refsols/casting_functions_oracle.sql b/tests/test_sql_refsols/casting_functions_oracle.sql index 589838d9c..7cb6a8382 100644 --- a/tests/test_sql_refsols/casting_functions_oracle.sql +++ b/tests/test_sql_refsols/casting_functions_oracle.sql @@ -1,6 +1,6 @@ SELECT - TO_CHAR(o_orderdate, 'YYYY-MM-DD') AS cast_to_string, - CAST(o_totalprice AS CLOB) AS cast_to_string2, + TO_CHAR(o_orderdate, '%Y-%m-%d') AS cast_to_string, + CAST(o_totalprice AS VARCHAR2(4000)) AS cast_to_string2, CAST(o_totalprice AS INT) AS cast_to_integer, CAST(o_shippriority AS DOUBLE PRECISION) AS cast_to_float FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/conditional_functions_oracle.sql b/tests/test_sql_refsols/conditional_functions_oracle.sql index 39d55094b..2e7fc4d16 100644 --- a/tests/test_sql_refsols/conditional_functions_oracle.sql +++ b/tests/test_sql_refsols/conditional_functions_oracle.sql @@ -1,7 +1,7 @@ SELECT CASE WHEN ANY_VALUE(CUSTOMER.c_acctbal) > 1000 THEN 'High' ELSE 'Low' END AS iff_col, ANY_VALUE(CUSTOMER.c_name) IN ('Alice', 'Bob', 'Charlie') AS isin_col, - NVL(MIN(ORDERS.o_totalprice), 0.0) AS default_val, + COALESCE(MIN(ORDERS.o_totalprice), 0.0) AS default_val, NOT MIN(ORDERS.o_totalprice) IS NULL AS has_acct_bal, MIN(ORDERS.o_totalprice) IS NULL AS no_acct_bal, CASE diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql index bd3d2266e..3cc39521d 100644 --- a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -23,7 +23,9 @@ WITH "_T1" AS ( FROM "_T1" "_T6" CROSS JOIN "_T4" "_T7" JOIN "_S3" "_S7" - ON "_S7".CA_DT < DATE_ADD(CAST("_T7".PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + ON "_S7".CA_DT < ( + CAST("_T7".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year') + ) AND "_S7".CA_DT >= "_T7".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON "_S7".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') @@ -43,7 +45,9 @@ WITH "_T1" AS ( FROM "_T1" "_T3" CROSS JOIN "_T4" "_T4" JOIN "_S3" "_S3" - ON "_S3".CA_DT < DATE_ADD(CAST("_T4".PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + ON "_S3".CA_DT < ( + CAST("_T4".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year') + ) AND "_S3".CA_DT >= "_T4".PR_RELEASE LEFT JOIN "_S15" "_S15" ON "_S15".CA_DT = "_S3".CA_DT AND "_S15".CO_NAME = "_T3".CO_NAME @@ -54,7 +58,7 @@ WITH "_T1" AS ( SELECT "_T1".CO_NAME AS country_name, "_S17".START_OF_YEAR AS start_of_year, - NVL("_S17".SUM_N_ROWS, 0) AS n_purchases + COALESCE("_S17".SUM_N_ROWS, 0) AS n_purchases FROM "_T1" "_T1" LEFT JOIN "_S17" "_S17" ON "_S17".CO_NAME = "_T1".CO_NAME diff --git a/tests/test_sql_refsols/country_x_year_combos_oracle.sql b/tests/test_sql_refsols/country_x_year_combos_oracle.sql index 5a5048cf2..db95c2367 100644 --- a/tests/test_sql_refsols/country_x_year_combos_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_combos_oracle.sql @@ -12,7 +12,9 @@ WITH "_T1" AS ( JOIN MAIN.PRODUCTS PRODUCTS ON PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.CALENDAR CALENDAR - ON CALENDAR.ca_dt < DATE_ADD(CAST(PRODUCTS.pr_release AS TIMESTAMP), 2, 'YEAR') + ON CALENDAR.ca_dt < ( + CAST(PRODUCTS.pr_release AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year') + ) AND CALENDAR.ca_dt >= PRODUCTS.pr_release ) SELECT diff --git a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql index 38685d21c..a35ad2aad 100644 --- a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql +++ b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql @@ -25,8 +25,8 @@ FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBTICKER SBTICKER ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid WHERE - EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 4 - AND EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 4 + AND EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 2023 AND SBTRANSACTION.sbtxstatus = 'success' ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql index 8b45ec8d1..ab0db546a 100644 --- a/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql +++ b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( l_orderkey AS L_ORDERKEY FROM TPCH.LINEITEM WHERE - EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_shipmode = 'AIR' + EXTRACT(YEAR FROM CAST(l_shipdate AS DATE)) = 1994 AND l_shipmode = 'AIR' ), "_T5" AS ( SELECT ANY_VALUE(ORDERS.o_custkey) AS ANYTHING_O_CUSTKEY, @@ -17,7 +17,7 @@ WITH "_S1" AS ( LEFT JOIN "_S1" "_S1" ON ORDERS.o_orderkey = "_S1".L_ORDERKEY WHERE - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1994 + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1994 GROUP BY ORDERS.o_orderkey ), "_T" AS ( @@ -25,13 +25,13 @@ WITH "_S1" AS ( ANYTHING_O_CUSTKEY, ANYTHING_O_ORDERDATE, SUM_R, - LAG(NVL(SUM_R, 0), 1) OVER (PARTITION BY ANYTHING_O_CUSTKEY ORDER BY ANYTHING_O_ORDERDATE) AS "_W" + LAG(COALESCE(SUM_R, 0), 1) OVER (PARTITION BY ANYTHING_O_CUSTKEY ORDER BY ANYTHING_O_ORDERDATE) AS "_W" FROM "_T5" ), "_T1" AS ( SELECT "_T".ANYTHING_O_CUSTKEY, CUSTOMER.c_name AS C_NAME, - NVL("_T".SUM_R, 0) - LAG(NVL("_T".SUM_R, 0), 1) OVER (PARTITION BY "_T".ANYTHING_O_CUSTKEY ORDER BY "_T".ANYTHING_O_ORDERDATE) AS REVENUE_DELTA + COALESCE("_T".SUM_R, 0) - LAG(COALESCE("_T".SUM_R, 0), 1) OVER (PARTITION BY "_T".ANYTHING_O_CUSTKEY ORDER BY "_T".ANYTHING_O_ORDERDATE) AS REVENUE_DELTA FROM TPCH.CUSTOMER CUSTOMER JOIN "_T" "_T" ON CUSTOMER.c_custkey = "_T".ANYTHING_O_CUSTKEY AND NOT "_T"."_W" IS NULL diff --git a/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql index d0718ad39..2492728a4 100644 --- a/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql +++ b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql @@ -16,7 +16,7 @@ WITH "_T" AS ( ) SELECT CUSTOMER.c_name AS name, - NVL("_S1".SUM_O_TOTALPRICE, 0) AS total_recent_value + COALESCE("_S1".SUM_O_TOTALPRICE, 0) AS total_recent_value FROM TPCH.CUSTOMER CUSTOMER JOIN "_S1" "_S1" ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY diff --git a/tests/test_sql_refsols/datediff_oracle.sql b/tests/test_sql_refsols/datediff_oracle.sql index accf3de8f..08b947083 100644 --- a/tests/test_sql_refsols/datediff_oracle.sql +++ b/tests/test_sql_refsols/datediff_oracle.sql @@ -1,16 +1,26 @@ SELECT sbtxdatetime AS x, - TIME_STR_TO_TIME('2025-05-02 11:00:00') AS y1, - TIME_STR_TO_TIME('2023-04-03 13:16:30') AS y, - DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), YEAR) AS years_diff, - DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), MONTH) AS months_diff, - DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), DAY) AS days_diff, - DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), HOUR) AS hours_diff, - DATEDIFF(TIME_STR_TO_TIME('2023-04-03 13:16:30'), CAST(sbtxdatetime AS DATETIME), MINUTE) AS minutes_diff, - DATEDIFF(TIME_STR_TO_TIME('2023-04-03 13:16:30'), CAST(sbtxdatetime AS DATETIME), SECOND) AS seconds_diff + TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') AS y1, + TO_DATE('2023-04-03 13:16:30', 'YYYY-MM-DD HH24:MI:SS') AS y, + EXTRACT(YEAR FROM TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) AS years_diff, + ( + EXTRACT(YEAR FROM TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) + ) * 12 + ( + EXTRACT(MONTH FROM TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATE)) + ) AS months_diff, + TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') - CAST(sbtxdatetime AS DATE) AS days_diff, + ( + TRUNC(CAST(TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'HH24') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATETIME), 'HH24') + ) * 24 AS hours_diff, + ( + TRUNC(CAST(TO_DATE('2023-04-03 13:16:30', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATETIME), 'MI') + ) * 1440 AS minutes_diff, + ( + TO_DATE('2023-04-03 13:16:30', 'YYYY-MM-DD HH24:MI:SS') - CAST(sbtxdatetime AS DATE) + ) * 86400 AS seconds_diff FROM MAIN.SBTRANSACTION WHERE - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 ORDER BY 4 NULLS FIRST FETCH FIRST 30 ROWS ONLY diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql index 70c2918f3..32c98894b 100644 --- a/tests/test_sql_refsols/datetime_current_oracle.sql +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -1,10 +1,6 @@ SELECT - DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 5, 'MONTH'), 1, DAY) AS d1, - DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 24, 'HOUR') AS d2, - DATE_ADD( - DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 12, 'HOUR'), 150, MINUTE), - 2, - 'SECOND' - ) AS d3 + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(5, 'month') + NUMTODSINTERVAL(1, 'day') AS d1, + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(24, 'hour') AS d2, + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') + NUMTODSINTERVAL(12, 'hour') + NUMTODSINTERVAL(150, 'minute') + NUMTODSINTERVAL(2, 'second') AS d3 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/datetime_functions_oracle.sql b/tests/test_sql_refsols/datetime_functions_oracle.sql index 35065ebf5..a0a6ddc67 100644 --- a/tests/test_sql_refsols/datetime_functions_oracle.sql +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -1,27 +1,48 @@ SELECT - CURRENT_TIMESTAMP AS ts_now_1, - TRUNC(CURRENT_TIMESTAMP, 'DAY') AS ts_now_2, - TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS ts_now_3, - DATE_ADD(CURRENT_TIMESTAMP, 1, 'HOUR') AS ts_now_4, + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS ts_now_1, + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') AS ts_now_2, + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AS ts_now_3, + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(1, 'hour') AS ts_now_4, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS ts_now_5, TO_DATE('1995-10-08', 'YYYY-MM-DD') AS ts_now_6, - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS year_col, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS year_col, 2020 AS year_py, 1995 AS year_pd, - EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) AS month_col, + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) AS month_col, 2 AS month_str, 1 AS month_dt, - EXTRACT(DAY FROM CAST(o_orderdate AS DATETIME)) AS day_col, + EXTRACT(DAY FROM CAST(o_orderdate AS DATE)) AS day_col, 25 AS day_str, 23 AS hour_str, 59 AS minute_str, 59 AS second_ts, - DATEDIFF(CAST('1992-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), DAY) AS dd_col_str, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1992-01-01' AS TIMESTAMP), DAY) AS dd_str_col, - DATEDIFF(CAST(o_orderdate AS DATETIME), TIME_STR_TO_TIME('1995-10-10 00:00:00'), MONTH) AS dd_pd_col, - DATEDIFF(TIME_STR_TO_TIME('1992-01-01 12:30:45'), CAST(o_orderdate AS DATETIME), YEAR) AS dd_col_dt, - DATEDIFF(TIME_STR_TO_TIME('1992-01-01 12:30:45'), CAST('1992-01-01' AS TIMESTAMP), WEEK) AS dd_dt_str, - DAY_OF_WEEK(o_orderdate) AS dow_col, + CAST(CAST('1992-01-01' AS TIMESTAMP) AS DATE) - CAST(o_orderdate AS DATE) AS dd_col_str, + CAST(o_orderdate AS DATE) - CAST(CAST('1992-01-01' AS TIMESTAMP) AS DATE) AS dd_str_col, + ( + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1995-10-10 00:00:00', 'YYYY-MM-DD HH24:MI:SS')) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM TO_DATE('1995-10-10 00:00:00', 'YYYY-MM-DD HH24:MI:SS')) + ) AS dd_pd_col, + EXTRACT(YEAR FROM TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS dd_col_dt, + FLOOR( + ( + TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS') - CAST(CAST('1992-01-01' AS TIMESTAMP) AS DATE) + ( + MOD(( + TO_CHAR('1992-01-01', 'D') + -1 + ), 7) + ) - ( + MOD( + ( + TO_CHAR(TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'D') + -1 + ), + 7 + ) + ) + ) / 7 + ) AS dd_dt_str, + MOD(( + TO_CHAR(o_orderdate, 'D') + -1 + ), 7) AS dow_col, 3 AS dow_str1, 4 AS dow_str2, 5 AS dow_str3, @@ -32,19 +53,19 @@ SELECT 3 AS dow_dt, 2 AS dow_pd, CASE - WHEN DAY_OF_WEEK(o_orderdate) = 0 + WHEN TO_CHAR(o_orderdate, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(o_orderdate) = 1 + WHEN TO_CHAR(o_orderdate, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(o_orderdate) = 2 + WHEN TO_CHAR(o_orderdate, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(o_orderdate) = 3 + WHEN TO_CHAR(o_orderdate, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(o_orderdate) = 4 + WHEN TO_CHAR(o_orderdate, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(o_orderdate) = 5 + WHEN TO_CHAR(o_orderdate, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(o_orderdate) = 6 + WHEN TO_CHAR(o_orderdate, 'D') = 7 THEN 'Saturday' END AS dayname_col, 'Monday' AS dayname_str1, diff --git a/tests/test_sql_refsols/datetime_relative_oracle.sql b/tests/test_sql_refsols/datetime_relative_oracle.sql index 69b0d668d..14080dde6 100644 --- a/tests/test_sql_refsols/datetime_relative_oracle.sql +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -10,22 +10,10 @@ WITH "_T0" AS ( SELECT TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'YEAR') AS d1, TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'MONTH') AS d2, - DATE_ADD( - DATE_SUB( - DATE_ADD( - DATE_SUB(DATE_ADD(DATE_SUB(CAST(O_ORDERDATE AS TIMESTAMP), 11, YEAR), 9, 'MONTH'), 7, DAY), - 5, - 'HOUR' - ), - 3, - MINUTE - ), - 1, - 'SECOND' - ) AS d3, - TIME_STR_TO_TIME('2025-07-04 12:00:00') AS d4, - TIME_STR_TO_TIME('2025-07-04 12:58:00') AS d5, - TIME_STR_TO_TIME('2025-07-26 02:45:25') AS d6 + CAST(O_ORDERDATE AS TIMESTAMP) + NUMTOYMINTERVAL(11, 'year') + NUMTOYMINTERVAL(9, 'month') + NUMTODSINTERVAL(7, 'day') + NUMTODSINTERVAL(5, 'hour') + NUMTODSINTERVAL(3, 'minute') + NUMTODSINTERVAL(1, 'second') AS d3, + TO_DATE('2025-07-04 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS d4, + TO_DATE('2025-07-04 12:58:00', 'YYYY-MM-DD HH24:MI:SS') AS d5, + TO_DATE('2025-07-26 02:45:25', 'YYYY-MM-DD HH24:MI:SS') AS d6 FROM "_T0" ORDER BY O_ORDERDATE NULLS FIRST diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql index 438071438..098e3329b 100644 --- a/tests/test_sql_refsols/datetime_sampler_oracle.sql +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -1,164 +1,176 @@ SELECT - TIME_STR_TO_TIME('2025-07-04 12:58:45') AS "_expr0", - TIME_STR_TO_TIME('2024-12-31 11:59:00') AS "_expr1", + TO_DATE('2025-07-04 12:58:45', 'YYYY-MM-DD HH24:MI:SS') AS "_expr0", + TO_DATE('2024-12-31 11:59:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr1", TO_DATE('2025-01-01', 'YYYY-MM-DD') AS "_expr2", TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr3", - CURRENT_TIMESTAMP AS "_expr4", - CURRENT_TIMESTAMP AS "_expr5", - CURRENT_TIMESTAMP AS "_expr6", - CURRENT_TIMESTAMP AS "_expr7", - CURRENT_TIMESTAMP AS "_expr8", - CURRENT_TIMESTAMP AS "_expr9", - CURRENT_TIMESTAMP AS "_expr10", - CURRENT_TIMESTAMP AS "_expr11", - CURRENT_TIMESTAMP AS "_expr12", - CURRENT_TIMESTAMP AS "_expr13", - CURRENT_TIMESTAMP AS "_expr14", - CURRENT_TIMESTAMP AS "_expr15", - CURRENT_TIMESTAMP AS "_expr16", - CURRENT_TIMESTAMP AS "_expr17", - CURRENT_TIMESTAMP AS "_expr18", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr4", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr5", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr6", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr7", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr8", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr9", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr10", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr11", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr12", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr13", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr14", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr15", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr16", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr17", + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr18", CAST(o_orderdate AS TIMESTAMP) AS "_expr19", - TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND) AS "_expr20", - DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 8, 'MINUTE'), 141, MONTH) AS "_expr21", - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), SECOND), HOUR) AS "_expr22", - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), SECOND), HOUR) AS "_expr23", - DATE_ADD(DATE_SUB(CURRENT_TIMESTAMP, 96, HOUR), 15, 'YEAR') AS "_expr24", - DATE_ADD( - TIMESTAMP_TRUNC(DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 3, YEAR), MINUTE), - 65, - 'MONTH' - ) AS "_expr25", - TRUNC(DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 56, HOUR), 'YEAR') AS "_expr26", - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 63, DAY), MINUTE), SECOND) AS "_expr27", - TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS "_expr28", - DATE_ADD(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 312, HOUR), SECOND), 48, 'YEAR') AS "_expr29", - DATE_SUB( - DATE_ADD(TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 75, 'DAY'), 'DAY'), 600, 'MINUTE'), - 294, - DAY - ) AS "_expr30", - DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 480, 'MONTH'), 45, YEAR) AS "_expr31", + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) AS "_expr20", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTODSINTERVAL(8, 'minute') + NUMTOYMINTERVAL(141, 'month') AS "_expr21", + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), SECOND), HOUR) AS "_expr22", + TIMESTAMP_TRUNC( + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), HOUR), SECOND), + HOUR + ) AS "_expr23", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(96, 'hour') + NUMTOYMINTERVAL(15, 'year') AS "_expr24", + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(3, 'year'), MINUTE) + NUMTOYMINTERVAL(65, 'month') AS "_expr25", + TRUNC(CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(56, 'hour'), 'YEAR') AS "_expr26", TIMESTAMP_TRUNC( - TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 270, MINUTE), 34, SECOND), 'DAY'), + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(63, 'day'), MINUTE), + SECOND + ) AS "_expr27", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AS "_expr28", + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(312, 'hour'), SECOND) + NUMTOYMINTERVAL(48, 'year') AS "_expr29", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(75, 'day'), 'DAY') + NUMTODSINTERVAL(600, 'minute') + NUMTODSINTERVAL(294, 'day') AS "_expr30", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(480, 'month') + NUMTOYMINTERVAL(45, 'year') AS "_expr31", + TIMESTAMP_TRUNC( + TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(270, 'minute') + NUMTODSINTERVAL(34, 'second'), + 'DAY' + ), SECOND ) AS "_expr32", - DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 213, 'SECOND') AS "_expr33", - DATE_ADD( - DATE_ADD(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 13, 'MINUTE'), 28, 'YEAR'), - 344, - 'SECOND' - ) AS "_expr34", - TRUNC(CURRENT_TIMESTAMP, 'DAY') AS "_expr35", - TIME_STR_TO_TIME('2116-01-01 00:49:00') AS "_expr36", - TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 'DAY') AS "_expr37", - TRUNC(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 'YEAR') AS "_expr38", - TIME_STR_TO_TIME('2025-07-01 00:22:00') AS "_expr39", - TRUNC(CURRENT_TIMESTAMP, 'YEAR') AS "_expr40", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(213, 'second') AS "_expr33", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(13, 'minute') + NUMTOYMINTERVAL(28, 'year') + NUMTODSINTERVAL(344, 'second') AS "_expr34", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') AS "_expr35", + TO_DATE('2116-01-01 00:49:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr36", + TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), 'DAY') AS "_expr37", + TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY'), 'YEAR') AS "_expr38", + TO_DATE('2025-07-01 00:22:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr39", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') AS "_expr40", TRUNC( - DATE_SUB( - DATE_ADD(DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 82, 'SECOND'), 415, 'SECOND'), - 160, - SECOND - ), + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(82, 'second') + NUMTODSINTERVAL(415, 'second') + NUMTODSINTERVAL(160, 'second'), 'YEAR' ) AS "_expr41", - DATE_ADD(CURRENT_TIMESTAMP, 192, 'MONTH') AS "_expr42", - DATE_ADD( - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), MINUTE), HOUR), - 486, - 'MINUTE' - ) AS "_expr43", - DATE_SUB(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND), 50, HOUR) AS "_expr44", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(192, 'month') AS "_expr42", + TIMESTAMP_TRUNC( + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), HOUR), MINUTE), + HOUR + ) + NUMTODSINTERVAL(486, 'minute') AS "_expr43", + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) + NUMTODSINTERVAL(50, 'hour') AS "_expr44", TIMESTAMP_TRUNC( - DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 297, 'DAY'), 72, 'MONTH'), 92, MONTH), + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day') + NUMTOYMINTERVAL(72, 'month') + NUMTOYMINTERVAL(92, 'month'), HOUR ) AS "_expr45", - TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 285, 'SECOND'), 'DAY') AS "_expr46", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(285, 'second'), 'DAY') AS "_expr46", TO_DATE('1999-05-15', 'YYYY-MM-DD') AS "_expr47", - DATE_SUB(TRUNC(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 1, 'HOUR'), 'MONTH'), 21, DAY) AS "_expr48", - DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 212, 'MINUTE'), 368, 'YEAR') AS "_expr49", + TRUNC( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(1, 'hour'), + 'MONTH' + ) + NUMTODSINTERVAL(21, 'day') AS "_expr48", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(212, 'minute') + NUMTOYMINTERVAL(368, 'year') AS "_expr49", TO_DATE('2024-01-01', 'YYYY-MM-DD') AS "_expr50", TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr51", - DATE_ADD( - TIMESTAMP_TRUNC(TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 60, HOUR), 'DAY'), MINUTE), - 196, - 'YEAR' - ) AS "_expr52", - DATE_ADD( - TIMESTAMP_TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 40, HOUR), 385, DAY), MINUTE), - 29, - 'HOUR' - ) AS "_expr53", - TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 405, 'DAY'), HOUR), MINUTE) AS "_expr54", - DATE_ADD( - DATE_ADD(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), SECOND), 98, 'YEAR'), - 96, - 'MONTH' - ) AS "_expr55", - DATE_ADD( - TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, MINUTE), SECOND), 'DAY'), - 78, - 'SECOND' - ) AS "_expr56", - DATE_ADD( - DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 136, 'HOUR'), 104, 'MINUTE'), 104, MONTH), - 312, + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(60, 'hour'), 'DAY'), MINUTE) + NUMTOYMINTERVAL(196, 'year') AS "_expr52", + TIMESTAMP_TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(40, 'hour') + NUMTODSINTERVAL(385, 'day'), + MINUTE + ) + NUMTODSINTERVAL(29, 'hour') AS "_expr53", + TIMESTAMP_TRUNC( + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(405, 'day'), HOUR), + MINUTE + ) AS "_expr54", + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), SECOND) + NUMTOYMINTERVAL(98, 'year') + NUMTOYMINTERVAL(96, 'month') AS "_expr55", + TRUNC( + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), MINUTE), SECOND), 'DAY' - ) AS "_expr57", - DATE_SUB(DATE_ADD(CURRENT_TIMESTAMP, 45, 'MONTH'), 135, SECOND) AS "_expr58", - EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS "_expr59", + ) + NUMTODSINTERVAL(78, 'second') AS "_expr56", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(136, 'hour') + NUMTODSINTERVAL(104, 'minute') + NUMTOYMINTERVAL(104, 'month') + NUMTODSINTERVAL(312, 'day') AS "_expr57", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(45, 'month') + NUMTODSINTERVAL(135, 'second') AS "_expr58", + EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr59", 2025 AS "_expr60", 1999 AS "_expr61", - EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS "_expr62", + EXTRACT(MONTH FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr62", 6 AS "_expr63", 3 AS "_expr64", - EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS "_expr65", + EXTRACT(DAY FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr65", 4 AS "_expr66", 4 AS "_expr67", - EXTRACT(HOUR FROM CURRENT_TIMESTAMP) AS "_expr68", + EXTRACT(HOUR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS TIMESTAMP)) AS "_expr68", 0 AS "_expr69", 0 AS "_expr70", - EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS "_expr71", + EXTRACT(MINUTE FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS TIMESTAMP)) AS "_expr71", 30 AS "_expr72", 0 AS "_expr73", - EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS "_expr74", + EXTRACT(SECOND FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS TIMESTAMP)) AS "_expr74", 45 AS "_expr75", 0 AS "_expr76", - DATEDIFF(CURRENT_TIMESTAMP, CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS "_expr77", - DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), CAST(o_orderdate AS DATETIME), YEAR) AS "_expr78", - DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MONTH) AS "_expr79", - DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), TIME_STR_TO_TIME('2006-05-01 12:00:00'), MONTH) AS "_expr80", - DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, DAY) AS "_expr81", - DATEDIFF(CURRENT_TIMESTAMP, CAST('1999-03-14' AS TIMESTAMP), DAY) AS "_expr82", - DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, HOUR) AS "_expr83", - DATEDIFF(CAST(o_orderdate AS DATETIME), TO_DATE('2005-06-30', 'YYYY-MM-DD'), HOUR) AS "_expr84", - DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CURRENT_TIMESTAMP, MINUTE) AS "_expr85", - DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), CAST(o_orderdate AS DATETIME), MINUTE) AS "_expr86", - DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS "_expr87", - DATEDIFF( - CAST('2018-02-14 12:41:06' AS TIMESTAMP), - TO_DATE('2005-06-30', 'YYYY-MM-DD'), - SECOND - ) AS "_expr88", - DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CAST(o_orderdate AS DATETIME), YEAR) AS "_expr89", - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS "_expr90", - DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), CAST(o_orderdate AS DATETIME), MONTH) AS "_expr91", - DATEDIFF( - CAST('2018-02-14 12:41:06' AS TIMESTAMP), - TIME_STR_TO_TIME('2019-07-04 11:30:00'), - MONTH + EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) AS "_expr77", + EXTRACT(YEAR FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS "_expr78", + ( + EXTRACT(YEAR FROM CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) + ) AS "_expr79", + ( + EXTRACT(YEAR FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) + ) * 12 + ( + EXTRACT(MONTH FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(MONTH FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) + ) AS "_expr80", + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS "_expr81", + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE) AS "_expr82", + ( + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'HH24') + ) * 24 AS "_expr83", + ( + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATETIME), 'HH24') + ) * 24 AS "_expr84", + ( + TRUNC(CAST(TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'MI') + ) * 1440 AS "_expr85", + ( + TRUNC(CAST(TO_DATE('2021-01-01 07:35:00', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'MI') + ) * 1440 AS "_expr86", + ( + TO_DATE('2021-01-01 07:35:00', 'YYYY-MM-DD HH24:MI:SS') - TO_DATE('2022-11-24', 'YYYY-MM-DD') + ) * 86400 AS "_expr87", + ( + CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE) - TO_DATE('2005-06-30', 'YYYY-MM-DD') + ) * 86400 AS "_expr88", + EXTRACT(YEAR FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS "_expr89", + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) AS "_expr90", + ( + EXTRACT(YEAR FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) + ) * 12 + ( + EXTRACT(MONTH FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) + ) AS "_expr91", + ( + EXTRACT(YEAR FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) ) AS "_expr92", - DATEDIFF(CAST(o_orderdate AS DATETIME), CURRENT_TIMESTAMP, DAY) AS "_expr93", - DATEDIFF(CURRENT_TIMESTAMP, TIME_STR_TO_TIME('2019-07-04 11:30:00'), DAY) AS "_expr94", - DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2022-11-24', 'YYYY-MM-DD'), HOUR) AS "_expr95", - DATEDIFF( - TIME_STR_TO_TIME('2020-12-31 00:31:06'), - CAST('2018-02-14 12:41:06' AS TIMESTAMP), - HOUR - ) AS "_expr96", - DATEDIFF(TIME_STR_TO_TIME('2020-12-31 00:31:06'), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MINUTE) AS "_expr97", - DATEDIFF(CAST('2018-02-14 12:41:06' AS TIMESTAMP), CURRENT_TIMESTAMP, MINUTE) AS "_expr98", - DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), CURRENT_TIMESTAMP, SECOND) AS "_expr99", - DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS "_expr100" + CAST(o_orderdate AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS "_expr93", + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr94", + ( + TRUNC(CAST(CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(TO_DATE('2022-11-24', 'YYYY-MM-DD') AS DATETIME), 'HH24') + ) * 24 AS "_expr95", + ( + TRUNC(CAST(TO_DATE('2020-12-31 00:31:06', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'HH24') - TRUNC(CAST(CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE) AS DATETIME), 'HH24') + ) * 24 AS "_expr96", + ( + TRUNC(CAST(TO_DATE('2020-12-31 00:31:06', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATETIME), 'MI') + ) * 1440 AS "_expr97", + ( + TRUNC(CAST(CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE) AS DATETIME), 'MI') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'MI') + ) * 1440 AS "_expr98", + ( + CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) + ) * 86400 AS "_expr99", + ( + TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS') - TO_DATE('2022-11-24', 'YYYY-MM-DD') + ) * 86400 AS "_expr100" FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/defog_academic_gen13_oracle.sql b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql index 57918f9b6..48de0e7eb 100644 --- a/tests/test_sql_refsols/defog_academic_gen13_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql @@ -15,7 +15,7 @@ WITH "_S1" AS ( ) SELECT DOMAIN.did AS domain_id, - NVL("_S1".N_ROWS, 0) / NULLIF("_S3".N_ROWS, 0) AS ratio + COALESCE("_S1".N_ROWS, 0) / NULLIF("_S3".N_ROWS, 0) AS ratio FROM MAIN.DOMAIN DOMAIN LEFT JOIN "_S1" "_S1" ON DOMAIN.did = "_S1".DID diff --git a/tests/test_sql_refsols/defog_academic_gen15_oracle.sql b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql index 70ce5a3eb..0f021fc85 100644 --- a/tests/test_sql_refsols/defog_academic_gen15_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql @@ -10,7 +10,7 @@ WITH "_T1" AS ( ) SELECT ANYTHING_CONTINENT AS continent, - NVL(SUM(COUNT_OID), 0) / COUNT(*) AS ratio + COALESCE(SUM(COUNT_OID), 0) / COUNT(*) AS ratio FROM "_T1" GROUP BY ANYTHING_CONTINENT diff --git a/tests/test_sql_refsols/defog_academic_gen17_oracle.sql b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql index f6638bd62..cb493537e 100644 --- a/tests/test_sql_refsols/defog_academic_gen17_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql @@ -1,6 +1,6 @@ SELECT ANY_VALUE(CONFERENCE.name) AS name, - NVL(NULLIF(COUNT(PUBLICATION.cid), 0), 0) AS count_publications + COUNT(PUBLICATION.cid) AS count_publications FROM MAIN.CONFERENCE CONFERENCE LEFT JOIN MAIN.PUBLICATION PUBLICATION ON CONFERENCE.cid = PUBLICATION.cid diff --git a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql index d88251faf..1e29049ab 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql @@ -9,7 +9,7 @@ WITH "_S1" AS ( SELECT JOURNAL.name, JOURNAL.jid AS journal_id, - NVL("_S1".N_ROWS, 0) AS num_publications + COALESCE("_S1".N_ROWS, 0) AS num_publications FROM MAIN.JOURNAL JOURNAL LEFT JOIN "_S1" "_S1" ON JOURNAL.jid = "_S1".JID diff --git a/tests/test_sql_refsols/defog_academic_gen19_oracle.sql b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql index e6dc99683..3fd973bf0 100644 --- a/tests/test_sql_refsols/defog_academic_gen19_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql @@ -1,6 +1,6 @@ SELECT ANY_VALUE(CONFERENCE.name) AS name, - NVL(NULLIF(COUNT(PUBLICATION.cid), 0), 0) AS num_publications + COUNT(PUBLICATION.cid) AS num_publications FROM MAIN.CONFERENCE CONFERENCE LEFT JOIN MAIN.PUBLICATION PUBLICATION ON CONFERENCE.cid = PUBLICATION.cid diff --git a/tests/test_sql_refsols/defog_academic_gen2_oracle.sql b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql index 4c017f8c4..1d51cb6b7 100644 --- a/tests/test_sql_refsols/defog_academic_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql @@ -10,7 +10,7 @@ WITH "_S3" AS ( ) SELECT AUTHOR.name, - NVL("_S3".SUM_CITATION_NUM, 0) AS total_citations + COALESCE("_S3".SUM_CITATION_NUM, 0) AS total_citations FROM MAIN.AUTHOR AUTHOR JOIN "_S3" "_S3" ON AUTHOR.aid = "_S3".AID diff --git a/tests/test_sql_refsols/defog_academic_gen7_oracle.sql b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql index 1bc5f4996..2d0bbbfbe 100644 --- a/tests/test_sql_refsols/defog_academic_gen7_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql @@ -8,7 +8,7 @@ WITH "_S1" AS ( ) SELECT DOMAIN.name, - NVL("_S1".NDISTINCT_AID, 0) AS author_count + COALESCE("_S1".NDISTINCT_AID, 0) AS author_count FROM MAIN.DOMAIN DOMAIN LEFT JOIN "_S1" "_S1" ON DOMAIN.did = "_S1".DID diff --git a/tests/test_sql_refsols/defog_broker_adv10_oracle.sql b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql index 035e32558..edd7075c6 100644 --- a/tests/test_sql_refsols/defog_broker_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql @@ -1,24 +1,24 @@ WITH "_S1" AS ( SELECT - EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) AS MONTH_SBTXDATETIME, - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) AS YEAR_SBTXDATETIME, + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATE)) AS MONTH_SBTXDATETIME, + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) AS YEAR_SBTXDATETIME, sbtxcustid AS SBTXCUSTID, COUNT(*) AS N_ROWS FROM MAIN.SBTRANSACTION GROUP BY - EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)), - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)), + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATE)), + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)), sbtxcustid ) SELECT SBCUSTOMER.sbcustid AS "_id", SBCUSTOMER.sbcustname AS name, - NVL("_S1".N_ROWS, 0) AS num_transactions + COALESCE("_S1".N_ROWS, 0) AS num_transactions FROM MAIN.SBCUSTOMER SBCUSTOMER LEFT JOIN "_S1" "_S1" ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID - AND "_S1".MONTH_SBTXDATETIME = EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) - AND "_S1".YEAR_SBTXDATETIME = EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) + AND "_S1".MONTH_SBTXDATETIME = EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)) + AND "_S1".YEAR_SBTXDATETIME = EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)) ORDER BY 3 DESC NULLS LAST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql index 85fd51da5..3f31b2044 100644 --- a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql @@ -5,7 +5,9 @@ WITH "_S1" AS ( SUM(sbdpclose) AS SUM_SBDPCLOSE FROM MAIN.SBDAILYPRICE WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(sbdpdate AS DATETIME), DAY) <= 7 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sbdpdate AS DATE) + ) <= 7 GROUP BY sbdptickerid ) diff --git a/tests/test_sql_refsols/defog_broker_adv15_oracle.sql b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql index e1cebfb27..6dc913b6b 100644 --- a/tests/test_sql_refsols/defog_broker_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql @@ -1,7 +1,7 @@ SELECT sbcustcountry AS country, 100 * ( - NVL(SUM(sbcuststatus = 'active'), 0) / COUNT(*) + COALESCE(SUM(sbcuststatus = 'active'), 0) / COUNT(*) ) AS ar FROM MAIN.SBCUSTOMER WHERE diff --git a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql index 7498070df..1ed9f9be2 100644 --- a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -5,7 +5,10 @@ WITH "_S1" AS ( SUM(sbtxamount) AS SUM_SBTXAMOUNT FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH) AND sbtxtype = 'sell' + sbtxdatetime >= ( + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(1, 'month') + ) + AND sbtxtype = 'sell' GROUP BY sbtxtickerid ) @@ -13,9 +16,9 @@ SELECT SBTICKER.sbtickersymbol AS symbol, ( 100.0 * ( - NVL("_S1".SUM_SBTXAMOUNT, 0) - NVL("_S1".SUM_EXPR, 0) + COALESCE("_S1".SUM_SBTXAMOUNT, 0) - COALESCE("_S1".SUM_EXPR, 0) ) - ) / NVL("_S1".SUM_SBTXAMOUNT, 0) AS SPM + ) / NULLIF("_S1".SUM_SBTXAMOUNT, 0) AS SPM FROM MAIN.SBTICKER SBTICKER JOIN "_S1" "_S1" ON SBTICKER.sbtickerid = "_S1".SBTXTICKERID diff --git a/tests/test_sql_refsols/defog_broker_adv1_oracle.sql b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql index f63422da4..73659f88e 100644 --- a/tests/test_sql_refsols/defog_broker_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql @@ -8,7 +8,7 @@ WITH "_S1" AS ( ) SELECT SBCUSTOMER.sbcustname AS name, - NVL("_S1".SUM_SBTXAMOUNT, 0) AS total_amount + COALESCE("_S1".SUM_SBTXAMOUNT, 0) AS total_amount FROM MAIN.SBCUSTOMER SBCUSTOMER LEFT JOIN "_S1" "_S1" ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql index bdc8b2673..a80790898 100644 --- a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql @@ -4,14 +4,14 @@ WITH "_S1" AS ( COUNT(*) AS N_ROWS FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 10, DAY), 'DAY') + sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(10, 'day'), 'DAY') AND sbtxtype = 'buy' GROUP BY sbtxtickerid ) SELECT SBTICKER.sbtickersymbol AS symbol, - NVL("_S1".N_ROWS, 0) AS tx_count + COALESCE("_S1".N_ROWS, 0) AS tx_count FROM MAIN.SBTICKER SBTICKER LEFT JOIN "_S1" "_S1" ON SBTICKER.sbtickerid = "_S1".SBTXTICKERID diff --git a/tests/test_sql_refsols/defog_broker_adv3_oracle.sql b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql index bc734142c..9d6861271 100644 --- a/tests/test_sql_refsols/defog_broker_adv3_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql @@ -10,7 +10,7 @@ WITH "_T1" AS ( SELECT SBCUSTOMER.sbcustname AS name, ( - 100.0 * NVL("_T1".SUM_EXPR, 0) + 100.0 * COALESCE("_T1".SUM_EXPR, 0) ) / "_T1".N_ROWS AS success_rate FROM MAIN.SBCUSTOMER SBCUSTOMER JOIN "_T1" "_T1" diff --git a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql index dc54073de..6ab536d5f 100644 --- a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql @@ -1,15 +1,28 @@ WITH "_S0" AS ( SELECT - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(sbdpdate AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))), ( - 2 * -1 - )) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( + 2 * -1 + )) + END, + NULL + ), + '-' ) AS MONTH, sbdptickerid AS SBDPTICKERID, COUNT(sbdpclose) AS COUNT_SBDPCLOSE, @@ -18,16 +31,29 @@ WITH "_S0" AS ( SUM(sbdpclose) AS SUM_SBDPCLOSE FROM MAIN.SBDAILYPRICE GROUP BY - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(sbdpdate AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))), ( - 2 * -1 - )) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( + 2 * -1 + )) + END, + NULL + ), + '-' ), sbdptickerid ), "_T0" AS ( @@ -55,5 +81,8 @@ SELECT ( SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE ) - LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) - ) / LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) AS momc + ) / NULLIF( + LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH), + 0 + ) AS momc FROM "_T0" diff --git a/tests/test_sql_refsols/defog_broker_adv6_oracle.sql b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql index a1ed99779..688af7536 100644 --- a/tests/test_sql_refsols/defog_broker_adv6_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql @@ -10,8 +10,8 @@ WITH "_S1" AS ( SELECT SBCUSTOMER.sbcustname AS name, "_S1".N_ROWS AS num_tx, - NVL("_S1".SUM_SBTXAMOUNT, 0) AS total_amount, - RANK() OVER (ORDER BY NVL("_S1".SUM_SBTXAMOUNT, 0) DESC) AS cust_rank + COALESCE("_S1".SUM_SBTXAMOUNT, 0) AS total_amount, + RANK() OVER (ORDER BY COALESCE("_S1".SUM_SBTXAMOUNT, 0) DESC) AS cust_rank FROM MAIN.SBCUSTOMER SBCUSTOMER JOIN "_S1" "_S1" ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql index fd522b87f..a9dc4d785 100644 --- a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -1,72 +1,130 @@ WITH "_S2" AS ( SELECT - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))), ( - 2 * -1 - )) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( + 2 * -1 + )) + END, + NULL + ), + '-' ) AS MONTH, COUNT(*) AS N_ROWS FROM MAIN.SBCUSTOMER WHERE - sbcustjoindate < TRUNC(CURRENT_TIMESTAMP, 'MONTH') - AND sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'MONTH') + sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'MONTH') GROUP BY - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))), ( - 2 * -1 - )) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( + 2 * -1 + )) + END, + NULL + ), + '-' ) ), "_S3" AS ( SELECT - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))), - ( - 2 * -1 + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), + ( + 2 * -1 + ) + ) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), + ( + 2 * -1 + ) ) - ) - END + END, + NULL + ), + '-' ) AS MONTH, AVG(SBTRANSACTION.sbtxamount) AS AVG_SBTXAMOUNT FROM MAIN.SBCUSTOMER SBCUSTOMER JOIN MAIN.SBTRANSACTION SBTRANSACTION - ON EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) = EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) - AND EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) = EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) + ON EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)) = EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) + AND EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)) = EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid WHERE - SBCUSTOMER.sbcustjoindate < TRUNC(CURRENT_TIMESTAMP, 'MONTH') - AND SBCUSTOMER.sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'MONTH') + SBCUSTOMER.sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'MONTH') GROUP BY - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))), - ( - 2 * -1 + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), + ( + 2 * -1 + ) + ) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), + ( + 2 * -1 + ) ) - ) - END + END, + NULL + ), + '-' ) ) SELECT diff --git a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql index a124a5926..0f4a3a16e 100644 --- a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql @@ -1,10 +1,12 @@ SELECT NULLIF(COUNT(*), 0) AS n_transactions, - NVL(SUM(SBTRANSACTION.sbtxamount), 0) AS total_amount + COALESCE(SUM(SBTRANSACTION.sbtxamount), 0) AS total_amount FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBCUSTOMER SBCUSTOMER ON LOWER(SBCUSTOMER.sbcustcountry) = 'usa' AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid WHERE - SBTRANSACTION.sbtxdatetime < TRUNC(CURRENT_TIMESTAMP, 'WEEK') - AND SBTRANSACTION.sbtxdatetime >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 1, WEEK) + SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + AND SBTRANSACTION.sbtxdatetime >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NUMTODSINTERVAL(1, 'week') + ) diff --git a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql index f1247db1e..2049353ec 100644 --- a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql @@ -1,10 +1,10 @@ SELECT TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') AS week, COUNT(*) AS num_transactions, - NVL( + COALESCE( SUM(( MOD(( - DAY_OF_WEEK(SBTRANSACTION.sbtxdatetime) + 6 + TO_CHAR(SBTRANSACTION.sbtxdatetime, 'D') + 5 ), 7) ) IN (5, 6)), 0 @@ -14,7 +14,9 @@ JOIN MAIN.SBTICKER SBTICKER ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid AND SBTICKER.sbtickertype = 'stock' WHERE - SBTRANSACTION.sbtxdatetime < TRUNC(CURRENT_TIMESTAMP, 'WEEK') - AND SBTRANSACTION.sbtxdatetime >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 8, WEEK) + SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + AND SBTRANSACTION.sbtxdatetime >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NUMTODSINTERVAL(8, 'week') + ) GROUP BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql index 9e5c7998b..d49913b9b 100644 --- a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql @@ -5,14 +5,14 @@ WITH "_S1" AS ( SUM(sbtxamount) AS SUM_SBTXAMOUNT FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 30, DAY), 'DAY') + sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(30, 'day'), 'DAY') GROUP BY sbtxcustid ) SELECT SBCUSTOMER.sbcustcountry AS country, - NVL(SUM("_S1".N_ROWS), 0) AS num_transactions, - NVL(SUM("_S1".SUM_SBTXAMOUNT), 0) AS total_amount + COALESCE(SUM("_S1".N_ROWS), 0) AS num_transactions, + COALESCE(SUM("_S1".SUM_SBTXAMOUNT), 0) AS total_amount FROM MAIN.SBCUSTOMER SBCUSTOMER LEFT JOIN "_S1" "_S1" ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_basic3_oracle.sql b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql index 8090f7ace..1ea7dea87 100644 --- a/tests/test_sql_refsols/defog_broker_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql @@ -9,8 +9,8 @@ WITH "_S1" AS ( ) SELECT SBTICKER.sbtickersymbol AS symbol, - NVL("_S1".N_ROWS, 0) AS num_transactions, - NVL("_S1".SUM_SBTXAMOUNT, 0) AS total_amount + COALESCE("_S1".N_ROWS, 0) AS num_transactions, + COALESCE("_S1".SUM_SBTXAMOUNT, 0) AS total_amount FROM MAIN.SBTICKER SBTICKER LEFT JOIN "_S1" "_S1" ON SBTICKER.sbtickerid = "_S1".SBTXTICKERID diff --git a/tests/test_sql_refsols/defog_broker_gen1_oracle.sql b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql index fc5ae4c8e..2de3ccc0b 100644 --- a/tests/test_sql_refsols/defog_broker_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql @@ -5,4 +5,6 @@ JOIN MAIN.SBTICKER SBTICKER ON SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid AND SBTICKER.sbtickersymbol = 'VTI' WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(SBDAILYPRICE.sbdpdate AS DATETIME), DAY) <= 7 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(SBDAILYPRICE.sbdpdate AS DATE) + ) <= 7 diff --git a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql index b2e6fa910..0876ce6ff 100644 --- a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql @@ -3,4 +3,4 @@ SELECT FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid - AND SBCUSTOMER.sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 70, DAY), 'DAY') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(70, 'day'), 'DAY') diff --git a/tests/test_sql_refsols/defog_broker_gen3_oracle.sql b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql index 293d545ec..f9e3d8d2d 100644 --- a/tests/test_sql_refsols/defog_broker_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql @@ -8,10 +8,10 @@ WITH "_S1" AS ( ) SELECT SBCUSTOMER.sbcustid AS cust_id, - DATEDIFF( - CAST("_S1".MIN_SBTXDATETIME AS DATETIME), - CAST(SBCUSTOMER.sbcustjoindate AS DATETIME), - SECOND + ( + ( + CAST("_S1".MIN_SBTXDATETIME AS DATE) - CAST(SBCUSTOMER.sbcustjoindate AS DATE) + ) * 86400 ) / 86400.0 AS DaysFromJoinToFirstTransaction FROM MAIN.SBCUSTOMER SBCUSTOMER JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql index 79a50e2cc..ed7e840e7 100644 --- a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql @@ -12,7 +12,7 @@ WITH "_S1" AS ( SELECT SBCUSTOMER.sbcustid AS "_id", SBCUSTOMER.sbcustname AS name, - NVL("_S1".N_ROWS, 0) AS num_tx + COALESCE("_S1".N_ROWS, 0) AS num_tx FROM MAIN.SBCUSTOMER SBCUSTOMER LEFT JOIN "_S1" "_S1" ON SBCUSTOMER.sbcustid = "_S1".SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_gen5_oracle.sql b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql index 59c8567b5..733ffa193 100644 --- a/tests/test_sql_refsols/defog_broker_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql @@ -3,8 +3,8 @@ SELECT AVG(sbtxprice) AS avg_price FROM MAIN.SBTRANSACTION WHERE - EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) IN (1, 2, 3) - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATE)) IN (1, 2, 3) + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 AND sbtxstatus = 'success' GROUP BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') diff --git a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql index f7fe19653..c57110582 100644 --- a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql @@ -7,12 +7,7 @@ WITH "_S1" AS ( sale_id ) SELECT - ROUND( - AVG( - DATEDIFF(CAST("_S1".MAX_PAYMENT_DATE AS DATETIME), CAST(SALES.sale_date AS DATETIME), DAY) - ), - 2 - ) AS avg_days_to_payment + ROUND(AVG(CAST("_S1".MAX_PAYMENT_DATE AS DATE) - CAST(SALES.sale_date AS DATE)), 2) AS avg_days_to_payment FROM MAIN.SALES SALES LEFT JOIN "_S1" "_S1" ON SALES."_id" = "_S1".SALE_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql index 06b7ee277..754884217 100644 --- a/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql @@ -4,15 +4,15 @@ WITH "_S0" AS ( SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE - EXTRACT(YEAR FROM CAST(sale_date AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(sale_date AS DATE)) = 2023 GROUP BY car_id ) SELECT ( ( - NVL(SUM("_S0".SUM_SALE_PRICE), 0) - NVL(SUM(CARS.cost), 0) - ) / NVL(SUM(CARS.cost), 0) + COALESCE(SUM("_S0".SUM_SALE_PRICE), 0) - COALESCE(SUM(CARS.cost), 0) + ) / NULLIF(SUM(CARS.cost), 0) ) * 100 AS GPM FROM "_S0" "_S0" JOIN MAIN.CARS CARS diff --git a/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql index 35e025121..dc90bc6d2 100644 --- a/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql @@ -2,4 +2,6 @@ SELECT COUNT(*) AS TSC FROM MAIN.SALES WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 7 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sale_date AS DATE) + ) <= 7 diff --git a/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql index a69868e97..ddbb439ad 100644 --- a/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql @@ -10,7 +10,7 @@ SELECT SALESPERSONS."_id", SALESPERSONS.first_name, SALESPERSONS.last_name, - NVL("_S1".SUM_SALE_PRICE, 0) AS total + COALESCE("_S1".SUM_SALE_PRICE, 0) AS total FROM MAIN.SALESPERSONS SALESPERSONS LEFT JOIN "_S1" "_S1" ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql index 0fdd8ba92..6853f2b14 100644 --- a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -1,11 +1,11 @@ SELECT TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') AS payment_week, COUNT(*) AS total_payments, - NVL( + COALESCE( SUM( ( MOD(( - DAY_OF_WEEK(PAYMENTS_RECEIVED.payment_date) + 6 + TO_CHAR(PAYMENTS_RECEIVED.payment_date, 'D') + 5 ), 7) ) IN (5, 6) ), @@ -15,7 +15,31 @@ FROM MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED JOIN MAIN.SALES SALES ON PAYMENTS_RECEIVED.sale_id = SALES."_id" AND SALES.sale_price > 30000 WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) <= 8 - AND DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) >= 1 + FLOOR( + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(PAYMENTS_RECEIVED.payment_date AS DATE) + ( + MOD(( + TO_CHAR(PAYMENTS_RECEIVED.payment_date, 'D') + 5 + ), 7) + ) - ( + MOD(( + TO_CHAR('now', 'D') + 5 + ), 7) + ) + ) / 7 + ) <= 8 + AND FLOOR( + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(PAYMENTS_RECEIVED.payment_date AS DATE) + ( + MOD(( + TO_CHAR(PAYMENTS_RECEIVED.payment_date, 'D') + 5 + ), 7) + ) - ( + MOD(( + TO_CHAR('now', 'D') + 5 + ), 7) + ) + ) / 7 + ) >= 1 GROUP BY TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql index ca3968375..a81c23992 100644 --- a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql @@ -4,7 +4,9 @@ WITH "_S1" AS ( COUNT(*) AS N_ROWS FROM MAIN.SALES WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 30 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sale_date AS DATE) + ) <= 30 GROUP BY salesperson_id ) diff --git a/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql index 3c3d69671..f7886bed4 100644 --- a/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql @@ -14,7 +14,7 @@ WITH "_T1" AS ( SELECT ANYTHING_MAKE AS make, ANYTHING_MODEL AS model, - NVL(SUM(COUNT_CAR_ID), 0) AS num_sales + COALESCE(SUM(COUNT_CAR_ID), 0) AS num_sales FROM "_T1" GROUP BY ANYTHING_MAKE, diff --git a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql index a0cc8da10..7ff083df9 100644 --- a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql @@ -1,9 +1,11 @@ SELECT COUNT(*) AS num_sales, - CASE WHEN COUNT(*) <> 0 THEN NVL(SUM(SALES.sale_price), 0) ELSE NULL END AS total_revenue + CASE WHEN COUNT(*) <> 0 THEN COALESCE(SUM(SALES.sale_price), 0) ELSE NULL END AS total_revenue FROM MAIN.CARS CARS JOIN MAIN.SALES SALES ON CARS."_id" = SALES.car_id - AND SALES.sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 30, DAY) + AND SALES.sale_date >= ( + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(30, 'day') + ) WHERE LOWER(CARS.make) LIKE '%toyota%' diff --git a/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql index b9d1e038f..387400d35 100644 --- a/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql @@ -10,9 +10,9 @@ WITH "_S1" AS ( SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, - NVL("_S1".SUM_SALE_PRICE, 0) AS total_sales, + COALESCE("_S1".SUM_SALE_PRICE, 0) AS total_sales, "_S1".N_ROWS AS num_sales, - RANK() OVER (ORDER BY NVL("_S1".SUM_SALE_PRICE, 0) DESC) AS sales_rank + RANK() OVER (ORDER BY COALESCE("_S1".SUM_SALE_PRICE, 0) DESC) AS sales_rank FROM MAIN.SALESPERSONS SALESPERSONS JOIN "_S1" "_S1" ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID diff --git a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql index cbb2cf067..38ca04e29 100644 --- a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql @@ -5,15 +5,17 @@ WITH "_S1" AS ( SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE - sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 3, MONTH) + sale_date >= ( + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(3, 'month') + ) GROUP BY salesperson_id ) SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, - NVL("_S1".N_ROWS, 0) AS total_sales, - NVL("_S1".SUM_SALE_PRICE, 0) AS total_revenue + COALESCE("_S1".N_ROWS, 0) AS total_sales, + COALESCE("_S1".SUM_SALE_PRICE, 0) AS total_revenue FROM MAIN.SALESPERSONS SALESPERSONS LEFT JOIN "_S1" "_S1" ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID diff --git a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql index ee0568d30..861ab780b 100644 --- a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql @@ -5,7 +5,9 @@ WITH "_S1" AS ( SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 30 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sale_date AS DATE) + ) <= 30 GROUP BY salesperson_id ) @@ -13,7 +15,7 @@ SELECT SALESPERSONS.first_name, SALESPERSONS.last_name, "_S1".N_ROWS AS total_sales, - NVL("_S1".SUM_SALE_PRICE, 0) AS total_revenue + COALESCE("_S1".SUM_SALE_PRICE, 0) AS total_revenue FROM MAIN.SALESPERSONS SALESPERSONS JOIN "_S1" "_S1" ON SALESPERSONS."_id" = "_S1".SALESPERSON_ID diff --git a/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql index b8c6b0d39..e571e96ca 100644 --- a/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql @@ -1,7 +1,7 @@ SELECT CUSTOMERS.state, COUNT(DISTINCT SALES.customer_id) AS unique_customers, - NVL(SUM(SALES.sale_price), 0) AS total_revenue + COALESCE(SUM(SALES.sale_price), 0) AS total_revenue FROM MAIN.SALES SALES JOIN MAIN.CUSTOMERS CUSTOMERS ON CUSTOMERS."_id" = SALES.customer_id diff --git a/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql index fa57bcc72..9bb734c78 100644 --- a/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql @@ -1,7 +1,7 @@ SELECT payment_method, COUNT(*) AS total_payments, - NVL(SUM(payment_amount), 0) AS total_amount + COALESCE(SUM(payment_amount), 0) AS total_amount FROM MAIN.PAYMENTS_RECEIVED GROUP BY payment_method diff --git a/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql index b7e04e9a6..5d99b226b 100644 --- a/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql @@ -10,8 +10,8 @@ WITH "_S1" AS ( SELECT CARS.make, CARS.model, - NVL("_S1".N_ROWS, 0) AS total_sales, - NVL("_S1".SUM_SALE_PRICE, 0) AS total_revenue + COALESCE("_S1".N_ROWS, 0) AS total_sales, + COALESCE("_S1".SUM_SALE_PRICE, 0) AS total_revenue FROM MAIN.CARS CARS LEFT JOIN "_S1" "_S1" ON CARS."_id" = "_S1".CAR_ID diff --git a/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql index 99d0ee519..22338ac07 100644 --- a/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql @@ -2,7 +2,7 @@ SELECT first_name, last_name, phone, - DATEDIFF(CAST(termination_date AS DATETIME), CAST(hire_date AS DATETIME), DAY) AS days_employed + CAST(termination_date AS DATE) - CAST(hire_date AS DATE) AS days_employed FROM MAIN.SALESPERSONS WHERE NOT termination_date IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql index 8cff8f98f..488d5af69 100644 --- a/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql @@ -4,7 +4,7 @@ FROM MAIN.PAYMENTS_MADE WHERE ( MOD(( - DAY_OF_WEEK(payment_date) + 6 + TO_CHAR(payment_date, 'D') + 5 ), 7) ) IN (5, 6) AND vendor_name = 'Utility Company' diff --git a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql index 3c58a82ef..9b932ce0c 100644 --- a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -5,7 +5,7 @@ WITH "_S0" AS ( SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE - EXTRACT(YEAR FROM CAST(sale_date AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(sale_date AS DATE)) = 2023 GROUP BY TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER'), customer_id diff --git a/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql index 538935eca..815788cfa 100644 --- a/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql @@ -5,8 +5,8 @@ WITH "_T" AS ( RANK() OVER (ORDER BY snapshot_date DESC) AS "_W" FROM MAIN.INVENTORY_SNAPSHOTS WHERE - EXTRACT(MONTH FROM CAST(snapshot_date AS DATETIME)) = 3 - AND EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 + EXTRACT(MONTH FROM CAST(snapshot_date AS DATE)) = 3 + AND EXTRACT(YEAR FROM CAST(snapshot_date AS DATE)) = 2023 ) SELECT CARS."_id", diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql index 1fa6d2b28..9232e2d7f 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -2,7 +2,13 @@ WITH "_S3" AS ( SELECT drug_id AS DRUG_ID, AVG( - tot_drug_amt / DATEDIFF(CAST(end_dt AS DATETIME), CAST(start_dt AS DATETIME), DAY) + tot_drug_amt / CASE + WHEN ( + CAST(end_dt AS DATE) - CAST(start_dt AS DATE) + ) <> 0 + THEN CAST(end_dt AS DATE) - CAST(start_dt AS DATE) + ELSE NULL + END ) AS AVG_DDD FROM MAIN.TREATMENTS WHERE diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql index 15c5a4d0b..cf736ba1f 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql @@ -2,7 +2,7 @@ SELECT ( ( AVG(day100_pasi_score) - AVG(day7_pasi_score) - ) / AVG(day7_pasi_score) + ) / NULLIF(AVG(day7_pasi_score), 0) ) * 100 AS d7d100pir FROM MAIN.OUTCOMES WHERE diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql index 861dd8bba..d22d810a7 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql @@ -1,6 +1,6 @@ WITH "_T1" AS ( SELECT - MIN(EXTRACT(YEAR FROM CAST(TREATMENTS_2.start_dt AS DATETIME))) AS MIN_YEAR_START_DT + MIN(EXTRACT(YEAR FROM CAST(TREATMENTS_2.start_dt AS DATE))) AS MIN_YEAR_START_DT FROM MAIN.PATIENTS PATIENTS JOIN MAIN.TREATMENTS TREATMENTS ON PATIENTS.patient_id = TREATMENTS.patient_id @@ -17,13 +17,13 @@ WITH "_T1" AS ( MIN_YEAR_START_DT ) SELECT - CAST(MIN_YEAR_START_DT AS CLOB) AS year, + CAST(MIN_YEAR_START_DT AS VARCHAR2(4000)) AS year, N_ROWS AS number_of_new_patients, CASE WHEN ( - N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + N_ROWS - COALESCE(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) ) <> 0 - THEN N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + THEN N_ROWS - COALESCE(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) ELSE NULL END AS npi FROM "_T0" diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql index d9e60aeb8..bc329c91a 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql @@ -5,5 +5,7 @@ JOIN MAIN.PATIENTS PATIENTS ON LOWER(PATIENTS.first_name) = 'alice' AND PATIENTS.patient_id = TREATMENTS.patient_id WHERE - TREATMENTS.start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') - AND TREATMENTS.start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 6, MONTH) + TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND TREATMENTS.start_dt >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(6, 'month') + ) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql index bb52043a2..20310940e 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -5,20 +5,33 @@ WITH "_T0" AS ( COUNT(DISTINCT diag_id) AS NDISTINCT_DIAG_ID FROM MAIN.TREATMENTS WHERE - DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 12, MONTH) <= TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') - AND TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(12, 'month') + ) <= TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') + AND TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') GROUP BY TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') ) SELECT - LISTAGG( - '-', - EXTRACT(YEAR FROM START_MONTH), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(START_MONTH AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(START_MONTH AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))), -2) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))), -2) + END, + NULL + ), + '-' ) AS start_month, NDISTINCT_DIAG_ID AS PMPD, N_ROWS AS PMTC diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql index 24b1a79ca..88928e476 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -1,76 +1,126 @@ WITH "_S2" AS ( SELECT - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(start_dt AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))), ( - 2 * -1 - )) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(start_dt AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(start_dt AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( + 2 * -1 + )) + END, + NULL + ), + '-' ) AS TREATMENT_MONTH, COUNT(DISTINCT patient_id) AS NDISTINCT_PATIENT_ID FROM MAIN.TREATMENTS WHERE - start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') - AND start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 3, MONTH) + start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND start_dt >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(3, 'month') + ) GROUP BY - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(start_dt AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))), ( - 2 * -1 - )) - END + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(start_dt AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(start_dt AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( + 2 * -1 + )) + END, + NULL + ), + '-' ) ), "_S3" AS ( SELECT - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))), - ( + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( 2 * -1 - ) - ) - END + )) + END, + NULL + ), + '-' ) AS TREATMENT_MONTH, COUNT(DISTINCT TREATMENTS.patient_id) AS NDISTINCT_PATIENT_ID FROM MAIN.TREATMENTS TREATMENTS JOIN MAIN.DRUGS DRUGS ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'biologic' WHERE - TREATMENTS.start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') - AND TREATMENTS.start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 3, MONTH) + TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND TREATMENTS.start_dt >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(3, 'month') + ) GROUP BY - LISTAGG( - '-', - EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATETIME)), - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))), - ( + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), + '-' || EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), + NULL + ) || NVL2( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( + 2 * -1 + )) + END, + '-' || CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( 2 * -1 - ) - ) - END + )) + END, + NULL + ), + '-' ) ) SELECT "_S2".TREATMENT_MONTH AS month, "_S2".NDISTINCT_PATIENT_ID AS patient_count, - NVL("_S3".NDISTINCT_PATIENT_ID, 0) AS biologic_treatment_count + COALESCE("_S3".NDISTINCT_PATIENT_ID, 0) AS biologic_treatment_count FROM "_S2" "_S2" LEFT JOIN "_S3" "_S3" ON "_S2".TREATMENT_MONTH = "_S3".TREATMENT_MONTH diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql index 3ce4e86fe..13a38c4e0 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( SUM(tot_drug_amt) AS SUM_TOT_DRUG_AMT FROM MAIN.TREATMENTS WHERE - start_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') + start_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'DAY') GROUP BY doc_id ), "_T1" AS ( @@ -22,7 +22,7 @@ WITH "_S1" AS ( SELECT SPECIALTY AS specialty, SUM_N_ROWS AS num_treatments, - NVL(SUM_SUM_TOT_DRUG_AMT, 0) AS total_drug_amount + COALESCE(SUM_SUM_TOT_DRUG_AMT, 0) AS total_drug_amount FROM "_T1" WHERE SUM_N_ROWS <> 0 diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql index e9a8b49ad..db219fa69 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql @@ -5,7 +5,7 @@ WITH "_T2" AS ( treatment_id AS TREATMENT_ID FROM MAIN.TREATMENTS WHERE - EXTRACT(YEAR FROM CAST(end_dt AS DATETIME)) = 2022 + EXTRACT(YEAR FROM CAST(end_dt AS DATE)) = 2022 ), "_T3" AS ( SELECT day100_pasi_score AS DAY100_PASI_SCORE, diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql index acae8a855..ba66491d8 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql @@ -9,7 +9,7 @@ WITH "_S1" AS ( ) SELECT DRUGS.drug_name, - NVL("_S1".N_ROWS, 0) AS num_treatments, + COALESCE("_S1".N_ROWS, 0) AS num_treatments, "_S1".AVG_TOT_DRUG_AMT AS avg_drug_amount FROM MAIN.DRUGS DRUGS LEFT JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql index 964d6dcdb..a04bfd931 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql @@ -5,9 +5,7 @@ SELECT ADVERSE_EVENTS.description FROM MAIN.ADVERSE_EVENTS ADVERSE_EVENTS JOIN MAIN.TREATMENTS TREATMENTS - ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id - AND DATEDIFF( - CAST(ADVERSE_EVENTS.reported_dt AS DATETIME), - CAST(TREATMENTS.start_dt AS DATETIME), - DAY + ON ( + CAST(ADVERSE_EVENTS.reported_dt AS DATE) - CAST(TREATMENTS.start_dt AS DATE) ) <= 10 + AND ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql index 1fc9dffaa..82e6555a8 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql @@ -1,4 +1,11 @@ -WITH "_T" AS ( +WITH "_u_0" AS ( + SELECT + ARRAY_AGG(doc_id) AS DOC_ID, + year_reg AS "_u_1" + FROM MAIN.DOCTORS + GROUP BY + year_reg +), "_T" AS ( SELECT doc_id AS DOC_ID, start_dt AS START_DT, @@ -15,12 +22,12 @@ WITH "_T" AS ( "_W" = 1 ) SELECT - DOCTORS.last_name, - DOCTORS.year_reg, + "_S0".LAST_NAME AS last_name, + "_S0".YEAR_REG AS year_reg, "_S1".START_DT AS first_treatment_date, "_S1".TREATMENT_ID AS first_treatment_id -FROM MAIN.DOCTORS DOCTORS +FROM "_u_0".DOC_ID +LEFT JOIN "_u_0" "_u_0" + ON "_u_0"."_u_1" = EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(2, 'year') AS DATE)) LEFT JOIN "_S1" "_S1" - ON DOCTORS.doc_id = "_S1".DOC_ID -WHERE - DOCTORS.year_reg = EXTRACT(YEAR FROM DATE_SUB(CURRENT_TIMESTAMP, 2, YEAR)) + ON "_S0".DOC_ID = "_S1".DOC_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql index 405b438a7..5d476b173 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql @@ -1,5 +1,7 @@ SELECT - AVG(DATEDIFF(CURRENT_TIMESTAMP, CAST(date_of_birth AS DATETIME), YEAR)) AS average_age + AVG( + EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(date_of_birth AS DATE)) + ) AS average_age FROM MAIN.PATIENTS WHERE gender = 'Male' AND ins_type = 'private' diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql index e3f8ff9ae..6e39e66e4 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql @@ -8,12 +8,10 @@ FROM MAIN.TREATMENTS TREATMENTS JOIN MAIN.CONCOMITANT_MEDS CONCOMITANT_MEDS ON CONCOMITANT_MEDS.treatment_id = TREATMENTS.treatment_id JOIN MAIN.TREATMENTS TREATMENTS_2 - ON CONCOMITANT_MEDS.treatment_id = TREATMENTS_2.treatment_id - AND DATEDIFF( - CAST(CONCOMITANT_MEDS.start_dt AS DATETIME), - CAST(TREATMENTS_2.start_dt AS DATETIME), - DAY + ON ( + CAST(CONCOMITANT_MEDS.start_dt AS DATE) - CAST(TREATMENTS_2.start_dt AS DATE) ) <= 14 + AND CONCOMITANT_MEDS.treatment_id = TREATMENTS_2.treatment_id AND TREATMENTS_2.is_placebo WHERE TREATMENTS.is_placebo = TRUE diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql index b231e94be..0037e526e 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql @@ -8,4 +8,4 @@ JOIN MAIN.DRUGS DRUGS ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT DRUGS.fda_appr_dt IS NULL WHERE NOT TREATMENTS.end_dt IS NULL - AND TREATMENTS.end_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') + AND TREATMENTS.end_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_ansi.sql b/tests/test_sql_refsols/defog_ewallet_adv11_ansi.sql index 185e648da..368a20707 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_ansi.sql @@ -9,8 +9,8 @@ SELECT ) AS total_duration FROM main.users AS users JOIN main.user_sessions AS user_sessions - ON user_sessions.session_end_ts < '2023-06-08' - AND user_sessions.session_start_ts >= '2023-06-01' + ON user_sessions.session_end_ts < CAST('2023-06-08' AS DATE) + AND user_sessions.session_start_ts >= CAST('2023-06-01' AS DATE) AND user_sessions.user_id = users.uid GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql b/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql index 41b3428dd..015fd0cdc 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql @@ -5,8 +5,8 @@ SELECT ) AS total_duration FROM main.users AS users JOIN main.user_sessions AS user_sessions - ON user_sessions.session_end_ts < '2023-06-08' - AND user_sessions.session_start_ts >= '2023-06-01' + ON user_sessions.session_end_ts < CAST('2023-06-08' AS DATE) + AND user_sessions.session_start_ts >= CAST('2023-06-01' AS DATE) AND user_sessions.user_id = users.uid GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql index 339cd6a87..bbfc650e3 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql @@ -1,17 +1,15 @@ SELECT USER_SESSIONS.user_id AS uid, SUM( - DATEDIFF( - CAST(USER_SESSIONS.session_end_ts AS DATETIME), - CAST(USER_SESSIONS.session_start_ts AS DATETIME), - SECOND - ) + ( + CAST(USER_SESSIONS.session_end_ts AS DATE) - CAST(USER_SESSIONS.session_start_ts AS DATE) + ) * 86400 ) AS total_duration FROM MAIN.USERS USERS JOIN MAIN.USER_SESSIONS USER_SESSIONS ON USERS.uid = USER_SESSIONS.user_id - AND USER_SESSIONS.session_end_ts < '2023-06-08' - AND USER_SESSIONS.session_start_ts >= '2023-06-01' + AND USER_SESSIONS.session_end_ts < TO_DATE('2023-06-08', 'YYYY-MM-DD') + AND USER_SESSIONS.session_start_ts >= TO_DATE('2023-06-01', 'YYYY-MM-DD') GROUP BY USER_SESSIONS.user_id ORDER BY diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_postgres.sql b/tests/test_sql_refsols/defog_ewallet_adv11_postgres.sql index e123f50d6..04c9cbee8 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_postgres.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_postgres.sql @@ -7,8 +7,8 @@ SELECT ) AS total_duration FROM main.users AS users JOIN main.user_sessions AS user_sessions - ON user_sessions.session_end_ts < '2023-06-08' - AND user_sessions.session_start_ts >= '2023-06-01' + ON user_sessions.session_end_ts < CAST('2023-06-08' AS DATE) + AND user_sessions.session_start_ts >= CAST('2023-06-01' AS DATE) AND user_sessions.user_id = users.uid GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql b/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql index 7d8defbb6..932a59624 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql @@ -9,8 +9,8 @@ SELECT ) AS total_duration FROM main.users AS users JOIN main.user_sessions AS user_sessions - ON user_sessions.session_end_ts < '2023-06-08' - AND user_sessions.session_start_ts >= '2023-06-01' + ON user_sessions.session_end_ts < CAST('2023-06-08' AS DATE) + AND user_sessions.session_start_ts >= CAST('2023-06-01' AS DATE) AND user_sessions.user_id = users.uid GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql index 70cd17a4f..89cf77714 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql @@ -1,6 +1,6 @@ SELECT COUPONS.cid AS coupon_id, - NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount + COALESCE(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount FROM MAIN.COUPONS COUPONS LEFT JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY ON COUPONS.cid = WALLET_TRANSACTIONS_DAILY.coupon_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql index 4a17a3456..cbc4f56f7 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql @@ -2,5 +2,5 @@ SELECT COUNT(*) AS TUC FROM MAIN.USER_SESSIONS WHERE - session_end_ts >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH), 'DAY') - OR session_start_ts >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH), 'DAY') + session_end_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(1, 'month'), 'DAY') + OR session_start_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(1, 'month'), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql index babc7982a..2721473af 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql @@ -4,15 +4,21 @@ WITH "_S3" AS ( COUNT(*) AS N_ROWS FROM MAIN.COUPONS COUPONS JOIN MAIN.MERCHANTS MERCHANTS - ON COUPONS.merchant_id = MERCHANTS.mid - AND DATEDIFF(CAST(COUPONS.created_at AS DATETIME), CAST(MERCHANTS.created_at AS DATETIME), MONTH) = 0 + ON ( + ( + EXTRACT(YEAR FROM CAST(COUPONS.created_at AS DATE)) - EXTRACT(YEAR FROM CAST(MERCHANTS.created_at AS DATE)) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(COUPONS.created_at AS DATE)) - EXTRACT(MONTH FROM CAST(MERCHANTS.created_at AS DATE)) + ) + ) = 0 + AND COUPONS.merchant_id = MERCHANTS.mid GROUP BY COUPONS.merchant_id ) SELECT MERCHANTS.mid AS merchant_id, MERCHANTS.name AS merchant_name, - NVL("_S3".N_ROWS, 0) AS coupons_per_merchant + COALESCE("_S3".N_ROWS, 0) AS coupons_per_merchant FROM MAIN.MERCHANTS MERCHANTS LEFT JOIN "_S3" "_S3" ON MERCHANTS.mid = "_S3".MERCHANT_ID diff --git a/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql index a400fa7a7..0d2ca987c 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql @@ -1,6 +1,6 @@ SELECT ANY_VALUE(MERCHANTS.name) AS name, - COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.coupon_id) / COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.txid) AS CPUR + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.coupon_id) / NULLIF(COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.txid), 0) AS CPUR FROM MAIN.MERCHANTS MERCHANTS JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql index af55a5d09..7a8856bf6 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql @@ -1,10 +1,10 @@ SELECT TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') AS week, COUNT(*) AS num_notifs, - NVL( + COALESCE( SUM(( MOD(( - DAY_OF_WEEK(NOTIFICATIONS.created_at) + 6 + TO_CHAR(NOTIFICATIONS.created_at, 'D') + 5 ), 7) ) IN (5, 6)), 0 @@ -13,7 +13,9 @@ FROM MAIN.NOTIFICATIONS NOTIFICATIONS JOIN MAIN.USERS USERS ON NOTIFICATIONS.user_id = USERS.uid AND USERS.country IN ('US', 'CA') WHERE - NOTIFICATIONS.created_at < TRUNC(CURRENT_TIMESTAMP, 'WEEK') - AND NOTIFICATIONS.created_at >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 3, WEEK) + NOTIFICATIONS.created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + AND NOTIFICATIONS.created_at >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NUMTODSINTERVAL(3, 'week') + ) GROUP BY TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql index f6da2c390..b506340af 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql @@ -2,11 +2,13 @@ SELECT COUNT(*) AS num_transactions, CASE WHEN COUNT(*) <> 0 - THEN NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) + THEN COALESCE(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) ELSE NULL END AS total_amount FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY JOIN MAIN.USERS USERS ON USERS.country = 'US' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATETIME), DAY) <= 7 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE) + ) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql index f2e00e4f0..2fb495684 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql @@ -2,4 +2,6 @@ SELECT AVG(balance) AS AMB FROM MAIN.WALLET_USER_BALANCE_DAILY WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(updated_at AS DATETIME), DAY) <= 7 + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(updated_at AS DATE) + ) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql index 90ce9d77a..551e3fcdc 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql @@ -2,8 +2,8 @@ SELECT WALLET_TRANSACTIONS_DAILY.receiver_id AS merchants_id, ANY_VALUE(MERCHANTS.name) AS merchants_name, ANY_VALUE(MERCHANTS.category) AS category, - NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_revenue, - ROW_NUMBER() OVER (ORDER BY NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) DESC) AS mrr + COALESCE(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_revenue, + ROW_NUMBER() OVER (ORDER BY COALESCE(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) DESC) AS mrr FROM MAIN.MERCHANTS MERCHANTS JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql index 1733ce8d8..e5fce1dba 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql @@ -3,8 +3,10 @@ SELECT COUNT(DISTINCT sender_id) AS active_users FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE - created_at < TRUNC(CURRENT_TIMESTAMP, 'MONTH') - AND created_at >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 2, MONTH) + created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND created_at >= ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(2, 'month') + ) AND sender_type = 0 GROUP BY TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql index 8dc71ed62..63f621ddf 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql @@ -4,13 +4,13 @@ WITH "_S1" AS ( receiver_id AS RECEIVER_ID FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE - created_at >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 150, DAY), 'DAY') + created_at >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(150, 'day'), 'DAY') AND receiver_type = 1 ) SELECT ANY_VALUE(MERCHANTS.name) AS merchant_name, - NVL(NULLIF(COUNT("_S1".RECEIVER_ID), 0), 0) AS total_transactions, - NVL(SUM("_S1".AMOUNT), 0) AS total_amount + COUNT("_S1".RECEIVER_ID) AS total_transactions, + COALESCE(SUM("_S1".AMOUNT), 0) AS total_amount FROM MAIN.MERCHANTS MERCHANTS LEFT JOIN "_S1" "_S1" ON MERCHANTS.mid = "_S1".RECEIVER_ID diff --git a/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql index e9bd25cf7..dfdbbd51f 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql @@ -5,7 +5,7 @@ FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY JOIN MAIN.USERS USERS ON USERS.status = 'active' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id WHERE - EXTRACT(YEAR FROM CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE)) = 2023 AND WALLET_TRANSACTIONS_DAILY.sender_type = 0 AND WALLET_TRANSACTIONS_DAILY.status = 'success' GROUP BY diff --git a/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql index 148c636dc..919f60a5a 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql @@ -1,7 +1,7 @@ SELECT ANY_VALUE(COUPONS.code) AS coupon_code, COUNT(WALLET_TRANSACTIONS_DAILY.txid) AS redemption_count, - NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount + COALESCE(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount FROM MAIN.COUPONS COUPONS LEFT JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY ON COUPONS.cid = WALLET_TRANSACTIONS_DAILY.coupon_id diff --git a/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql index 6e97509d8..2b419d7b8 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql @@ -1,7 +1,7 @@ SELECT USERS.country, COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.sender_id) AS user_count, - NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_amount + COALESCE(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_amount FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY LEFT JOIN MAIN.USERS USERS ON USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id diff --git a/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql index 3888863c7..4206306c5 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql @@ -3,7 +3,7 @@ WITH "_S0" AS ( MIN(snapshot_date) AS MIN_SNAPSHOT_DATE FROM MAIN.USER_SETTING_SNAPSHOT WHERE - EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(snapshot_date AS DATE)) = 2023 ), "_S1" AS ( SELECT snapshot_date AS SNAPSHOT_DATE, @@ -11,7 +11,7 @@ WITH "_S0" AS ( AVG(tx_limit_monthly) AS AVG_TX_LIMIT_MONTHLY FROM MAIN.USER_SETTING_SNAPSHOT WHERE - EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(snapshot_date AS DATE)) = 2023 GROUP BY snapshot_date ) diff --git a/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql index 12217a386..0a5c52c5a 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql @@ -1,8 +1,8 @@ SELECT device_type, - AVG( - DATEDIFF(CAST(session_end_ts AS DATETIME), CAST(session_start_ts AS DATETIME), SECOND) - ) AS avg_session_duration_seconds + AVG(( + CAST(session_end_ts AS DATE) - CAST(session_start_ts AS DATE) + ) * 86400) AS avg_session_duration_seconds FROM MAIN.USER_SESSIONS GROUP BY device_type diff --git a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql index c7d0e27d0..ea73ca5e6 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql @@ -33,4 +33,6 @@ SELECT FROM "_S4" "_S4" JOIN "_T1" "_S5" ON "_S4".MID = "_S5".MERCHANT_ID - AND "_S5".START_DATE <= DATE_ADD(CAST("_S4".ANYTHING_CREATED_AT AS TIMESTAMP), 1, 'YEAR') + AND "_S5".START_DATE <= ( + CAST("_S4".ANYTHING_CREATED_AT AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + ) diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql index 6264d6c93..45935bd00 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -6,6 +6,8 @@ FROM MAIN.USERS USERS JOIN MAIN.NOTIFICATIONS NOTIFICATIONS ON NOTIFICATIONS.user_id = USERS.uid JOIN MAIN.USERS USERS_2 - ON NOTIFICATIONS.created_at <= DATE_ADD(CAST(USERS_2.created_at AS TIMESTAMP), 1, 'YEAR') + ON NOTIFICATIONS.created_at <= ( + CAST(USERS_2.created_at AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + ) AND NOTIFICATIONS.created_at >= USERS_2.created_at AND NOTIFICATIONS.user_id = USERS_2.uid diff --git a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql index 4087698ab..3fe0d0e05 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql @@ -10,6 +10,6 @@ WITH "_S0" AS ( FROM MAIN.RESTAURANT ) SELECT - "_S0".N_ROWS / "_S1".N_ROWS AS ratio + "_S0".N_ROWS / NULLIF("_S1".N_ROWS, 0) AS ratio FROM "_S0" "_S0" CROSS JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql index 6140ced43..145f7169e 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql @@ -1,3 +1,3 @@ SELECT - NVL(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio + COALESCE(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio FROM MAIN.RESTAURANT diff --git a/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql index 3f873154b..082b6d399 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio + COALESCE(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio FROM MAIN.RESTAURANT WHERE LOWER(city_name) = 'new york' diff --git a/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql index d107fd0cd..f5ed57cf5 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL(SUM(LOWER(food_type) = 'vegan'), 0) / NULLIF(SUM(LOWER(food_type) <> 'vegan'), 0) AS ratio + COALESCE(SUM(LOWER(food_type) = 'vegan'), 0) / NULLIF(SUM(LOWER(food_type) <> 'vegan'), 0) AS ratio FROM MAIN.RESTAURANT WHERE LOWER(city_name) = 'san francisco' diff --git a/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql index c4cd6b49b..6424e1314 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL(SUM(LOWER(food_type) = 'italian'), 0) / NULLIF(COUNT(*), 0) AS ratio + COALESCE(SUM(LOWER(food_type) = 'italian'), 0) / NULLIF(COUNT(*), 0) AS ratio FROM MAIN.RESTAURANT WHERE LOWER(city_name) = 'los angeles' diff --git a/tests/test_sql_refsols/division_by_zero_database_oracle.sql b/tests/test_sql_refsols/division_by_zero_database_oracle.sql new file mode 100644 index 000000000..33bb1923c --- /dev/null +++ b/tests/test_sql_refsols/division_by_zero_database_oracle.sql @@ -0,0 +1,6 @@ +SELECT + l_extendedprice / l_discount AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_by_zero_null_oracle.sql b/tests/test_sql_refsols/division_by_zero_null_oracle.sql new file mode 100644 index 000000000..f85774032 --- /dev/null +++ b/tests/test_sql_refsols/division_by_zero_null_oracle.sql @@ -0,0 +1,6 @@ +SELECT + l_extendedprice / NULLIF(l_discount, 0) AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_by_zero_zero_oracle.sql b/tests/test_sql_refsols/division_by_zero_zero_oracle.sql new file mode 100644 index 000000000..af890a7ea --- /dev/null +++ b/tests/test_sql_refsols/division_by_zero_zero_oracle.sql @@ -0,0 +1,6 @@ +SELECT + CASE WHEN l_discount = 0 THEN 0 ELSE l_extendedprice / l_discount END AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_complex_operands_null_oracle.sql b/tests/test_sql_refsols/division_complex_operands_null_oracle.sql new file mode 100644 index 000000000..2ecd10638 --- /dev/null +++ b/tests/test_sql_refsols/division_complex_operands_null_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ( + l_extendedprice + l_tax + ) / CASE WHEN ( + l_discount * 2 + ) <> 0 THEN l_discount * 2 ELSE NULL END AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_complex_operands_zero_oracle.sql b/tests/test_sql_refsols/division_complex_operands_zero_oracle.sql new file mode 100644 index 000000000..62b2dbaeb --- /dev/null +++ b/tests/test_sql_refsols/division_complex_operands_zero_oracle.sql @@ -0,0 +1,16 @@ +SELECT + CASE + WHEN ( + l_discount * 2 + ) = 0 + THEN 0 + ELSE ( + l_extendedprice + l_tax + ) / ( + l_discount * 2 + ) + END AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_iff_false_branch_null_oracle.sql b/tests/test_sql_refsols/division_iff_false_branch_null_oracle.sql new file mode 100644 index 000000000..ca3818236 --- /dev/null +++ b/tests/test_sql_refsols/division_iff_false_branch_null_oracle.sql @@ -0,0 +1,6 @@ +SELECT + l_extendedprice / NULLIF(CASE WHEN l_discount > 0 THEN 1 ELSE l_discount END, 0) AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_iff_false_branch_zero_oracle.sql b/tests/test_sql_refsols/division_iff_false_branch_zero_oracle.sql new file mode 100644 index 000000000..1bc6699cf --- /dev/null +++ b/tests/test_sql_refsols/division_iff_false_branch_zero_oracle.sql @@ -0,0 +1,10 @@ +SELECT + CASE + WHEN CASE WHEN l_discount > 0 THEN 1 ELSE l_discount END = 0 + THEN 0 + ELSE l_extendedprice / CASE WHEN l_discount > 0 THEN 1 ELSE l_discount END + END AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_iff_true_branch_null_oracle.sql b/tests/test_sql_refsols/division_iff_true_branch_null_oracle.sql new file mode 100644 index 000000000..357b76747 --- /dev/null +++ b/tests/test_sql_refsols/division_iff_true_branch_null_oracle.sql @@ -0,0 +1,6 @@ +SELECT + l_extendedprice / NULLIF(CASE WHEN l_discount > 0 THEN l_discount ELSE 1 END, 0) AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_iff_true_branch_zero_oracle.sql b/tests/test_sql_refsols/division_iff_true_branch_zero_oracle.sql new file mode 100644 index 000000000..23b4f54c3 --- /dev/null +++ b/tests/test_sql_refsols/division_iff_true_branch_zero_oracle.sql @@ -0,0 +1,10 @@ +SELECT + CASE + WHEN CASE WHEN l_discount > 0 THEN l_discount ELSE 1 END = 0 + THEN 0 + ELSE l_extendedprice / CASE WHEN l_discount > 0 THEN l_discount ELSE 1 END + END AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_keep_if_denom_null_oracle.sql b/tests/test_sql_refsols/division_keep_if_denom_null_oracle.sql new file mode 100644 index 000000000..84591c04c --- /dev/null +++ b/tests/test_sql_refsols/division_keep_if_denom_null_oracle.sql @@ -0,0 +1,6 @@ +SELECT + l_extendedprice / NULLIF(CASE WHEN l_discount > 0.05 THEN l_discount ELSE NULL END, 0) AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_keep_if_denom_zero_oracle.sql b/tests/test_sql_refsols/division_keep_if_denom_zero_oracle.sql new file mode 100644 index 000000000..ebfc18583 --- /dev/null +++ b/tests/test_sql_refsols/division_keep_if_denom_zero_oracle.sql @@ -0,0 +1,10 @@ +SELECT + CASE + WHEN CASE WHEN l_discount > 0.05 THEN l_discount ELSE NULL END = 0 + THEN 0 + ELSE l_extendedprice / CASE WHEN l_discount > 0.05 THEN l_discount ELSE NULL END + END AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_multiple_ops_null_oracle.sql b/tests/test_sql_refsols/division_multiple_ops_null_oracle.sql new file mode 100644 index 000000000..3fb5a6bc2 --- /dev/null +++ b/tests/test_sql_refsols/division_multiple_ops_null_oracle.sql @@ -0,0 +1,8 @@ +SELECT + l_quantity * ( + l_extendedprice / NULLIF(l_discount, 0) + ) + l_tax AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/division_multiple_ops_zero_oracle.sql b/tests/test_sql_refsols/division_multiple_ops_zero_oracle.sql new file mode 100644 index 000000000..5062fbc5a --- /dev/null +++ b/tests/test_sql_refsols/division_multiple_ops_zero_oracle.sql @@ -0,0 +1,6 @@ +SELECT + l_quantity * CASE WHEN l_discount = 0 THEN 0 ELSE l_extendedprice / l_discount END + l_tax AS computed_value +FROM TPCH.LINEITEM +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql index ff2376998..0a8bf4326 100644 --- a/tests/test_sql_refsols/double_cross_oracle.sql +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -8,25 +8,69 @@ WITH "_T3" AS ( FROM "_T3" ), "_S2" AS ( SELECT - DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST("_S0".MIN_O_ORDERDATE AS DATETIME), WEEK) AS ORD_WK, + FLOOR( + ( + CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S0".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(ORDERS.o_orderdate, 'D') + -1 + ), 7) + ) + ) / 7 + ) AS ORD_WK, COUNT(*) AS N_ROWS FROM "_S0" "_S0" JOIN TPCH.ORDERS ORDERS - ON DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST("_S0".MIN_O_ORDERDATE AS DATETIME), WEEK) < 10 + ON FLOOR( + ( + CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S0".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(ORDERS.o_orderdate, 'D') + -1 + ), 7) + ) + ) / 7 + ) < 10 AND ORDERS.o_orderpriority = '1-URGENT' AND ORDERS.o_orderstatus = 'F' GROUP BY - DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST("_S0".MIN_O_ORDERDATE AS DATETIME), WEEK) + FLOOR( + ( + CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S0".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(ORDERS.o_orderdate, 'D') + -1 + ), 7) + ) + ) / 7 + ) ), "_S3" AS ( SELECT MIN(O_ORDERDATE) AS MIN_O_ORDERDATE FROM "_T3" ), "_T0" AS ( SELECT - DATEDIFF( - CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST("_S3".MIN_O_ORDERDATE AS DATETIME), - WEEK + FLOOR( + ( + CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + ), 7) + ) + ) / 7 ) AS LINE_WK, "_S2".ORD_WK, ANY_VALUE("_S2".N_ROWS) AS ANYTHING_N_ROWS, @@ -34,24 +78,48 @@ WITH "_T3" AS ( FROM "_S2" "_S2" CROSS JOIN "_S3" "_S3" JOIN TPCH.LINEITEM LINEITEM - ON DATEDIFF( - CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST("_S3".MIN_O_ORDERDATE AS DATETIME), - WEEK + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATE)) = 1992 + AND FLOOR( + ( + CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + ), 7) + ) + ) / 7 ) < 10 - AND EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1992 AND LINEITEM.l_returnflag = 'R' AND LINEITEM.l_shipmode = 'RAIL' - AND "_S2".ORD_WK = DATEDIFF( - CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST("_S3".MIN_O_ORDERDATE AS DATETIME), - WEEK + AND "_S2".ORD_WK = FLOOR( + ( + CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + ), 7) + ) + ) / 7 ) GROUP BY - DATEDIFF( - CAST(LINEITEM.l_receiptdate AS DATETIME), - CAST("_S3".MIN_O_ORDERDATE AS DATETIME), - WEEK + FLOOR( + ( + CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + MOD(( + TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + ), 7) + ) + ) / 7 ), "_S2".ORD_WK ) diff --git a/tests/test_sql_refsols/double_partition_oracle.sql b/tests/test_sql_refsols/double_partition_oracle.sql index 417a6d4c8..2982b9c1e 100644 --- a/tests/test_sql_refsols/double_partition_oracle.sql +++ b/tests/test_sql_refsols/double_partition_oracle.sql @@ -1,11 +1,11 @@ WITH "_T0" AS ( SELECT - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS YEAR_O_ORDERDATE, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY - EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)), - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) ) SELECT YEAR_O_ORDERDATE AS year, diff --git a/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql index b48b54e32..4a0d4e730 100644 --- a/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql +++ b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql @@ -7,24 +7,24 @@ WITH "_S2" AS ( SELECT EVENTS.ev_name AS event_name, ERAS.er_name AS era_name, - EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) AS event_year, + EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) AS event_year, SEASONS.s_name AS season_name, TIMES.t_name AS tod FROM EVENTS EVENTS JOIN ERAS ERAS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) JOIN "_S2" "_S2" ON EVENTS.ev_key = "_S2".EV_KEY JOIN SEASONS SEASONS - ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATETIME)) - OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATETIME)) - OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATETIME)) + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATE)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATE)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST("_S2".EV_DT AS DATE)) JOIN "_S2" "_S6" ON EVENTS.ev_key = "_S6".EV_KEY JOIN TIMES TIMES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S6".EV_DT AS DATETIME)) - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S6".EV_DT AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S6".EV_DT AS TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S6".EV_DT AS TIMESTAMP)) WHERE EVENTS.ev_typ = 'culture' ORDER BY diff --git a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql index a81ff0f60..95f7660bb 100644 --- a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql +++ b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql @@ -4,23 +4,19 @@ WITH "_T2" AS ( ERAS.er_name AS ER_NAME, ERAS.er_start_year AS ER_START_YEAR, EVENTS.ev_dt AS EV_DT, - DATEDIFF( - CAST(EVENTS.ev_dt AS DATETIME), - CAST(LAG(EVENTS.ev_dt, 1) OVER (PARTITION BY ERAS.er_name, ERAS.er_name ORDER BY EVENTS.ev_dt) AS DATETIME), - DAY - ) AS DAY_GAP + CAST(EVENTS.ev_dt AS DATE) - CAST(LAG(EVENTS.ev_dt, 1) OVER (PARTITION BY ERAS.er_name, ERAS.er_name ORDER BY EVENTS.ev_dt) AS DATE) AS DAY_GAP FROM ERAS ERAS JOIN EVENTS EVENTS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) ) SELECT ER_NAME AS era_name, AVG(DAY_GAP) AS avg_event_gap FROM "_T2" WHERE - ER_END_YEAR > EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) - AND ER_START_YEAR <= EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) + ER_END_YEAR > EXTRACT(YEAR FROM CAST(EV_DT AS DATE)) + AND ER_START_YEAR <= EXTRACT(YEAR FROM CAST(EV_DT AS DATE)) GROUP BY ER_NAME ORDER BY diff --git a/tests/test_sql_refsols/epoch_events_per_season_oracle.sql b/tests/test_sql_refsols/epoch_events_per_season_oracle.sql index 585bbad16..b373e1ad2 100644 --- a/tests/test_sql_refsols/epoch_events_per_season_oracle.sql +++ b/tests/test_sql_refsols/epoch_events_per_season_oracle.sql @@ -3,9 +3,9 @@ SELECT COUNT(*) AS n_events FROM SEASONS SEASONS JOIN EVENTS EVENTS - ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) - OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) - OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATE)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATE)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATE)) GROUP BY SEASONS.s_name ORDER BY diff --git a/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql index 483d55e49..ea23ab825 100644 --- a/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql +++ b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql @@ -6,8 +6,8 @@ WITH "_T" AS ( ROW_NUMBER() OVER (PARTITION BY ERAS.er_name ORDER BY EVENTS.ev_dt) AS "_W" FROM ERAS ERAS JOIN EVENTS EVENTS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) ) SELECT ER_NAME AS era_name, diff --git a/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql index 9058dd39d..e4e1ddc54 100644 --- a/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql +++ b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql @@ -16,17 +16,17 @@ WITH "_S0" AS ( SEARCHES.search_id AS SEARCH_ID FROM "_S0" "_S2" JOIN SEARCHES SEARCHES - ON "_S2".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR "_S2".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR "_S2".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON "_S2".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) + OR "_S2".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) + OR "_S2".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) JOIN "_S5" "_S5" ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER("_S5".EV_NAME), '%') JOIN "_S0" "_S7" ON "_S2".S_NAME = "_S7".S_NAME AND ( - "_S7".S_MONTH1 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATETIME)) - OR "_S7".S_MONTH2 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATETIME)) - OR "_S7".S_MONTH3 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATETIME)) + "_S7".S_MONTH1 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATE)) + OR "_S7".S_MONTH2 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATE)) + OR "_S7".S_MONTH3 = EXTRACT(MONTH FROM CAST("_S5".EV_DT AS DATE)) ) ), "_T1" AS ( SELECT @@ -34,9 +34,9 @@ WITH "_S0" AS ( COUNT("_S9".SEARCH_ID) AS COUNT_SEARCH_ID FROM "_S0" "_S0" JOIN SEARCHES SEARCHES - ON "_S0".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR "_S0".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR "_S0".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON "_S0".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) + OR "_S0".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) + OR "_S0".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) LEFT JOIN "_S9" "_S9" ON SEARCHES.search_id = "_S9".SEARCH_ID AND "_S0".S_NAME = "_S9".S_NAME GROUP BY @@ -59,26 +59,29 @@ WITH "_S0" AS ( SUM("_S15".S_NAME = "_S10".S_NAME) AS SUM_IS_INTRA_SEASON FROM "_S0" "_S10" JOIN "_S5" "_S11" - ON "_S10".S_MONTH1 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATETIME)) - OR "_S10".S_MONTH2 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATETIME)) - OR "_S10".S_MONTH3 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATETIME)) + ON "_S10".S_MONTH1 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATE)) + OR "_S10".S_MONTH2 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATE)) + OR "_S10".S_MONTH3 = EXTRACT(MONTH FROM CAST("_S11".EV_DT AS DATE)) JOIN SEARCHES SEARCHES ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER("_S11".EV_NAME), '%') JOIN "_S0" "_S15" - ON "_S15".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR "_S15".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) - OR "_S15".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON "_S15".S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) + OR "_S15".S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) + OR "_S15".S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATE)) GROUP BY "_S10".S_NAME ) SELECT "_S16".S_NAME AS season_name, ROUND(( - 100.0 * NVL("_S16".SUM_IS_INTRA_SEASON, 0) + 100.0 * COALESCE("_S16".SUM_IS_INTRA_SEASON, 0) ) / "_S16".N_ROWS, 2) AS pct_season_searches, - ROUND(( - 100.0 * NVL("_S17".SUM_IS_INTRA_SEASON, 0) - ) / NVL("_S17".N_ROWS, 0), 2) AS pct_event_searches + ROUND( + ( + 100.0 * COALESCE("_S17".SUM_IS_INTRA_SEASON, 0) + ) / COALESCE("_S17".N_ROWS, 0), + 2 + ) AS pct_event_searches FROM "_S16" "_S16" LEFT JOIN "_S17" "_S17" ON "_S16".S_NAME = "_S17".S_NAME diff --git a/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql index 138bc436f..538e49051 100644 --- a/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql +++ b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql @@ -5,8 +5,8 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM TIMES TIMES JOIN SEARCHES SEARCHES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) GROUP BY SEARCHES.search_engine, TIMES.t_name diff --git a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql index 2b7095b43..e4b64d002 100644 --- a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql @@ -8,12 +8,12 @@ SELECT COUNT(DISTINCT "_S0".EV_KEY) AS n_events FROM "_S0" "_S0" JOIN TIMES TIMES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S0".EV_DT AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S0".EV_DT AS TIMESTAMP)) AND TIMES.t_name = 'Pre-Dawn' - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S0".EV_DT AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S0".EV_DT AS TIMESTAMP)) JOIN "_S0" "_S2" ON "_S0".EV_KEY = "_S2".EV_KEY JOIN ERAS ERAS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATETIME)) + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATE)) AND ERAS.er_name = 'Cold War' - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATE)) diff --git a/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql index 2df5df362..409975580 100644 --- a/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql +++ b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql @@ -5,8 +5,8 @@ WITH "_T0" AS ( COUNT(*) AS N_ROWS FROM TIMES TIMES JOIN SEARCHES SEARCHES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) GROUP BY TIMES.t_name ) diff --git a/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql index e2145dcc7..e7d336788 100644 --- a/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql +++ b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql @@ -6,8 +6,8 @@ WITH "_T0" AS ( COUNT(*) AS N_ROWS FROM TIMES TIMES JOIN SEARCHES SEARCHES - ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) - AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) GROUP BY TIMES.t_name ) diff --git a/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql b/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql index da14a0d97..907c19a30 100644 --- a/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql +++ b/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql @@ -4,9 +4,9 @@ SELECT FROM EVENTS EVENTS JOIN SEASONS SEASONS ON ( - SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) - OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) - OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATE)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATE)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATE)) ) AND SEASONS.s_name = 'Summer' GROUP BY diff --git a/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql index 2edca9da2..29b3ec33f 100644 --- a/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql +++ b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql @@ -8,14 +8,14 @@ WITH "_S0" AS ( COUNT(DISTINCT search_user_id) AS NDISTINCT_SEARCH_USER_ID FROM SEARCHES WHERE - EXTRACT(YEAR FROM CAST(search_ts AS DATETIME)) <= 2019 - AND EXTRACT(YEAR FROM CAST(search_ts AS DATETIME)) >= 2010 + EXTRACT(YEAR FROM CAST(search_ts AS DATE)) <= 2019 + AND EXTRACT(YEAR FROM CAST(search_ts AS DATE)) >= 2010 GROUP BY search_engine ) SELECT "_S0".SEARCH_ENGINE AS engine, - NVL("_S1".NDISTINCT_SEARCH_USER_ID, 0) AS n_users + COALESCE("_S1".NDISTINCT_SEARCH_USER_ID, 0) AS n_users FROM "_S0" "_S0" LEFT JOIN "_S1" "_S1" ON "_S0".SEARCH_ENGINE = "_S1".SEARCH_ENGINE diff --git a/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql index cf4e87416..e9d96d9d1 100644 --- a/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql +++ b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql @@ -5,9 +5,9 @@ WITH "_T1" AS ( JOIN EVENTS EVENTS ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') JOIN ERAS ERAS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) AND ERAS.er_name = 'Cold War' - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) GROUP BY SEARCHES.search_id ), "_S5" AS ( diff --git a/tests/test_sql_refsols/first_order_in_year_oracle.sql b/tests/test_sql_refsols/first_order_in_year_oracle.sql index 7272558d7..f23de7893 100644 --- a/tests/test_sql_refsols/first_order_in_year_oracle.sql +++ b/tests/test_sql_refsols/first_order_in_year_oracle.sql @@ -6,14 +6,14 @@ WITH "_T" AS ( LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS "_W_2" FROM TPCH.ORDERS WHERE - EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) = 1 ) SELECT O_ORDERDATE AS order_date, O_ORDERKEY AS key FROM "_T" WHERE - EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) <> EXTRACT(YEAR FROM CAST("_W_2" AS DATETIME)) + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATE)) <> EXTRACT(YEAR FROM CAST("_W_2" AS DATE)) OR "_W" IS NULL ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/function_sampler_oracle.sql b/tests/test_sql_refsols/function_sampler_oracle.sql index 81a99a23d..412f2fe19 100644 --- a/tests/test_sql_refsols/function_sampler_oracle.sql +++ b/tests/test_sql_refsols/function_sampler_oracle.sql @@ -1,5 +1,8 @@ SELECT - LISTAGG('-', REGION.r_name, NATION.n_name, SUBSTR(CUSTOMER.c_name, 17)) AS a, + LTRIM( + NVL2(REGION.r_name, '-' || REGION.r_name, NULL) || NVL2(NATION.n_name, '-' || NATION.n_name, NULL) || NVL2(SUBSTR(CUSTOMER.c_name, 17), '-' || SUBSTR(CUSTOMER.c_name, 17), NULL), + '-' + ) AS a, ROUND(CUSTOMER.c_acctbal, 1) AS b, CASE WHEN SUBSTR(CUSTOMER.c_phone, 1, 1) = '3' THEN CUSTOMER.c_name ELSE NULL END AS c, NOT CASE diff --git a/tests/test_sql_refsols/has_equals_one_oracle.sql b/tests/test_sql_refsols/has_equals_one_oracle.sql new file mode 100644 index 000000000..c81355273 --- /dev/null +++ b/tests/test_sql_refsols/has_equals_one_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(DISTINCT o_custkey) AS n +FROM TPCH.ORDERS +WHERE + o_orderpriority = '1-URGENT' diff --git a/tests/test_sql_refsols/hasnot_equals_one_oracle.sql b/tests/test_sql_refsols/hasnot_equals_one_oracle.sql new file mode 100644 index 000000000..c2f2d03a0 --- /dev/null +++ b/tests/test_sql_refsols/hasnot_equals_one_oracle.sql @@ -0,0 +1,17 @@ +WITH "_S1" AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' + GROUP BY + o_custkey +) +SELECT + COUNT(*) AS n +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN "_S1" "_S1" + ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY +WHERE + "_S1".N_ROWS = 0 OR "_S1".N_ROWS IS NULL diff --git a/tests/test_sql_refsols/highest_priority_per_year_oracle.sql b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql index 0b2fc6e24..0ff41cdb0 100644 --- a/tests/test_sql_refsols/highest_priority_per_year_oracle.sql +++ b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql @@ -1,11 +1,11 @@ WITH "_T3" AS ( SELECT - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS YEAR_O_ORDERDATE, o_orderpriority AS O_ORDERPRIORITY, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)), o_orderpriority ), "_T2" AS ( SELECT diff --git a/tests/test_sql_refsols/hour_minute_day_oracle.sql b/tests/test_sql_refsols/hour_minute_day_oracle.sql index 6d37fe54b..4dcfc7b07 100644 --- a/tests/test_sql_refsols/hour_minute_day_oracle.sql +++ b/tests/test_sql_refsols/hour_minute_day_oracle.sql @@ -1,13 +1,13 @@ SELECT SBTRANSACTION.sbtxid AS transaction_id, - EXTRACT(HOUR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS "_expr0", - EXTRACT(MINUTE FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS "_expr1", - EXTRACT(SECOND FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS "_expr2" + EXTRACT(HOUR FROM CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP)) AS "_expr0", + EXTRACT(MINUTE FROM CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP)) AS "_expr1", + EXTRACT(SECOND FROM CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP)) AS "_expr2" FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBTICKER SBTICKER ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid AND SBTICKER.sbtickersymbol IN ('AAPL', 'GOOGL', 'NFLX') WHERE - EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 2023 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql index 0b96c92bf..6207119eb 100644 --- a/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, + COALESCE("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, CALCULATE.".WHERE" AS "_where", CALCULATE."LIKE" AS "_like", CALCULATE.datetime, diff --git a/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql index dd42f6bba..a8aa9e9fc 100644 --- a/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql +++ b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql @@ -17,6 +17,6 @@ SELECT "_S1".MAX_NAME AS max_name, "_S1".COUNT_CAST AS count_cast, "_S1".AVG_QUOTE AS quote_avg, - NVL("_S1".SUM_NAME, 0) AS sum_name + COALESCE("_S1".SUM_NAME, 0) AS sum_name FROM "_S0" "_S0" CROSS JOIN "_S1" "_S1" diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql index a38b0f5ad..ff85e4c70 100644 --- a/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql @@ -1,7 +1,7 @@ SELECT """," AS "dbl_quote_dot", "." AS "dot", - "." + NVL("FLOAT", str, 1) AS addition, + "." + COALESCE("FLOAT", str, 1) AS addition, "__col__" AS "col", "__col1__" AS "col1", def AS def_, diff --git a/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql index 47dcc9e1c..71f7f1ce5 100644 --- a/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql +++ b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql @@ -8,37 +8,37 @@ WITH "_T7" AS ( o_orderpriority = '1-URGENT' ), "_T5" AS ( SELECT - EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATE)) AS YEAR_O_ORDERDATE, SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE FROM "_T7" GROUP BY - EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATE)) ), "_T4" AS ( SELECT SUM_O_TOTALPRICE, YEAR_O_ORDERDATE, - LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE) AS NEXT_YEAR_TOTAL_SPENT + LEAD(COALESCE(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE) AS NEXT_YEAR_TOTAL_SPENT FROM "_T5" ), "_T2" AS ( SELECT - EXTRACT(MONTH FROM CAST("_T8".O_ORDERDATE AS DATETIME)) AS MONTH_O_ORDERDATE, - EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + EXTRACT(MONTH FROM CAST("_T8".O_ORDERDATE AS DATE)) AS MONTH_O_ORDERDATE, + EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATE)) AS YEAR_O_ORDERDATE, SUM("_T8".O_TOTALPRICE) AS SUM_O_TOTALPRICE FROM "_T4" "_T4" JOIN "_T7" "_T8" - ON "_T4".YEAR_O_ORDERDATE = EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATETIME)) + ON "_T4".YEAR_O_ORDERDATE = EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATE)) WHERE - "_T4".NEXT_YEAR_TOTAL_SPENT < NVL("_T4".SUM_O_TOTALPRICE, 0) + "_T4".NEXT_YEAR_TOTAL_SPENT < COALESCE("_T4".SUM_O_TOTALPRICE, 0) GROUP BY - EXTRACT(MONTH FROM CAST("_T8".O_ORDERDATE AS DATETIME)), - EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATETIME)) + EXTRACT(MONTH FROM CAST("_T8".O_ORDERDATE AS DATE)), + EXTRACT(YEAR FROM CAST("_T8".O_ORDERDATE AS DATE)) ), "_T" AS ( SELECT MONTH_O_ORDERDATE, YEAR_O_ORDERDATE, SUM_O_TOTALPRICE, - LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS "_W", - LAG(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS "_W_2" + LEAD(COALESCE(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS "_W", + LAG(COALESCE(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS "_W_2" FROM "_T2" ) SELECT @@ -46,7 +46,7 @@ SELECT MONTH_O_ORDERDATE AS month FROM "_T" WHERE - "_W" < NVL(SUM_O_TOTALPRICE, 0) AND "_W_2" < NVL(SUM_O_TOTALPRICE, 0) + "_W" < COALESCE(SUM_O_TOTALPRICE, 0) AND "_W_2" < COALESCE(SUM_O_TOTALPRICE, 0) ORDER BY 1 NULLS FIRST, 2 NULLS FIRST diff --git a/tests/test_sql_refsols/nation_best_order_oracle.sql b/tests/test_sql_refsols/nation_best_order_oracle.sql index 2260b6813..c6bb69c59 100644 --- a/tests/test_sql_refsols/nation_best_order_oracle.sql +++ b/tests/test_sql_refsols/nation_best_order_oracle.sql @@ -10,7 +10,7 @@ WITH "_T3" AS ( FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1998 ), "_T" AS ( SELECT C_NAME, diff --git a/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql index 32fab572f..50c70386f 100644 --- a/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql +++ b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql @@ -1,10 +1,6 @@ SELECT AVG( - DATEDIFF( - CAST(LEAST(LINEITEM.l_commitdate, LINEITEM.l_receiptdate) AS DATETIME), - CAST(ORDERS.o_orderdate AS DATETIME), - DAY - ) + CAST(LEAST(LINEITEM.l_commitdate, LINEITEM.l_receiptdate) AS DATE) - CAST(ORDERS.o_orderdate AS DATE) ) AS avg_gap FROM TPCH.LINEITEM LINEITEM JOIN TPCH.ORDERS ORDERS diff --git a/tests/test_sql_refsols/order_info_per_priority_oracle.sql b/tests/test_sql_refsols/order_info_per_priority_oracle.sql index 85b335d37..61bb07464 100644 --- a/tests/test_sql_refsols/order_info_per_priority_oracle.sql +++ b/tests/test_sql_refsols/order_info_per_priority_oracle.sql @@ -6,7 +6,7 @@ WITH "_T" AS ( ROW_NUMBER() OVER (PARTITION BY o_orderpriority ORDER BY o_totalprice DESC) AS "_W" FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1992 ) SELECT O_ORDERPRIORITY AS order_priority, diff --git a/tests/test_sql_refsols/order_quarter_test_oracle.sql b/tests/test_sql_refsols/order_quarter_test_oracle.sql index 3276ffee3..7131ef5ab 100644 --- a/tests/test_sql_refsols/order_quarter_test_oracle.sql +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -1,18 +1,26 @@ SELECT o_orderdate AS order_date, - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATETIME)) AS quarter, + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) AS quarter, TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER') AS quarter_start, - DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 1, 'QUARTER') AS next_quarter, - DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 1, QUARTER) AS prev_quarter, - DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 2, 'QUARTER') AS two_quarters_ahead, - DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 2, QUARTER) AS two_quarters_behind, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1995-01-01' AS TIMESTAMP), QUARTER) AS quarters_since_1995, - DATEDIFF(CAST('2000-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), QUARTER) AS quarters_until_2000, - DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 4, QUARTER) AS same_quarter_prev_year, - DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 4, 'QUARTER') AS same_quarter_next_year + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(1, 'quarter') AS next_quarter, + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(1, 'quarter') AS prev_quarter, + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(2, 'quarter') AS two_quarters_ahead, + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(2, 'quarter') AS two_quarters_behind, + ( + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1995-01-01' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('1995-01-01' AS TIMESTAMP) AS DATE)) + ) AS quarters_since_1995, + ( + EXTRACT(YEAR FROM CAST(CAST('2000-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2000-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) + ) AS quarters_until_2000, + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(4, 'quarter') AS same_quarter_prev_year, + CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(4, 'quarter') AS same_quarter_next_year FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1995 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1995 ORDER BY 1 NULLS FIRST FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql index 7e260dcf3..64905f5d0 100644 --- a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql +++ b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql @@ -27,7 +27,7 @@ WITH "_S4" AS ( SELECT "_S5".C_NAME AS customer_name, "_S4".O_ORDERKEY AS order_key, - DATEDIFF(CAST("_S4".O_ORDERDATE AS DATETIME), CAST("_S5".O_ORDERDATE AS DATETIME), DAY) AS days_since_first_order + CAST("_S4".O_ORDERDATE AS DATE) - CAST("_S5".O_ORDERDATE AS DATE) AS days_since_first_order FROM "_S4" "_S4" LEFT JOIN "_S5" "_S5" ON "_S4".O_CUSTKEY = "_S5".C_CUSTKEY diff --git a/tests/test_sql_refsols/part_cross_part_a_oracle.sql b/tests/test_sql_refsols/part_cross_part_a_oracle.sql index 0e0c73108..b5036247b 100644 --- a/tests/test_sql_refsols/part_cross_part_a_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_a_oracle.sql @@ -21,7 +21,7 @@ WITH "_S0" AS ( SELECT SBCUSTOMER.sbcuststate AS state, "_S0".SBTICKEREXCHANGE AS exchange, - NVL(SUM("_S9".N_ROWS), 0) AS n + COALESCE(SUM("_S9".N_ROWS), 0) AS n FROM "_S0" "_S0" CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER LEFT JOIN "_S9" "_S9" diff --git a/tests/test_sql_refsols/part_cross_part_b_oracle.sql b/tests/test_sql_refsols/part_cross_part_b_oracle.sql index dc55f69f2..591c8b44e 100644 --- a/tests/test_sql_refsols/part_cross_part_b_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_b_oracle.sql @@ -7,7 +7,7 @@ WITH "_S0" AS ( sbtxdatetime AS SBTXDATETIME FROM MAIN.SBTRANSACTION WHERE - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_S1" AS ( SELECT DISTINCT TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH @@ -24,7 +24,7 @@ WITH "_S0" AS ( FROM "_S0" "_S2" CROSS JOIN "_S3" "_S3" JOIN MAIN.SBTRANSACTION SBTRANSACTION - ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 2023 AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid @@ -36,7 +36,7 @@ WITH "_S0" AS ( SELECT "_S0".SBCUSTSTATE AS state, "_S1".MONTH AS month_of_year, - SUM(NVL("_S9".N_ROWS, 0)) OVER (PARTITION BY "_S0".SBCUSTSTATE ORDER BY "_S1".MONTH ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n + SUM(COALESCE("_S9".N_ROWS, 0)) OVER (PARTITION BY "_S0".SBCUSTSTATE ORDER BY "_S1".MONTH ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n FROM "_S0" "_S0" CROSS JOIN "_S1" "_S1" LEFT JOIN "_S9" "_S9" diff --git a/tests/test_sql_refsols/part_cross_part_c_oracle.sql b/tests/test_sql_refsols/part_cross_part_c_oracle.sql index b2cc55022..69dd53b32 100644 --- a/tests/test_sql_refsols/part_cross_part_c_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_c_oracle.sql @@ -7,7 +7,7 @@ WITH "_S0" AS ( sbtxdatetime AS SBTXDATETIME FROM MAIN.SBTRANSACTION WHERE - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_S1" AS ( SELECT DISTINCT TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH @@ -24,7 +24,7 @@ WITH "_S0" AS ( FROM "_S0" "_S2" CROSS JOIN "_S3" "_S3" JOIN MAIN.SBTRANSACTION SBTRANSACTION - ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 2023 AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid @@ -35,7 +35,7 @@ WITH "_S0" AS ( ) SELECT "_S0".SBCUSTSTATE AS state, - MAX(NVL("_S9".N_ROWS, 0)) AS max_n + MAX(COALESCE("_S9".N_ROWS, 0)) AS max_n FROM "_S0" "_S0" CROSS JOIN "_S1" "_S1" LEFT JOIN "_S9" "_S9" diff --git a/tests/test_sql_refsols/part_reduced_size_oracle.sql b/tests/test_sql_refsols/part_reduced_size_oracle.sql index 0920fad07..9584a7c35 100644 --- a/tests/test_sql_refsols/part_reduced_size_oracle.sql +++ b/tests/test_sql_refsols/part_reduced_size_oracle.sql @@ -11,11 +11,18 @@ WITH "_S0" AS ( SELECT CAST("_S0".P_SIZE / 2.5 AS DOUBLE PRECISION) AS reduced_size, CAST("_S0".P_RETAILPRICE AS INT) AS retail_price_int, - LISTAGG('', 'old size: ', CAST("_S0".P_SIZE AS CLOB)) AS message, + LTRIM( + NVL2('old size: ', 'old size: ', NULL) || NVL2( + CAST("_S0".P_SIZE AS VARCHAR2(4000)), + '' || CAST("_S0".P_SIZE AS VARCHAR2(4000)), + NULL + ), + '' + ) AS message, LINEITEM.l_discount AS discount, - TO_CHAR(LINEITEM.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, - TO_CHAR(LINEITEM.l_receiptdate, 'MM/DD') AS date_md, - TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MIP.M.') AS am_pm + TO_CHAR(LINEITEM.l_receiptdate, '%d-%m-%Y') AS date_dmy, + TO_CHAR(LINEITEM.l_receiptdate, '%m/%d') AS date_md, + TO_CHAR(LINEITEM.l_receiptdate, '%H:%M%p') AS am_pm FROM "_S0" "_S0" JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_partkey = "_S0".P_PARTKEY diff --git a/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql index 8b99c5d82..4f946c5df 100644 --- a/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql +++ b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql @@ -16,7 +16,7 @@ WITH "_T4" AS ( JOIN "_T4" "_T4" ON PART.p_partkey = "_T4".L_PARTKEY JOIN TPCH.ORDERS ORDERS - ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1995 AND ORDERS.o_orderkey = "_T4".L_ORDERKEY WHERE PART.p_container LIKE 'SM%' @@ -25,17 +25,17 @@ WITH "_T4" AS ( ) SELECT ANY_VALUE("_S6".ANYTHING_P_NAME) AS name, - NVL(ANY_VALUE("_S6".SUM_L_QUANTITY), 0) AS qty_95, - NVL(SUM("_T6".L_QUANTITY), 0) AS qty_96 + COALESCE(ANY_VALUE("_S6".SUM_L_QUANTITY), 0) AS qty_95, + COALESCE(SUM("_T6".L_QUANTITY), 0) AS qty_96 FROM "_S6" "_S6" JOIN "_T4" "_T6" ON "_S6".L_PARTKEY = "_T6".L_PARTKEY JOIN TPCH.ORDERS ORDERS - ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1996 + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1996 AND ORDERS.o_orderkey = "_T6".L_ORDERKEY GROUP BY "_T6".L_PARTKEY ORDER BY - NVL(SUM("_T6".L_QUANTITY), 0) - NVL(ANY_VALUE("_S6".SUM_L_QUANTITY), 0) DESC NULLS LAST, + COALESCE(SUM("_T6".L_QUANTITY), 0) - COALESCE(ANY_VALUE("_S6".SUM_L_QUANTITY), 0) DESC NULLS LAST, 1 NULLS FIRST FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/quantile_function_test_1_oracle.sql b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql index ff802f162..a999a326e 100644 --- a/tests/test_sql_refsols/quantile_function_test_1_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql @@ -7,7 +7,7 @@ WITH "_T0" AS ( END AS EXPR_1 FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1998 ) SELECT MAX(EXPR_1) AS seventieth_order_price diff --git a/tests/test_sql_refsols/quantile_function_test_2_oracle.sql b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql index 2e1484ac1..e234b9091 100644 --- a/tests/test_sql_refsols/quantile_function_test_2_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql @@ -14,7 +14,7 @@ WITH "_S0" AS ( FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1998 ), "_T1" AS ( SELECT "_S0".N_NAME, diff --git a/tests/test_sql_refsols/quantile_function_test_3_oracle.sql b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql index 2e1484ac1..e234b9091 100644 --- a/tests/test_sql_refsols/quantile_function_test_3_oracle.sql +++ b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql @@ -14,7 +14,7 @@ WITH "_S0" AS ( FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1998 ), "_T1" AS ( SELECT "_S0".N_NAME, diff --git a/tests/test_sql_refsols/quantile_test_1_oracle.sql b/tests/test_sql_refsols/quantile_test_1_oracle.sql index ff802f162..a999a326e 100644 --- a/tests/test_sql_refsols/quantile_test_1_oracle.sql +++ b/tests/test_sql_refsols/quantile_test_1_oracle.sql @@ -7,7 +7,7 @@ WITH "_T0" AS ( END AS EXPR_1 FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1998 ) SELECT MAX(EXPR_1) AS seventieth_order_price diff --git a/tests/test_sql_refsols/quantile_test_2_oracle.sql b/tests/test_sql_refsols/quantile_test_2_oracle.sql index 2e1484ac1..e234b9091 100644 --- a/tests/test_sql_refsols/quantile_test_2_oracle.sql +++ b/tests/test_sql_refsols/quantile_test_2_oracle.sql @@ -14,7 +14,7 @@ WITH "_S0" AS ( FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1998 ), "_T1" AS ( SELECT "_S0".N_NAME, diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql index fb40dce74..9aeef5f1f 100644 --- a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -15,7 +15,7 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T4" JOIN "_S1" "_S3" - ON "_S3".CA_DT < TRUNC(DATE_ADD(CAST("_T4".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S3".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S3".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON DEVICES.de_product_id = 800544 @@ -28,7 +28,7 @@ WITH "_T2" AS ( SUM("_S7".N_ROWS) AS SUM_N_ROWS FROM "_T2" "_T2" JOIN "_S1" "_S1" - ON "_S1".CA_DT < TRUNC(DATE_ADD(CAST("_T2".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S1".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S1".CA_DT >= "_T2".PR_RELEASE LEFT JOIN "_S7" "_S7" ON "_S1".CA_DT = "_S7".CA_DT @@ -39,14 +39,14 @@ WITH "_T2" AS ( TRUNC(CAST("_S11".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER FROM "_T2" "_T10" JOIN "_S1" "_S11" - ON "_S11".CA_DT < TRUNC(DATE_ADD(CAST("_T10".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S11".CA_DT < TRUNC(CAST("_T10".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S11".CA_DT >= "_T10".PR_RELEASE ), "_S17" AS ( SELECT "_S15".CA_DT FROM "_T2" "_T11" JOIN "_S1" "_S15" - ON "_S15".CA_DT < TRUNC(DATE_ADD(CAST("_T11".PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + ON "_S15".CA_DT < TRUNC(CAST("_T11".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S15".CA_DT >= "_T11".PR_RELEASE ), "_S23" AS ( SELECT @@ -70,10 +70,10 @@ WITH "_T2" AS ( ) SELECT "_S22".QUARTER AS quarter, - NVL("_S23".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, - NVL("_S22".SUM_N_ROWS, 0) AS n_sold, + COALESCE("_S23".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + COALESCE("_S22".SUM_N_ROWS, 0) AS n_sold, ROUND( - SUM(NVL("_S23".NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY "_S22".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL("_S22".SUM_N_ROWS, 0)) OVER (ORDER BY "_S22".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(COALESCE("_S23".NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY "_S22".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(COALESCE("_S22".SUM_N_ROWS, 0)) OVER (ORDER BY "_S22".QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS quarter_cum FROM "_S22" "_S22" diff --git a/tests/test_sql_refsols/quarter_function_test_oracle.sql b/tests/test_sql_refsols/quarter_function_test_oracle.sql index 6b387d252..10bcb68c5 100644 --- a/tests/test_sql_refsols/quarter_function_test_oracle.sql +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -29,30 +29,78 @@ SELECT TO_DATE('2023-07-01', 'YYYY-MM-DD') AS alias2, TO_DATE('2023-10-01', 'YYYY-MM-DD') AS alias3, TO_DATE('2023-01-01', 'YYYY-MM-DD') AS alias4, - TIME_STR_TO_TIME('2023-04-02 02:00:00') AS chain1, + TO_DATE('2023-04-02 02:00:00', 'YYYY-MM-DD HH24:MI:SS') AS chain1, TO_DATE('2023-07-01', 'YYYY-MM-DD') AS chain2, TO_DATE('2023-10-01', 'YYYY-MM-DD') AS chain3, - TIME_STR_TO_TIME('2023-04-15 12:30:45') AS plus_1q, - TIME_STR_TO_TIME('2023-07-15 12:30:45') AS plus_2q, + TO_DATE('2023-04-15 12:30:45', 'YYYY-MM-DD HH24:MI:SS') AS plus_1q, + TO_DATE('2023-07-15 12:30:45', 'YYYY-MM-DD HH24:MI:SS') AS plus_2q, TO_DATE('2023-10-15', 'YYYY-MM-DD') AS plus_3q, - TIME_STR_TO_TIME('2022-10-15 12:30:45') AS minus_1q, - TIME_STR_TO_TIME('2022-07-15 12:30:45') AS minus_2q, + TO_DATE('2022-10-15 12:30:45', 'YYYY-MM-DD HH24:MI:SS') AS minus_1q, + TO_DATE('2022-07-15 12:30:45', 'YYYY-MM-DD HH24:MI:SS') AS minus_2q, TO_DATE('2022-04-15', 'YYYY-MM-DD') AS minus_3q, TO_DATE('2023-08-15', 'YYYY-MM-DD') AS syntax1, TO_DATE('2024-02-15', 'YYYY-MM-DD') AS syntax2, TO_DATE('2024-08-15', 'YYYY-MM-DD') AS syntax3, TO_DATE('2022-08-15', 'YYYY-MM-DD') AS syntax4, - DATEDIFF(CAST('2023-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff1, - DATEDIFF(CAST('2023-07-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff2, - DATEDIFF(CAST('2023-10-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff3, - DATEDIFF(CAST('2023-12-31' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff4, - DATEDIFF(CAST('2024-01-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff5, - DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff6, - DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2022-10-15' AS TIMESTAMP), QUARTER) AS q_diff7, - DATEDIFF(CAST('2025-01-01' AS TIMESTAMP), CAST('2020-01-01' AS TIMESTAMP), QUARTER) AS q_diff8, - DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2023-04-15' AS TIMESTAMP), QUARTER) AS q_diff9, - DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2024-01-15' AS TIMESTAMP), QUARTER) AS q_diff10, - DATEDIFF(CAST('2023-04-01' AS TIMESTAMP), CAST('2023-03-31' AS TIMESTAMP), QUARTER) AS q_diff11, - DATEDIFF(CAST('2024-01-01' AS TIMESTAMP), CAST('2023-12-31' AS TIMESTAMP), QUARTER) AS q_diff12 + ( + EXTRACT(YEAR FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff1, + ( + EXTRACT(YEAR FROM CAST(CAST('2023-07-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-07-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff2, + ( + EXTRACT(YEAR FROM CAST(CAST('2023-10-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-10-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff3, + ( + EXTRACT(YEAR FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff4, + ( + EXTRACT(YEAR FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff5, + ( + EXTRACT(YEAR FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff6, + ( + EXTRACT(YEAR FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2022-10-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2022-10-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff7, + ( + EXTRACT(YEAR FROM CAST(CAST('2025-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2020-01-01' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2025-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2020-01-01' AS TIMESTAMP) AS DATE)) + ) AS q_diff8, + ( + EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff9, + ( + EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) + ) AS q_diff10, + ( + EXTRACT(YEAR FROM CAST(CAST('2023-04-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-03-31' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2023-04-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-03-31' AS TIMESTAMP) AS DATE)) + ) AS q_diff11, + ( + EXTRACT(YEAR FROM CAST(CAST('2024-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(CAST('2024-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) + ) AS q_diff12 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql index b94477187..cde94b2e9 100644 --- a/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql +++ b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql @@ -27,7 +27,7 @@ WITH "_T" AS ( ) SELECT REGION.r_name AS region_name, - NVL("_S5".SUM_N_ROWS, 0) AS n_orders + COALESCE("_S5".SUM_N_ROWS, 0) AS n_orders FROM TPCH.REGION REGION LEFT JOIN "_S5" "_S5" ON REGION.r_regionkey = "_S5".N_REGIONKEY diff --git a/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql index 47d9ebde7..7188b31dd 100644 --- a/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql +++ b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql @@ -8,7 +8,7 @@ WITH "_T" AS ( ON CUSTOMER.c_nationkey = NATION.n_nationkey JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1992 ), "_T_2" AS ( SELECT LINEITEM.l_partkey AS L_PARTKEY, @@ -16,7 +16,7 @@ WITH "_T" AS ( ROW_NUMBER() OVER (PARTITION BY "_T".N_REGIONKEY ORDER BY LINEITEM.l_quantity DESC, LINEITEM.l_linenumber) AS "_W" FROM "_T" "_T" JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1992 AND LINEITEM.l_orderkey = "_T".O_ORDERKEY WHERE "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/simple_cross_10_oracle.sql b/tests/test_sql_refsols/simple_cross_10_oracle.sql index 837218a07..c52cf5d4b 100644 --- a/tests/test_sql_refsols/simple_cross_10_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_10_oracle.sql @@ -18,7 +18,7 @@ WITH "_S4" AS ( ) SELECT "_S4".R_NAME AS region_name, - NVL("_S5".N_ROWS, 0) AS n_other_nations + COALESCE("_S5".N_ROWS, 0) AS n_other_nations FROM "_S4" "_S4" LEFT JOIN "_S5" "_S5" ON "_S4".R_REGIONKEY = "_S5".R_REGIONKEY diff --git a/tests/test_sql_refsols/simple_cross_14_oracle.sql b/tests/test_sql_refsols/simple_cross_14_oracle.sql index 79d91e1fe..1d8cb983f 100644 --- a/tests/test_sql_refsols/simple_cross_14_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_14_oracle.sql @@ -11,7 +11,7 @@ WITH "_S1" AS ( SELECT REGION.r_name AS region_name, 'foo' AS x, - NVL("_S1".N_ROWS, 0) AS n + COALESCE("_S1".N_ROWS, 0) AS n FROM TPCH.REGION REGION LEFT JOIN "_S1" "_S1" ON REGION.r_regionkey = "_S1".N_REGIONKEY diff --git a/tests/test_sql_refsols/simple_cross_3_oracle.sql b/tests/test_sql_refsols/simple_cross_3_oracle.sql index e366e84ac..a383093a1 100644 --- a/tests/test_sql_refsols/simple_cross_3_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_3_oracle.sql @@ -20,8 +20,8 @@ JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_acctbal < 0 AND CUSTOMER.c_nationkey = "_S5".N_NATIONKEY JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 4 - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + AND EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)) = 4 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1992 JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_shipmode = 'SHIP' JOIN TPCH.SUPPLIER SUPPLIER diff --git a/tests/test_sql_refsols/simple_cross_4_oracle.sql b/tests/test_sql_refsols/simple_cross_4_oracle.sql index c572b3049..5142d3964 100644 --- a/tests/test_sql_refsols/simple_cross_4_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_4_oracle.sql @@ -16,7 +16,7 @@ WITH "_S2" AS ( ) SELECT "_S2".R_NAME AS region_name, - NVL("_S3".N_ROWS, 0) AS n_other_regions + COALESCE("_S3".N_ROWS, 0) AS n_other_regions FROM "_S2" "_S2" LEFT JOIN "_S3" "_S3" ON "_S2".R_REGIONKEY = "_S3".R_REGIONKEY diff --git a/tests/test_sql_refsols/simple_cross_5_oracle.sql b/tests/test_sql_refsols/simple_cross_5_oracle.sql index 54f4ba2de..8ea9255bd 100644 --- a/tests/test_sql_refsols/simple_cross_5_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_5_oracle.sql @@ -26,8 +26,8 @@ WITH "_T1" AS ( SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY FROM "_S0" "_S0" JOIN TPCH.ORDERS ORDERS - ON EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1 - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + ON EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)) = 1 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1998 JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_discount = 0 AND LINEITEM.l_orderkey = ORDERS.o_orderkey @@ -49,7 +49,7 @@ WITH "_T1" AS ( WHEN ( NOT SUM_L_QUANTITY IS NULL AND SUM_L_QUANTITY > 0 ) - THEN NVL(SUM_L_QUANTITY, 0) + THEN COALESCE(SUM_L_QUANTITY, 0) ELSE NULL END DESC) AS "_W" FROM "_T4" @@ -59,7 +59,7 @@ WITH "_T1" AS ( WHEN ( NOT SUM_L_QUANTITY IS NULL AND SUM_L_QUANTITY > 0 ) - THEN NVL(SUM_L_QUANTITY, 0) + THEN COALESCE(SUM_L_QUANTITY, 0) ELSE NULL END AS TOTAL_QTY, O_ORDERPRIORITY, diff --git a/tests/test_sql_refsols/simple_cross_7_oracle.sql b/tests/test_sql_refsols/simple_cross_7_oracle.sql index e41a0c336..c1c93cb24 100644 --- a/tests/test_sql_refsols/simple_cross_7_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_7_oracle.sql @@ -18,7 +18,7 @@ WITH "_S3" AS ( ) SELECT PART.p_partkey AS original_part_key, - NVL("_S3".N_ROWS, 0) AS n_other_parts + COALESCE("_S3".N_ROWS, 0) AS n_other_parts FROM TPCH.PART PART LEFT JOIN "_S3" "_S3" ON PART.p_partkey = "_S3".P_PARTKEY diff --git a/tests/test_sql_refsols/simple_cross_8_oracle.sql b/tests/test_sql_refsols/simple_cross_8_oracle.sql index f33acc021..006915d21 100644 --- a/tests/test_sql_refsols/simple_cross_8_oracle.sql +++ b/tests/test_sql_refsols/simple_cross_8_oracle.sql @@ -33,8 +33,8 @@ JOIN TPCH.CUSTOMER CUSTOMER JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000007' JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 3 - AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1998 + ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATE)) = 3 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1998 AND LINEITEM.l_orderkey = ORDERS.o_orderkey JOIN "_S15" "_S15" ON LINEITEM.l_suppkey = "_S15".S_SUPPKEY AND "_S0".R_NAME = "_S15".R_NAME diff --git a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql index 4c127a17b..8c7859488 100644 --- a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql +++ b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql @@ -12,14 +12,14 @@ SELECT CAST('-5.888' AS DOUBLE PRECISION) AS f5, -6.0 AS f6, 0.0 AS f7, - CAST(1 AS CLOB) AS s1, - CAST(2.2 AS CLOB) AS s2, - CAST('3' AS CLOB) AS s3, - CAST('4.3' AS CLOB) AS s4, - CAST('-5.888' AS CLOB) AS s5, - CAST(-6.1 AS CLOB) AS s6, - CAST(0.1 AS CLOB) AS s7, - CAST('0.0' AS CLOB) AS s8, - CAST('abc def' AS CLOB) AS s9 + CAST(1 AS VARCHAR2(4000)) AS s1, + CAST(2.2 AS VARCHAR2(4000)) AS s2, + '3' AS s3, + '4.3' AS s4, + '-5.888' AS s5, + CAST(-6.1 AS VARCHAR2(4000)) AS s6, + CAST(0.1 AS VARCHAR2(4000)) AS s7, + '0.0' AS s8, + 'abc def' AS s9 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql index 332ecf40c..e0841feef 100644 --- a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql +++ b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql @@ -6,9 +6,9 @@ SELECT NULL AS s5, LEAST(20.22, 10.22, -0.34) AS s6, LEAST( - TIME_STR_TO_TIME('2025-01-01 00:00:00'), - TIME_STR_TO_TIME('2024-01-01 00:00:00'), - TIME_STR_TO_TIME('2023-01-01 00:00:00') + TO_DATE('2025-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_DATE('2024-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_DATE('2023-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ) AS s7, LEAST('', 'alphabet soup', 'Hello World') AS s8, NULL AS s9, @@ -19,9 +19,9 @@ SELECT NULL AS l5, GREATEST(20.22, 100.22, -0.34) AS l6, GREATEST( - TIME_STR_TO_TIME('2025-01-01 00:00:00'), - TIME_STR_TO_TIME('2024-01-01 00:00:00'), - TIME_STR_TO_TIME('2023-01-01 00:00:00') + TO_DATE('2025-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_DATE('2024-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_DATE('2023-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ) AS l7, GREATEST('', 'alphabet soup', 'Hello World') AS l8, NULL AS l9 diff --git a/tests/test_sql_refsols/simplification_1_oracle.sql b/tests/test_sql_refsols/simplification_1_oracle.sql index ad3f7197f..295d976e7 100644 --- a/tests/test_sql_refsols/simplification_1_oracle.sql +++ b/tests/test_sql_refsols/simplification_1_oracle.sql @@ -19,7 +19,7 @@ SELECT COUNT(*) < 25 AS s17, COUNT(*) <= 25 AS s18, COUNT(*) AS s19, - AVG(NVL(LENGTH(sbcustname), 0)) AS s20, + AVG(COALESCE(LENGTH(sbcustname), 0)) AS s20, TRUE AS s21, TRUE AS s22, TRUE AS s23 diff --git a/tests/test_sql_refsols/simplification_2_oracle.sql b/tests/test_sql_refsols/simplification_2_oracle.sql index 9dbcca858..b4df6c451 100644 --- a/tests/test_sql_refsols/simplification_2_oracle.sql +++ b/tests/test_sql_refsols/simplification_2_oracle.sql @@ -46,5 +46,5 @@ SELECT NULL AS s44, NULL AS s45, NULL AS s46, - NVL(MAX(sbcustname), '') LIKE '%r%' AS s47 + COALESCE(MAX(sbcustname), '') LIKE '%r%' AS s47 FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_3_oracle.sql b/tests/test_sql_refsols/simplification_3_oracle.sql index 8b3f19301..c48b4fe0e 100644 --- a/tests/test_sql_refsols/simplification_3_oracle.sql +++ b/tests/test_sql_refsols/simplification_3_oracle.sql @@ -2,24 +2,24 @@ WITH "_T2" AS ( SELECT ABS(CAST(sbcustpostalcode AS INT)) AS EXPR_13, ROW_NUMBER() OVER (ORDER BY sbcustname) AS RANK, - AVG(CAST(ABS(NVL(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER () AS RAVG1, - NVL( - AVG(CAST(ABS(NVL(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), + AVG(CAST(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER () AS RAVG1, + COALESCE( + AVG(CAST(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), 0.1 ) AS RAVG2, COUNT(CAST(sbcustpostalcode AS INT)) OVER () AS RCNT1, - NVL( + COALESCE( COUNT(CAST(sbcustpostalcode AS INT)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0.1 ) AS RCNT2, COUNT(*) OVER () AS RSIZ1, - NVL( + COALESCE( COUNT(*) OVER (ORDER BY sbcustname ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING), 0.1 ) AS RSIZ2, - SUM(ABS(NVL(CAST(sbcustpostalcode AS INT), 0))) OVER () AS RSUM1, - NVL( - SUM(ABS(NVL(CAST(sbcustpostalcode AS INT), 0))) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0))) OVER () AS RSUM1, + COALESCE( + SUM(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0))) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0.1 ) AS RSUM2 FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql index cc5ae425e..385abc796 100644 --- a/tests/test_sql_refsols/simplification_4_oracle.sql +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -5,42 +5,42 @@ WITH "_T" AS ( ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS "_W_2" FROM MAIN.SBTRANSACTION WHERE - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ) SELECT SBTXDATETIME AS date_time, - DATE_SUB(TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'WEEK'), 8, WEEK) AS s00, + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'WEEK') + NUMTODSINTERVAL(8, 'week') AS s00, FALSE AS s01, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (1, 2, 3) AS s02, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (4, 5, 6) AS s03, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (7, 8, 9) AS s04, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (10, 11, 12) AS s05, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (1, 2, 3) AS s02, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (4, 5, 6) AS s03, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (7, 8, 9) AS s04, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (10, 11, 12) AS s05, FALSE AS s06, FALSE AS s07, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 4 AS s08, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 7 AS s09, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 10 AS s10, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) < 4 AS s08, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) < 7 AS s09, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) < 10 AS s10, TRUE AS s11, FALSE AS s12, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 3 AS s13, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 6 AS s14, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 9 AS s15, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) <= 3 AS s13, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) <= 6 AS s14, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) <= 9 AS s15, TRUE AS s16, TRUE AS s17, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 3 AS s18, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 6 AS s19, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 9 AS s20, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) > 3 AS s18, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) > 6 AS s19, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) > 9 AS s20, FALSE AS s21, TRUE AS s22, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 4 AS s23, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 7 AS s24, - EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 10 AS s25, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) >= 4 AS s23, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) >= 7 AS s24, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) >= 10 AS s25, FALSE AS s26, TRUE AS s27, - NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (1, 2, 3) AS s28, - NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (4, 5, 6) AS s29, - NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (7, 8, 9) AS s30, - NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (10, 11, 12) AS s31, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (1, 2, 3) AS s28, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (4, 5, 6) AS s29, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (7, 8, 9) AS s30, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (10, 11, 12) AS s31, TRUE AS s32, 2024 AS s33, 3 AS s34, diff --git a/tests/test_sql_refsols/singular4_oracle.sql b/tests/test_sql_refsols/singular4_oracle.sql index 1c8f5a555..a6f6d10f4 100644 --- a/tests/test_sql_refsols/singular4_oracle.sql +++ b/tests/test_sql_refsols/singular4_oracle.sql @@ -22,5 +22,5 @@ LEFT JOIN "_S1" "_S1" WHERE CUSTOMER.c_nationkey = 6 ORDER BY - NVL("_S1".O_ORDERDATE, TO_DATE('2000-01-01', 'YYYY-MM-DD')) + COALESCE("_S1".O_ORDERDATE, TO_DATE('2000-01-01', 'YYYY-MM-DD')) FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular7_oracle.sql b/tests/test_sql_refsols/singular7_oracle.sql index aa135b2cd..9c3793635 100644 --- a/tests/test_sql_refsols/singular7_oracle.sql +++ b/tests/test_sql_refsols/singular7_oracle.sql @@ -4,7 +4,7 @@ WITH "_S3" AS ( l_suppkey AS L_SUPPKEY FROM TPCH.LINEITEM WHERE - EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 + EXTRACT(YEAR FROM CAST(l_shipdate AS DATE)) = 1994 ), "_T4" AS ( SELECT PARTSUPP.ps_suppkey AS PS_SUPPKEY, @@ -23,11 +23,11 @@ WITH "_S3" AS ( PS_SUPPKEY, ANYTHING_P_NAME, COUNT_L_SUPPKEY, - ROW_NUMBER() OVER (PARTITION BY PS_SUPPKEY ORDER BY NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) DESC, ANYTHING_P_NAME) AS "_W" + ROW_NUMBER() OVER (PARTITION BY PS_SUPPKEY ORDER BY COALESCE(COUNT_L_SUPPKEY, 0) DESC, ANYTHING_P_NAME) AS "_W" FROM "_T4" ), "_S5" AS ( SELECT - NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) AS N_ORDERS, + COALESCE(COUNT_L_SUPPKEY, 0) AS N_ORDERS, ANYTHING_P_NAME, PS_SUPPKEY FROM "_T" diff --git a/tests/test_sql_refsols/smoke_a_oracle.sql b/tests/test_sql_refsols/smoke_a_oracle.sql index c16c6f71e..c561ea955 100644 --- a/tests/test_sql_refsols/smoke_a_oracle.sql +++ b/tests/test_sql_refsols/smoke_a_oracle.sql @@ -1,18 +1,32 @@ SELECT p_partkey AS key, - CAST(LISTAGG( - '', - SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), - SUBSTR(p_brand, 8), - SUBSTR( - p_brand, - CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END, - CASE - WHEN ABS(-2) > LENGTH(p_brand) - THEN LENGTH(p_brand) + -1 - ELSE GREATEST(1, 0) - END - ) + CAST(LTRIM( + NVL2( + SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), + '' || SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), + NULL + ) || NVL2(SUBSTR(p_brand, 8), '' || SUBSTR(p_brand, 8), NULL) || NVL2( + SUBSTR( + p_brand, + CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END, + CASE + WHEN ABS(-2) > LENGTH(p_brand) + THEN LENGTH(p_brand) + -1 + ELSE GREATEST(1, 0) + END + ), + '' || SUBSTR( + p_brand, + CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END, + CASE + WHEN ABS(-2) > LENGTH(p_brand) + THEN LENGTH(p_brand) + -1 + ELSE GREATEST(1, 0) + END + ), + NULL + ), + '' ) AS INT) AS a, UPPER( LEAST( @@ -22,11 +36,11 @@ SELECT ) AS b, TRIM('o' FROM SUBSTR(p_name, 1, 2)) AS c, CASE - WHEN LENGTH(CAST(p_size AS CLOB)) >= 3 - THEN SUBSTR(CAST(p_size AS CLOB), 1, 3) - ELSE SUBSTR(CONCAT('000', CAST(p_size AS CLOB)), -3) + WHEN LENGTH(CAST(p_size AS VARCHAR2(4000))) >= 3 + THEN SUBSTR(CAST(p_size AS VARCHAR2(4000)), 1, 3) + ELSE SUBSTR(CONCAT('000', CAST(p_size AS VARCHAR2(4000))), -3) END AS d, - SUBSTR(CONCAT(CAST(p_size AS CLOB), '000'), 1, 3) AS e, + SUBSTR(CONCAT(CAST(p_size AS VARCHAR2(4000)), '000'), 1, 3) AS e, REPLACE(p_mfgr, 'Manufacturer#', 'm') AS f, REPLACE(LOWER(p_container), ' ', '') AS g, CASE diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql index d41b0d971..d36c1044a 100644 --- a/tests/test_sql_refsols/smoke_b_oracle.sql +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -1,46 +1,116 @@ SELECT o_orderkey AS key, - LISTAGG( - '_', - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATETIME)), - EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)), - EXTRACT(DAY FROM CAST(o_orderdate AS DATETIME)) + LTRIM( + NVL2( + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)), + '_' || EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)), + NULL + ) || NVL2( + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)), + '_' || EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)), + NULL + ) || NVL2( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), + '_' || EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), + NULL + ) || NVL2( + EXTRACT(DAY FROM CAST(o_orderdate AS DATE)), + '_' || EXTRACT(DAY FROM CAST(o_orderdate AS DATE)), + NULL + ), + '_' ) AS a, - LISTAGG( - ':', - CASE - WHEN DAY_OF_WEEK(o_orderdate) = 0 - THEN 'Sunday' - WHEN DAY_OF_WEEK(o_orderdate) = 1 - THEN 'Monday' - WHEN DAY_OF_WEEK(o_orderdate) = 2 - THEN 'Tuesday' - WHEN DAY_OF_WEEK(o_orderdate) = 3 - THEN 'Wednesday' - WHEN DAY_OF_WEEK(o_orderdate) = 4 - THEN 'Thursday' - WHEN DAY_OF_WEEK(o_orderdate) = 5 - THEN 'Friday' - WHEN DAY_OF_WEEK(o_orderdate) = 6 - THEN 'Saturday' - END, - DAY_OF_WEEK(o_orderdate) + LTRIM( + NVL2( + CASE + WHEN TO_CHAR(o_orderdate, 'D') = 1 + THEN 'Sunday' + WHEN TO_CHAR(o_orderdate, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(o_orderdate, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(o_orderdate, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(o_orderdate, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(o_orderdate, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(o_orderdate, 'D') = 7 + THEN 'Saturday' + END, + ':' || CASE + WHEN TO_CHAR(o_orderdate, 'D') = 1 + THEN 'Sunday' + WHEN TO_CHAR(o_orderdate, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(o_orderdate, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(o_orderdate, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(o_orderdate, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(o_orderdate, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(o_orderdate, 'D') = 7 + THEN 'Saturday' + END, + NULL + ) || NVL2( + ( + MOD(( + TO_CHAR(o_orderdate, 'D') + -1 + ), 7) + ), + ':' || MOD(( + TO_CHAR(o_orderdate, 'D') + -1 + ), 7), + NULL + ), + ':' ) AS b, - DATE_SUB(DATE_ADD(TRUNC(CAST(o_orderdate AS TIMESTAMP), 'YEAR'), 6, 'MONTH'), 13, DAY) AS c, - DATE_ADD(DATE_ADD(TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER'), 1, 'YEAR'), 25, 'HOUR') AS d, - TIME_STR_TO_TIME('2025-01-01 12:35:00') AS e, - TIME_STR_TO_TIME('2025-07-22 12:00:00') AS f, + TRUNC(CAST(o_orderdate AS TIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(6, 'month') + NUMTODSINTERVAL(13, 'day') AS c, + TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER') + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(25, 'hour') AS d, + TO_DATE('2025-01-01 12:35:00', 'YYYY-MM-DD HH24:MI:SS') AS e, + TO_DATE('2025-07-22 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS f, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, - LISTAGG(';', 12, 20, 6) AS h, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), YEAR) AS i, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), QUARTER) AS j, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), MONTH) AS k, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), WEEK) AS l, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), DAY) AS m, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), HOUR) AS n, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), MINUTE) AS o, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), SECOND) AS p, + LTRIM( + NVL2(12, ';' || 12, NULL) || NVL2(20, ';' || 20, NULL) || NVL2(6, ';' || 6, NULL), + ';' + ) AS h, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) AS i, + ( + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + ) * 4 + ( + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + ) AS j, + ( + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + ) AS k, + FLOOR( + ( + CAST(o_orderdate AS DATE) - CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) + ( + MOD(( + TO_CHAR('1993-05-25 12:45:36', 'D') + -1 + ), 7) + ) - ( + MOD(( + TO_CHAR(o_orderdate, 'D') + -1 + ), 7) + ) + ) / 7 + ) AS l, + CAST(o_orderdate AS DATE) - CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) AS m, + ( + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) AS DATETIME), 'HH24') + ) * 24 AS n, + ( + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'MI') - TRUNC(CAST(CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) AS DATETIME), 'MI') + ) * 1440 AS o, + ( + CAST(o_orderdate AS DATE) - CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) + ) * 86400 AS p, TRUNC(CAST(o_orderdate AS TIMESTAMP), 'WEEK') AS q FROM TPCH.ORDERS WHERE diff --git a/tests/test_sql_refsols/smoke_c_oracle.sql b/tests/test_sql_refsols/smoke_c_oracle.sql index 7d3caa12e..7cd5610d8 100644 --- a/tests/test_sql_refsols/smoke_c_oracle.sql +++ b/tests/test_sql_refsols/smoke_c_oracle.sql @@ -25,8 +25,8 @@ WITH "_T1" AS ( ) SELECT COUNT(*) AS a, - NVL(SUM(FLOOR(C_ACCTBAL)), 0) AS b, - NVL(SUM(CEIL(C_ACCTBAL)), 0) AS c, + COALESCE(SUM(FLOOR(C_ACCTBAL)), 0) AS b, + COALESCE(SUM(CEIL(C_ACCTBAL)), 0) AS c, COUNT(DISTINCT C_MKTSEGMENT) AS d, ROUND(AVG(ABS(C_ACCTBAL)), 4) AS e, MIN(C_ACCTBAL) AS f, @@ -37,7 +37,7 @@ SELECT ROUND(VARIANCE(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END), 4) AS k, FLOOR(STDDEV_POP(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END)) AS l, ROUND(STDDEV(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END), 4) AS m, - ROUND(AVG(NVL(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END, 0)), 2) AS n, + ROUND(AVG(COALESCE(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END, 0)), 2) AS n, SUM(NOT CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS o, SUM(CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS p, MAX(EXPR_30) AS q, diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql index 040bd90a6..d10b30aee 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql @@ -2,27 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, ( MOD(( - DAY_OF_WEEK(sbtxdatetime) + 2 + TO_CHAR(sbtxdatetime, 'D') + 1 ), 7) ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql index eabd3e5ac..d717d1754 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql @@ -2,25 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, MOD(( - DAY_OF_WEEK(sbtxdatetime) + 2 + TO_CHAR(sbtxdatetime, 'D') + 1 ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql index 1fc16f17f..4a88fd71c 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql @@ -2,27 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, ( MOD(( - DAY_OF_WEEK(sbtxdatetime) + 6 + TO_CHAR(sbtxdatetime, 'D') + 5 ), 7) ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql index b4d67c626..e58c89403 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql @@ -2,25 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, MOD(( - DAY_OF_WEEK(sbtxdatetime) + 6 + TO_CHAR(sbtxdatetime, 'D') + 5 ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql index 584872c0b..05f3feba9 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql @@ -2,27 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, ( MOD(( - DAY_OF_WEEK(sbtxdatetime) + 1 + TO_CHAR(sbtxdatetime, 'D') + 0 ), 7) ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql index e9836ebc8..5b7d56dec 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql @@ -2,25 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, MOD(( - DAY_OF_WEEK(sbtxdatetime) + 1 + TO_CHAR(sbtxdatetime, 'D') + 0 ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql index f7f489a92..4e176cadb 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql @@ -2,23 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, - DAY_OF_WEEK(sbtxdatetime) + 1 AS dayofweek + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + -1 + ), 7) + ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql index d4f0b58ab..5c2483132 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql @@ -2,23 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, - DAY_OF_WEEK(sbtxdatetime) AS dayofweek + MOD(( + TO_CHAR(sbtxdatetime, 'D') + -1 + ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql index 9d515872c..c32f8fc3f 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql @@ -2,27 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, ( MOD(( - DAY_OF_WEEK(sbtxdatetime) + 3 + TO_CHAR(sbtxdatetime, 'D') + 2 ), 7) ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql index 955c36257..c787be52d 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql @@ -2,25 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, MOD(( - DAY_OF_WEEK(sbtxdatetime) + 3 + TO_CHAR(sbtxdatetime, 'D') + 2 ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql index 0c10a5870..599cc58b8 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql @@ -2,27 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, ( MOD(( - DAY_OF_WEEK(sbtxdatetime) + 5 + TO_CHAR(sbtxdatetime, 'D') + 4 ), 7) ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql index 2cc7da32c..fbde2d92e 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql @@ -2,25 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, MOD(( - DAY_OF_WEEK(sbtxdatetime) + 5 + TO_CHAR(sbtxdatetime, 'D') + 4 ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql index 66d595c70..3f5362969 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql @@ -2,27 +2,27 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, ( MOD(( - DAY_OF_WEEK(sbtxdatetime) + 4 + TO_CHAR(sbtxdatetime, 'D') + 3 ), 7) ) + 1 AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql index 74b1fee96..ce549c8aa 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql @@ -2,25 +2,25 @@ SELECT sbtxdatetime AS date_time, TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, CASE - WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 THEN 'Monday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 THEN 'Tuesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 THEN 'Wednesday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 THEN 'Thursday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 THEN 'Friday' - WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 THEN 'Saturday' END AS dayname, MOD(( - DAY_OF_WEEK(sbtxdatetime) + 4 + TO_CHAR(sbtxdatetime, 'D') + 3 ), 7) AS dayofweek FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/string_format_specifiers_oracle.sql b/tests/test_sql_refsols/string_format_specifiers_oracle.sql index acb6e4483..cb5c13d68 100644 --- a/tests/test_sql_refsols/string_format_specifiers_oracle.sql +++ b/tests/test_sql_refsols/string_format_specifiers_oracle.sql @@ -1,18 +1,18 @@ SELECT - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'YYYY') AS d1, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'YY') AS d2, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MM') AS d3, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'Mon') AS d4, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MMMM') AS d5, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DD') AS d6, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DY') AS d7, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DYDY') AS d8, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'HH24') AS d9, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'HH12') AS d10, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MI') AS d11, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'SS') AS d12, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'P.M.') AS d13, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), '.FF') AS d14, - TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'TZH:TZM') AS d15 + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'YYYY') AS d1, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'YY') AS d2, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MM') AS d3, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'Mon') AS d4, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MMMM') AS d5, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DD') AS d6, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DY') AS d7, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DYDY') AS d8, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'HH24') AS d9, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'HH12') AS d10, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MI') AS d11, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'SS') AS d12, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'P.M.') AS d13, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), '.FF') AS d14, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'TZH:TZM') AS d15 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/string_functions_oracle.sql b/tests/test_sql_refsols/string_functions_oracle.sql index 86bedce30..97366cb90 100644 --- a/tests/test_sql_refsols/string_functions_oracle.sql +++ b/tests/test_sql_refsols/string_functions_oracle.sql @@ -6,7 +6,10 @@ SELECT CUSTOMER.c_name LIKE '%z' AS ends_with_z, CUSTOMER.c_name LIKE '%sub%' AS contains_sub, CUSTOMER.c_name LIKE '%test%' AS matches_like, - LISTAGG('::', CUSTOMER.c_name, NATION.n_name) AS joined_string, + LTRIM( + NVL2(CUSTOMER.c_name, '::' || CUSTOMER.c_name, NULL) || NVL2(NATION.n_name, '::' || NATION.n_name, NULL), + '::' + ) AS joined_string, CASE WHEN LENGTH(CUSTOMER.c_name) >= 20 THEN SUBSTR(CUSTOMER.c_name, 1, 20) diff --git a/tests/test_sql_refsols/supplier_best_part_oracle.sql b/tests/test_sql_refsols/supplier_best_part_oracle.sql index c596df042..e4aa338d3 100644 --- a/tests/test_sql_refsols/supplier_best_part_oracle.sql +++ b/tests/test_sql_refsols/supplier_best_part_oracle.sql @@ -6,7 +6,7 @@ WITH "_S2" AS ( SUM(l_quantity) AS SUM_L_QUANTITY FROM TPCH.LINEITEM WHERE - EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_tax = 0 + EXTRACT(YEAR FROM CAST(l_shipdate AS DATE)) = 1994 AND l_tax = 0 GROUP BY l_partkey, l_suppkey @@ -16,7 +16,7 @@ WITH "_S2" AS ( "_S2".N_ROWS, PART.p_name AS P_NAME, "_S2".SUM_L_QUANTITY, - ROW_NUMBER() OVER (PARTITION BY "_S2".L_SUPPKEY ORDER BY NVL("_S2".SUM_L_QUANTITY, 0) DESC) AS "_W" + ROW_NUMBER() OVER (PARTITION BY "_S2".L_SUPPKEY ORDER BY COALESCE("_S2".SUM_L_QUANTITY, 0) DESC) AS "_W" FROM "_S2" "_S2" JOIN TPCH.PART PART ON PART.p_partkey = "_S2".L_PARTKEY @@ -24,7 +24,7 @@ WITH "_S2" AS ( SELECT SUPPLIER.s_name AS supplier_name, "_T".P_NAME AS part_name, - NVL("_T".SUM_L_QUANTITY, 0) AS total_quantity, + COALESCE("_T".SUM_L_QUANTITY, 0) AS total_quantity, "_T".N_ROWS AS n_shipments FROM TPCH.SUPPLIER SUPPLIER JOIN TPCH.NATION NATION diff --git a/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql index b95a33666..7f4286672 100644 --- a/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql +++ b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql @@ -8,8 +8,8 @@ WITH "_S7" AS ( AND PART.p_container LIKE 'LG%' AND PART.p_name LIKE '%tomato%' WHERE - EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) < 7 - AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 + EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATE)) < 7 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1995 AND LINEITEM.l_shipmode = 'SHIP' ), "_T0" AS ( SELECT @@ -32,12 +32,12 @@ WITH "_S7" AS ( SELECT ANYTHING_S_NAME AS supplier_name, ANYTHING_N_NAME AS nation_name, - NVL(SUM_L_QUANTITY, 0) AS supplier_quantity, + COALESCE(SUM_L_QUANTITY, 0) AS supplier_quantity, ( - 100.0 * NVL(SUM_L_QUANTITY, 0) + 100.0 * COALESCE(SUM_L_QUANTITY, 0) ) / CASE - WHEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) > 0 - THEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) + WHEN SUM(COALESCE(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) > 0 + THEN SUM(COALESCE(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) ELSE NULL END AS national_qty_pct FROM "_T0" diff --git a/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql index a874e454b..f9c6f0689 100644 --- a/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql +++ b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql @@ -11,7 +11,7 @@ WITH "_S7" AS ( SELECT COUNTRIES.co_name AS country_name, PRODUCTS.pr_name AS product_name, - ROUND(NVL(SUM("_S7".N_ROWS), 0) / COUNT(*), 2) AS ir + ROUND(COALESCE(SUM("_S7".N_ROWS), 0) / COUNT(*), 2) AS ir FROM MAIN.COUNTRIES COUNTRIES JOIN MAIN.DEVICES DEVICES ON COUNTRIES.co_id = DEVICES.de_production_country_id diff --git a/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql index 3f92d0bd2..92a6af6a4 100644 --- a/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql +++ b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql @@ -35,7 +35,7 @@ WITH "_S0" AS ( SELECT "_S0".CO_NAME AS factory_country, "_S1".CO_NAME AS purchase_country, - ROUND(NVL("_S9".SUM_N_ROWS, 0) / NVL("_S9".N_ROWS, 0), 2) AS ir + ROUND(COALESCE("_S9".SUM_N_ROWS, 0) / COALESCE("_S9".N_ROWS, 0), 2) AS ir FROM "_S0" "_S0" CROSS JOIN "_S0" "_S1" LEFT JOIN "_S9" "_S9" diff --git a/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql index 615b82e2d..50c3c7c31 100644 --- a/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql +++ b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql @@ -58,9 +58,9 @@ WITH "_T2" AS ( ) SELECT COUNTRIES.co_name AS country_name, - ROUND(NVL("_S3".SUM_N_ROWS, 0) / "_S3".N_ROWS, 2) AS made_ir, - ROUND(NVL("_S7".SUM_N_ROWS, 0) / "_S7".N_ROWS, 2) AS sold_ir, - ROUND(NVL("_S13".SUM_N_ROWS, 0) / NVL("_S13".N_ROWS, 0), 2) AS user_ir + ROUND(COALESCE("_S3".SUM_N_ROWS, 0) / "_S3".N_ROWS, 2) AS made_ir, + ROUND(COALESCE("_S7".SUM_N_ROWS, 0) / "_S7".N_ROWS, 2) AS sold_ir, + ROUND(COALESCE("_S13".SUM_N_ROWS, 0) / COALESCE("_S13".N_ROWS, 0), 2) AS user_ir FROM MAIN.COUNTRIES COUNTRIES JOIN "_S3" "_S3" ON COUNTRIES.co_id = "_S3".DE_PRODUCTION_COUNTRY_ID diff --git a/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql index 313f27c5a..c100f405b 100644 --- a/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql +++ b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql @@ -12,9 +12,12 @@ WITH "_S5" AS ( ) SELECT ERRORS.er_name AS error, - ROUND(( - 100.0 * NVL("_S5".N_ROWS, 0) - ) / SUM(NVL("_S5".N_ROWS, 0)) OVER (), 2) AS pct + ROUND( + ( + 100.0 * COALESCE("_S5".N_ROWS, 0) + ) / SUM(COALESCE("_S5".N_ROWS, 0)) OVER (), + 2 + ) AS pct FROM MAIN.ERRORS ERRORS LEFT JOIN "_S5" "_S5" ON ERRORS.er_id = "_S5".IN_ERROR_ID diff --git a/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql index 89f70b5c5..2329068c1 100644 --- a/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql +++ b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql @@ -11,7 +11,7 @@ WITH "_T2" AS ( DEVICES.de_id ), "_S5" AS ( SELECT - NVL(SUM(COUNT_IN_DEVICE_ID), 0) AS SUM_N_INCIDENTS, + COALESCE(SUM(COUNT_IN_DEVICE_ID), 0) AS SUM_N_INCIDENTS, ANYTHING_DE_PRODUCTION_COUNTRY_ID, COUNT(*) AS N_ROWS FROM "_T2" @@ -20,7 +20,7 @@ WITH "_T2" AS ( ) SELECT COUNTRIES.co_name AS country, - ROUND(NVL("_S5".SUM_N_INCIDENTS, 0) / NVL("_S5".N_ROWS, 0), 2) AS ir + ROUND(COALESCE("_S5".SUM_N_INCIDENTS, 0) / COALESCE("_S5".N_ROWS, 0), 2) AS ir FROM MAIN.COUNTRIES COUNTRIES LEFT JOIN "_S5" "_S5" ON COUNTRIES.co_id = "_S5".ANYTHING_DE_PRODUCTION_COUNTRY_ID diff --git a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql index b3fa5f7ca..495c40bf0 100644 --- a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql +++ b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql @@ -4,11 +4,13 @@ SELECT FROM MAIN.CALENDAR CALENDAR JOIN MAIN.CALENDAR CALENDAR_2 ON CALENDAR.ca_dt <= CALENDAR_2.ca_dt - AND CALENDAR_2.ca_dt < DATE_ADD(CAST(CALENDAR.ca_dt AS TIMESTAMP), 5, 'DAY') + AND CALENDAR_2.ca_dt < ( + CAST(CALENDAR.ca_dt AS TIMESTAMP) + NUMTODSINTERVAL(5, 'day') + ) JOIN MAIN.DEVICES DEVICES ON CALENDAR_2.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') WHERE - EXTRACT(YEAR FROM CAST(CALENDAR.ca_dt AS DATETIME)) = 2024 + EXTRACT(YEAR FROM CAST(CALENDAR.ca_dt AS DATE)) = 2024 GROUP BY CALENDAR.ca_dt ORDER BY diff --git a/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql index 386e41d20..3f7c82d76 100644 --- a/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql +++ b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql @@ -12,16 +12,16 @@ WITH "_S0" AS ( FROM MAIN.PRODUCTS ), "_S6" AS ( SELECT - EXTRACT(YEAR FROM CAST("_S1".PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + EXTRACT(YEAR FROM CAST("_S1".PR_RELEASE AS DATE)) AS YEAR_PR_RELEASE, SUM("_S0".N_ROWS) AS SUM_N_ROWS FROM "_S0" "_S0" JOIN "_S1" "_S1" ON "_S0".DE_PRODUCT_ID = "_S1".PR_ID GROUP BY - EXTRACT(YEAR FROM CAST("_S1".PR_RELEASE AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S1".PR_RELEASE AS DATE)) ), "_S7" AS ( SELECT - EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATE)) AS YEAR_PR_RELEASE, COUNT(*) AS N_ROWS FROM MAIN.DEVICES DEVICES JOIN "_S1" "_S3" @@ -29,11 +29,11 @@ WITH "_S0" AS ( JOIN MAIN.INCIDENTS INCIDENTS ON DEVICES.de_id = INCIDENTS.in_device_id GROUP BY - EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATE)) ) SELECT "_S6".YEAR_PR_RELEASE AS year, - ROUND(NVL("_S7".N_ROWS, 0) / "_S6".SUM_N_ROWS, 2) AS ir + ROUND(COALESCE("_S7".N_ROWS, 0) / "_S6".SUM_N_ROWS, 2) AS ir FROM "_S6" "_S6" LEFT JOIN "_S7" "_S7" ON "_S6".YEAR_PR_RELEASE = "_S7".YEAR_PR_RELEASE diff --git a/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql index ce0801521..f538b51e1 100644 --- a/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql +++ b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql @@ -8,7 +8,7 @@ WITH "_S3" AS ( ) SELECT PRODUCTS.pr_brand AS brand, - ROUND(NVL(SUM("_S3".N_ROWS), 0) / COUNT(*), 2) AS ir + ROUND(COALESCE(SUM("_S3".N_ROWS), 0) / COUNT(*), 2) AS ir FROM MAIN.DEVICES DEVICES JOIN MAIN.PRODUCTS PRODUCTS ON DEVICES.de_product_id = PRODUCTS.pr_id diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql index a7a0aa0f3..8c1873360 100644 --- a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -3,7 +3,7 @@ WITH "_T2" AS ( ca_dt AS CA_DT FROM MAIN.CALENDAR WHERE - EXTRACT(YEAR FROM CAST(ca_dt AS DATETIME)) IN (2020, 2021) + EXTRACT(YEAR FROM CAST(ca_dt AS DATE)) IN (2020, 2021) ), "_T5" AS ( SELECT co_id AS CO_ID, @@ -17,7 +17,9 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T4" JOIN MAIN.CALENDAR CALENDAR - ON CALENDAR.ca_dt >= DATE_SUB(CAST("_T4".CA_DT AS TIMESTAMP), 6, MONTH) + ON CALENDAR.ca_dt >= ( + CAST("_T4".CA_DT AS TIMESTAMP) + NUMTOYMINTERVAL(6, 'month') + ) JOIN MAIN.DEVICES DEVICES ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') JOIN "_T5" "_T5" @@ -39,8 +41,8 @@ WITH "_T2" AS ( "_T7".CA_DT ), "_T0" AS ( SELECT - EXTRACT(MONTH FROM CAST("_T2".CA_DT AS DATETIME)) AS MONTH_CA_DT, - EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATETIME)) AS YEAR_CA_DT, + EXTRACT(MONTH FROM CAST("_T2".CA_DT AS DATE)) AS MONTH_CA_DT, + EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATE)) AS YEAR_CA_DT, SUM("_S7".N_ROWS) AS SUM_EXPR_3, SUM("_S15".N_ROWS) AS SUM_N_ROWS FROM "_T2" "_T2" @@ -49,22 +51,29 @@ WITH "_T2" AS ( LEFT JOIN "_S15" "_S15" ON "_S15".CA_DT = "_T2".CA_DT GROUP BY - EXTRACT(MONTH FROM CAST("_T2".CA_DT AS DATETIME)), - EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATETIME)) + EXTRACT(MONTH FROM CAST("_T2".CA_DT AS DATE)), + EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATE)) ) SELECT - LISTAGG( - '-', - YEAR_CA_DT, - CASE - WHEN LENGTH(MONTH_CA_DT) >= 2 - THEN SUBSTR(MONTH_CA_DT, 1, 2) - ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) - END + LTRIM( + NVL2(YEAR_CA_DT, '-' || YEAR_CA_DT, NULL) || NVL2( + CASE + WHEN LENGTH(MONTH_CA_DT) >= 2 + THEN SUBSTR(MONTH_CA_DT, 1, 2) + ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) + END, + '-' || CASE + WHEN LENGTH(MONTH_CA_DT) >= 2 + THEN SUBSTR(MONTH_CA_DT, 1, 2) + ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) + END, + NULL + ), + '-' ) AS month, ROUND(( - 1000000.0 * NVL(SUM_N_ROWS, 0) - ) / NVL(SUM_EXPR_3, 0), 2) AS ir + 1000000.0 * COALESCE(SUM_N_ROWS, 0) + ) / COALESCE(SUM_EXPR_3, 0), 2) AS ir FROM "_T0" ORDER BY MONTH_CA_DT NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql index 8479e10e0..32cef5abb 100644 --- a/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql +++ b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql @@ -20,7 +20,7 @@ SELECT PRODUCTS.pr_name AS product, PRODUCTS.pr_brand AS product_brand, PRODUCTS.pr_type AS product_type, - ROUND(NVL("_S3".SUM_N_ROWS, 0) / "_S3".N_ROWS, 2) AS ir + ROUND(COALESCE("_S3".SUM_N_ROWS, 0) / "_S3".N_ROWS, 2) AS ir FROM MAIN.PRODUCTS PRODUCTS JOIN "_S3" "_S3" ON PRODUCTS.pr_id = "_S3".DE_PRODUCT_ID diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql index 51aa465fa..051d86429 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql @@ -41,7 +41,7 @@ WITH "_S14" AS ( "_S8".CA_DT ), "_S15" AS ( SELECT - EXTRACT(YEAR FROM CAST("_S6".CA_DT AS DATETIME)) AS YEAR_CA_DT, + EXTRACT(YEAR FROM CAST("_S6".CA_DT AS DATE)) AS YEAR_CA_DT, SUM("_S7".N_ROWS) AS SUM_EXPR_4, SUM("_S13".N_ROWS) AS SUM_N_ROWS FROM "_S6" "_S6" @@ -50,34 +50,34 @@ WITH "_S14" AS ( LEFT JOIN "_S13" "_S13" ON "_S13".CA_DT = "_S6".CA_DT GROUP BY - EXTRACT(YEAR FROM CAST("_S6".CA_DT AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S6".CA_DT AS DATE)) ) SELECT - "_S15".YEAR_CA_DT - EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATETIME)) AS years_since_release, + "_S15".YEAR_CA_DT - EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATE)) AS years_since_release, ROUND( - SUM(NVL("_S15".SUM_EXPR_4, 0)) OVER (ORDER BY "_S15".YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL("_S15".SUM_N_ROWS, 0)) OVER (ORDER BY "_S15".YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(COALESCE("_S15".SUM_EXPR_4, 0)) OVER (ORDER BY "_S15".YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(COALESCE("_S15".SUM_N_ROWS, 0)) OVER (ORDER BY "_S15".YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS cum_ir, ROUND( ( 100.0 * ( - NVL("_S15".SUM_N_ROWS, 0) - LAG(NVL("_S15".SUM_N_ROWS, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT) + COALESCE("_S15".SUM_N_ROWS, 0) - LAG(COALESCE("_S15".SUM_N_ROWS, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT) ) - ) / LAG(NVL("_S15".SUM_N_ROWS, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT), + ) / LAG(COALESCE("_S15".SUM_N_ROWS, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT), 2 ) AS pct_bought_change, ROUND( ( 100.0 * ( - NVL("_S15".SUM_EXPR_4, 0) - LAG(NVL("_S15".SUM_EXPR_4, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT) + COALESCE("_S15".SUM_EXPR_4, 0) - LAG(COALESCE("_S15".SUM_EXPR_4, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT) ) - ) / LAG(NVL("_S15".SUM_EXPR_4, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT), + ) / LAG(COALESCE("_S15".SUM_EXPR_4, 0), 1) OVER (ORDER BY "_S15".YEAR_CA_DT), 2 ) AS pct_incident_change, - NVL("_S15".SUM_N_ROWS, 0) AS bought, - NVL("_S15".SUM_EXPR_4, 0) AS incidents + COALESCE("_S15".SUM_N_ROWS, 0) AS bought, + COALESCE("_S15".SUM_EXPR_4, 0) AS incidents FROM "_S14" "_S14" JOIN "_S15" "_S15" - ON "_S15".YEAR_CA_DT >= EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATETIME)) + ON "_S15".YEAR_CA_DT >= EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATE)) ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql index 771f161fa..33feef788 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql @@ -22,7 +22,7 @@ WITH "_S2" AS ( "_S4".CA_DT ), "_T1" AS ( SELECT - EXTRACT(YEAR FROM CAST("_S2".CA_DT AS DATETIME)) AS YEAR_CA_DT, + EXTRACT(YEAR FROM CAST("_S2".CA_DT AS DATE)) AS YEAR_CA_DT, SUM("_S3".N_ROWS) AS SUM_EXPR_3, SUM("_S7".N_ROWS) AS SUM_N_ROWS FROM "_S2" "_S2" @@ -31,12 +31,12 @@ WITH "_S2" AS ( LEFT JOIN "_S7" "_S7" ON "_S2".CA_DT = "_S7".CA_DT GROUP BY - EXTRACT(YEAR FROM CAST("_S2".CA_DT AS DATETIME)) + EXTRACT(YEAR FROM CAST("_S2".CA_DT AS DATE)) ) SELECT YEAR_CA_DT AS yr, ROUND( - SUM(NVL(SUM_N_ROWS, 0)) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(SUM_EXPR_3) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(COALESCE(SUM_N_ROWS, 0)) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(SUM_EXPR_3) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 2 ) AS cum_ir, ROUND( @@ -50,13 +50,13 @@ SELECT ROUND( ( 100.0 * ( - NVL(SUM_N_ROWS, 0) - LAG(NVL(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT) + COALESCE(SUM_N_ROWS, 0) - LAG(COALESCE(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT) ) - ) / LAG(NVL(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT), + ) / LAG(COALESCE(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT), 2 ) AS pct_incident_change, SUM_EXPR_3 AS bought, - NVL(SUM_N_ROWS, 0) AS incidents + COALESCE(SUM_N_ROWS, 0) AS incidents FROM "_T1" WHERE NOT SUM_EXPR_3 IS NULL AND SUM_EXPR_3 <> 0 diff --git a/tests/test_sql_refsols/time_threshold_reached_oracle.sql b/tests/test_sql_refsols/time_threshold_reached_oracle.sql index 0c29394fc..1a1403df1 100644 --- a/tests/test_sql_refsols/time_threshold_reached_oracle.sql +++ b/tests/test_sql_refsols/time_threshold_reached_oracle.sql @@ -6,7 +6,7 @@ WITH "_T3" AS ( ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY')) AS PCT_OF_DAY FROM MAIN.SBTRANSACTION WHERE - EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_T" AS ( SELECT SBTXDATETIME, diff --git a/tests/test_sql_refsols/top_customers_by_orders_oracle.sql b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql index 565de3cbd..19e55025a 100644 --- a/tests/test_sql_refsols/top_customers_by_orders_oracle.sql +++ b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql @@ -8,7 +8,7 @@ WITH "_S1" AS ( ) SELECT CUSTOMER.c_custkey AS customer_key, - NVL("_S1".N_ROWS, 0) AS n_orders + COALESCE("_S1".N_ROWS, 0) AS n_orders FROM TPCH.CUSTOMER CUSTOMER LEFT JOIN "_S1" "_S1" ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY diff --git a/tests/test_sql_refsols/tpch_q10_oracle.sql b/tests/test_sql_refsols/tpch_q10_oracle.sql index 6bcc8bef3..be6b050bf 100644 --- a/tests/test_sql_refsols/tpch_q10_oracle.sql +++ b/tests/test_sql_refsols/tpch_q10_oracle.sql @@ -8,15 +8,15 @@ WITH "_S3" AS ( JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_returnflag = 'R' WHERE - EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (10, 11, 12) - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1993 + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)) IN (10, 11, 12) + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1993 GROUP BY ORDERS.o_custkey ) SELECT CUSTOMER.c_custkey AS C_CUSTKEY, CUSTOMER.c_name AS C_NAME, - NVL("_S3".SUM_EXPR, 0) AS REVENUE, + COALESCE("_S3".SUM_EXPR, 0) AS REVENUE, CUSTOMER.c_acctbal AS C_ACCTBAL, NATION.n_name AS N_NAME, CUSTOMER.c_address AS C_ADDRESS, diff --git a/tests/test_sql_refsols/tpch_q11_oracle.sql b/tests/test_sql_refsols/tpch_q11_oracle.sql index fb0f113a0..eeacda21b 100644 --- a/tests/test_sql_refsols/tpch_q11_oracle.sql +++ b/tests/test_sql_refsols/tpch_q11_oracle.sql @@ -32,12 +32,12 @@ WITH "_S0" AS ( ) SELECT "_S9".PS_PARTKEY, - NVL("_S9".SUM_EXPR, 0) AS VALUE + COALESCE("_S9".SUM_EXPR, 0) AS VALUE FROM "_S8" "_S8" JOIN "_S9" "_S9" ON ( - NVL("_S8".SUM_METRIC, 0) * 0.0001 - ) < NVL("_S9".SUM_EXPR, 0) + COALESCE("_S8".SUM_METRIC, 0) * 0.0001 + ) < COALESCE("_S9".SUM_EXPR, 0) ORDER BY 2 DESC NULLS LAST FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q12_oracle.sql b/tests/test_sql_refsols/tpch_q12_oracle.sql index 26b980c89..b09952c84 100644 --- a/tests/test_sql_refsols/tpch_q12_oracle.sql +++ b/tests/test_sql_refsols/tpch_q12_oracle.sql @@ -1,12 +1,12 @@ SELECT LINEITEM.l_shipmode AS L_SHIPMODE, - NVL(SUM(ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS HIGH_LINE_COUNT, - NVL(SUM(NOT ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS LOW_LINE_COUNT + COALESCE(SUM(ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS HIGH_LINE_COUNT, + COALESCE(SUM(NOT ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS LOW_LINE_COUNT FROM TPCH.LINEITEM LINEITEM JOIN TPCH.ORDERS ORDERS ON LINEITEM.l_orderkey = ORDERS.o_orderkey WHERE - EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1994 + EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATE)) = 1994 AND LINEITEM.l_commitdate < LINEITEM.l_receiptdate AND LINEITEM.l_commitdate > LINEITEM.l_shipdate AND ( diff --git a/tests/test_sql_refsols/tpch_q13_oracle.sql b/tests/test_sql_refsols/tpch_q13_oracle.sql index 2d44a883a..a0eeea26c 100644 --- a/tests/test_sql_refsols/tpch_q13_oracle.sql +++ b/tests/test_sql_refsols/tpch_q13_oracle.sql @@ -9,13 +9,13 @@ WITH "_S1" AS ( o_custkey ) SELECT - NVL("_S1".N_ROWS, 0) AS C_COUNT, + COALESCE("_S1".N_ROWS, 0) AS C_COUNT, COUNT(*) AS CUSTDIST FROM TPCH.CUSTOMER CUSTOMER LEFT JOIN "_S1" "_S1" ON CUSTOMER.c_custkey = "_S1".O_CUSTKEY GROUP BY - NVL("_S1".N_ROWS, 0) + COALESCE("_S1".N_ROWS, 0) ORDER BY 2 DESC NULLS LAST, 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/tpch_q14_oracle.sql b/tests/test_sql_refsols/tpch_q14_oracle.sql index c624de595..72354ac01 100644 --- a/tests/test_sql_refsols/tpch_q14_oracle.sql +++ b/tests/test_sql_refsols/tpch_q14_oracle.sql @@ -1,6 +1,6 @@ SELECT ( - 100.0 * NVL( + 100.0 * COALESCE( SUM( CASE WHEN PART.p_type LIKE 'PROMO%' @@ -12,12 +12,12 @@ SELECT ), 0 ) - ) / NVL(SUM(LINEITEM.l_extendedprice * ( + ) / COALESCE(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount )), 0) AS PROMO_REVENUE FROM TPCH.LINEITEM LINEITEM JOIN TPCH.PART PART ON LINEITEM.l_partkey = PART.p_partkey WHERE - EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 9 - AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 + EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATE)) = 9 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1995 diff --git a/tests/test_sql_refsols/tpch_q15_oracle.sql b/tests/test_sql_refsols/tpch_q15_oracle.sql index d625b081c..7ce7b99b3 100644 --- a/tests/test_sql_refsols/tpch_q15_oracle.sql +++ b/tests/test_sql_refsols/tpch_q15_oracle.sql @@ -18,7 +18,7 @@ WITH "_T3" AS ( L_SUPPKEY ), "_S0" AS ( SELECT - MAX(NVL(SUM_EXPR, 0)) AS MAX_TOTAL_REVENUE + MAX(COALESCE(SUM_EXPR, 0)) AS MAX_TOTAL_REVENUE FROM "_T1" ), "_S3" AS ( SELECT @@ -35,11 +35,11 @@ SELECT SUPPLIER.s_name AS S_NAME, SUPPLIER.s_address AS S_ADDRESS, SUPPLIER.s_phone AS S_PHONE, - NVL("_S3".SUM_EXPR, 0) AS TOTAL_REVENUE + COALESCE("_S3".SUM_EXPR, 0) AS TOTAL_REVENUE FROM "_S0" "_S0" CROSS JOIN TPCH.SUPPLIER SUPPLIER JOIN "_S3" "_S3" ON SUPPLIER.s_suppkey = "_S3".L_SUPPKEY - AND "_S0".MAX_TOTAL_REVENUE = NVL("_S3".SUM_EXPR, 0) + AND "_S0".MAX_TOTAL_REVENUE = COALESCE("_S3".SUM_EXPR, 0) ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q17_oracle.sql b/tests/test_sql_refsols/tpch_q17_oracle.sql index 94bf3569e..c42913705 100644 --- a/tests/test_sql_refsols/tpch_q17_oracle.sql +++ b/tests/test_sql_refsols/tpch_q17_oracle.sql @@ -10,7 +10,7 @@ WITH "_T" AS ( PART.p_brand = 'Brand#23' AND PART.p_container = 'MED BOX' ) SELECT - NVL(SUM(L_EXTENDEDPRICE), 0) / 7.0 AS AVG_YEARLY + COALESCE(SUM(L_EXTENDEDPRICE), 0) / 7.0 AS AVG_YEARLY FROM "_T" WHERE L_QUANTITY < ( diff --git a/tests/test_sql_refsols/tpch_q19_oracle.sql b/tests/test_sql_refsols/tpch_q19_oracle.sql index 8d61bd47f..cc0c13dfd 100644 --- a/tests/test_sql_refsols/tpch_q19_oracle.sql +++ b/tests/test_sql_refsols/tpch_q19_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL(SUM(LINEITEM.l_extendedprice * ( + COALESCE(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount )), 0) AS REVENUE FROM TPCH.LINEITEM LINEITEM diff --git a/tests/test_sql_refsols/tpch_q1_oracle.sql b/tests/test_sql_refsols/tpch_q1_oracle.sql index cd723794a..6f0434e3f 100644 --- a/tests/test_sql_refsols/tpch_q1_oracle.sql +++ b/tests/test_sql_refsols/tpch_q1_oracle.sql @@ -1,12 +1,12 @@ SELECT l_returnflag AS L_RETURNFLAG, l_linestatus AS L_LINESTATUS, - NVL(SUM(l_quantity), 0) AS SUM_QTY, - NVL(SUM(l_extendedprice), 0) AS SUM_BASE_PRICE, - NVL(SUM(l_extendedprice * ( + COALESCE(SUM(l_quantity), 0) AS SUM_QTY, + COALESCE(SUM(l_extendedprice), 0) AS SUM_BASE_PRICE, + COALESCE(SUM(l_extendedprice * ( 1 - l_discount )), 0) AS SUM_DISC_PRICE, - NVL(SUM(l_extendedprice * ( + COALESCE(SUM(l_extendedprice * ( 1 - l_discount ) * ( 1 + l_tax diff --git a/tests/test_sql_refsols/tpch_q20_oracle.sql b/tests/test_sql_refsols/tpch_q20_oracle.sql index 7bf6bfc3f..cc634b80b 100644 --- a/tests/test_sql_refsols/tpch_q20_oracle.sql +++ b/tests/test_sql_refsols/tpch_q20_oracle.sql @@ -4,7 +4,7 @@ WITH "_S5" AS ( SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY FROM TPCH.PART PART JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1994 + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1994 AND LINEITEM.l_partkey = PART.p_partkey WHERE PART.p_name LIKE 'forest%' @@ -21,7 +21,7 @@ JOIN TPCH.PARTSUPP PARTSUPP ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey JOIN "_S5" "_S5" ON PARTSUPP.ps_availqty > ( - 0.5 * NVL("_S5".SUM_L_QUANTITY, 0) + 0.5 * COALESCE("_S5".SUM_L_QUANTITY, 0) ) AND PARTSUPP.ps_partkey = "_S5".L_PARTKEY GROUP BY diff --git a/tests/test_sql_refsols/tpch_q21_oracle.sql b/tests/test_sql_refsols/tpch_q21_oracle.sql index 5898784de..38a59a6f6 100644 --- a/tests/test_sql_refsols/tpch_q21_oracle.sql +++ b/tests/test_sql_refsols/tpch_q21_oracle.sql @@ -41,7 +41,7 @@ WITH "_T5" AS ( ) SELECT ANY_VALUE(SUPPLIER.s_name) AS S_NAME, - NVL(NULLIF(COUNT("_S11".ANYTHING_L_SUPPKEY), 0), 0) AS NUMWAIT + COUNT("_S11".ANYTHING_L_SUPPKEY) AS NUMWAIT FROM TPCH.SUPPLIER SUPPLIER JOIN TPCH.NATION NATION ON NATION.n_name = 'SAUDI ARABIA' AND NATION.n_nationkey = SUPPLIER.s_nationkey diff --git a/tests/test_sql_refsols/tpch_q22_oracle.sql b/tests/test_sql_refsols/tpch_q22_oracle.sql index 9e7c79010..f3418cf8a 100644 --- a/tests/test_sql_refsols/tpch_q22_oracle.sql +++ b/tests/test_sql_refsols/tpch_q22_oracle.sql @@ -9,7 +9,7 @@ WITH "_S0" AS ( SELECT SUBSTR(CUSTOMER.c_phone, 1, 2) AS CNTRY_CODE, COUNT(*) AS NUM_CUSTS, - NVL(SUM(CUSTOMER.c_acctbal), 0) AS TOTACCTBAL + COALESCE(SUM(CUSTOMER.c_acctbal), 0) AS TOTACCTBAL FROM "_S0" "_S0" JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_acctbal > "_S0".AVG_C_ACCTBAL diff --git a/tests/test_sql_refsols/tpch_q3_oracle.sql b/tests/test_sql_refsols/tpch_q3_oracle.sql index d4595b0ac..94a028a62 100644 --- a/tests/test_sql_refsols/tpch_q3_oracle.sql +++ b/tests/test_sql_refsols/tpch_q3_oracle.sql @@ -1,6 +1,6 @@ SELECT LINEITEM.l_orderkey AS L_ORDERKEY, - NVL(SUM(LINEITEM.l_extendedprice * ( + COALESCE(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount )), 0) AS REVENUE, ORDERS.o_orderdate AS O_ORDERDATE, diff --git a/tests/test_sql_refsols/tpch_q4_oracle.sql b/tests/test_sql_refsols/tpch_q4_oracle.sql index 3dba2c4f5..f89ec8ddf 100644 --- a/tests/test_sql_refsols/tpch_q4_oracle.sql +++ b/tests/test_sql_refsols/tpch_q4_oracle.sql @@ -6,8 +6,8 @@ JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate AND LINEITEM.l_orderkey = ORDERS.o_orderkey WHERE - EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (7, 8, 9) - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1993 + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)) IN (7, 8, 9) + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1993 GROUP BY ORDERS.o_orderpriority ORDER BY diff --git a/tests/test_sql_refsols/tpch_q5_oracle.sql b/tests/test_sql_refsols/tpch_q5_oracle.sql index a826fc523..79da8572b 100644 --- a/tests/test_sql_refsols/tpch_q5_oracle.sql +++ b/tests/test_sql_refsols/tpch_q5_oracle.sql @@ -8,7 +8,7 @@ WITH "_S11" AS ( ) SELECT ANY_VALUE(NATION.n_name) AS N_NAME, - NVL(SUM(LINEITEM.l_extendedprice * ( + COALESCE(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount )), 0) AS REVENUE FROM TPCH.NATION NATION diff --git a/tests/test_sql_refsols/tpch_q6_oracle.sql b/tests/test_sql_refsols/tpch_q6_oracle.sql index 80f156bc9..0c47af730 100644 --- a/tests/test_sql_refsols/tpch_q6_oracle.sql +++ b/tests/test_sql_refsols/tpch_q6_oracle.sql @@ -1,5 +1,5 @@ SELECT - NVL(SUM(l_extendedprice * l_discount), 0) AS REVENUE + COALESCE(SUM(l_extendedprice * l_discount), 0) AS REVENUE FROM TPCH.LINEITEM WHERE l_discount <= 0.07 diff --git a/tests/test_sql_refsols/tpch_q7_oracle.sql b/tests/test_sql_refsols/tpch_q7_oracle.sql index fd0229c77..f7bcb74f7 100644 --- a/tests/test_sql_refsols/tpch_q7_oracle.sql +++ b/tests/test_sql_refsols/tpch_q7_oracle.sql @@ -14,8 +14,8 @@ WITH "_S9" AS ( SELECT NATION.n_name AS SUPP_NATION, "_S9".N_NAME AS CUST_NATION, - EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) AS L_YEAR, - NVL(SUM(LINEITEM.l_extendedprice * ( + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) AS L_YEAR, + COALESCE(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount )), 0) AS REVENUE FROM TPCH.LINEITEM LINEITEM @@ -35,9 +35,9 @@ JOIN "_S9" "_S9" NATION.n_name = 'GERMANY' OR "_S9".N_NAME = 'GERMANY' ) WHERE - EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) IN (1995, 1996) GROUP BY - EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)), "_S9".N_NAME, NATION.n_name ORDER BY diff --git a/tests/test_sql_refsols/tpch_q8_oracle.sql b/tests/test_sql_refsols/tpch_q8_oracle.sql index 4bf2f76b9..6902a4f52 100644 --- a/tests/test_sql_refsols/tpch_q8_oracle.sql +++ b/tests/test_sql_refsols/tpch_q8_oracle.sql @@ -1,6 +1,6 @@ SELECT - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS O_YEAR, - NVL( + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) AS O_YEAR, + COALESCE( SUM( CASE WHEN NATION_2.n_name = 'BRAZIL' @@ -11,14 +11,14 @@ SELECT END ), 0 - ) / NVL(SUM(LINEITEM.l_extendedprice * ( + ) / COALESCE(SUM(LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount )), 0) AS MKT_SHARE FROM TPCH.LINEITEM LINEITEM JOIN TPCH.PART PART ON LINEITEM.l_partkey = PART.p_partkey AND PART.p_type = 'ECONOMY ANODIZED STEEL' JOIN TPCH.ORDERS ORDERS - ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (1995, 1996) + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) IN (1995, 1996) AND LINEITEM.l_orderkey = ORDERS.o_orderkey JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = ORDERS.o_custkey @@ -31,4 +31,4 @@ JOIN TPCH.SUPPLIER SUPPLIER JOIN TPCH.NATION NATION_2 ON NATION_2.n_nationkey = SUPPLIER.s_nationkey GROUP BY - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) diff --git a/tests/test_sql_refsols/tpch_q9_oracle.sql b/tests/test_sql_refsols/tpch_q9_oracle.sql index f8bb56e29..1950b391a 100644 --- a/tests/test_sql_refsols/tpch_q9_oracle.sql +++ b/tests/test_sql_refsols/tpch_q9_oracle.sql @@ -1,7 +1,7 @@ SELECT NATION.n_name AS NATION, - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS O_YEAR, - NVL( + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) AS O_YEAR, + COALESCE( SUM( LINEITEM.l_extendedprice * ( 1 - LINEITEM.l_discount @@ -22,7 +22,7 @@ JOIN TPCH.PARTSUPP PARTSUPP ON LINEITEM.l_partkey = PARTSUPP.ps_partkey AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey GROUP BY - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)), NATION.n_name ORDER BY 1 NULLS FIRST, diff --git a/tests/test_sql_refsols/triple_partition_oracle.sql b/tests/test_sql_refsols/triple_partition_oracle.sql index 4dbe4b784..037dd6415 100644 --- a/tests/test_sql_refsols/triple_partition_oracle.sql +++ b/tests/test_sql_refsols/triple_partition_oracle.sql @@ -16,8 +16,8 @@ WITH "_S3" AS ( COUNT(*) AS N_ROWS FROM TPCH.PART PART JOIN TPCH.LINEITEM LINEITEM - ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 6 - AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 + ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATE)) = 6 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 1992 AND LINEITEM.l_partkey = PART.p_partkey JOIN TPCH.SUPPLIER SUPPLIER ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey @@ -26,7 +26,7 @@ WITH "_S3" AS ( JOIN "_S5" "_S5" ON "_S3".N_REGIONKEY = "_S5".R_REGIONKEY JOIN TPCH.ORDERS ORDERS - ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1992 AND LINEITEM.l_orderkey = ORDERS.o_orderkey WHERE PART.p_container LIKE 'SM%' diff --git a/tests/test_sql_refsols/user_range_collection_1_oracle.sql b/tests/test_sql_refsols/user_range_collection_1_oracle.sql index e60277da3..236adf39d 100644 --- a/tests/test_sql_refsols/user_range_collection_1_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_1_oracle.sql @@ -10,7 +10,7 @@ WITH "_S1" AS ( ) SELECT COLUMN1 AS part_size, - NVL("_S1".N_ROWS, 0) AS n_parts + COALESCE("_S1".N_ROWS, 0) AS n_parts FROM (VALUES (1), (6), diff --git a/tests/test_sql_refsols/user_range_collection_2_oracle.sql b/tests/test_sql_refsols/user_range_collection_2_oracle.sql index c89c71056..ce9fe88f5 100644 --- a/tests/test_sql_refsols/user_range_collection_2_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -523,7 +523,7 @@ WITH "_S0" AS ( COUNT(*) AS N_ROWS FROM "_S0" "_S0" JOIN "_S1" "_S1" - ON CAST("_S1".Y AS CLOB) LIKE CONCAT(CAST("_S0".X AS CLOB), '%') + ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST("_S0".X AS VARCHAR2(4000)), '%') GROUP BY "_S0".X ), "_S5" AS ( @@ -532,7 +532,7 @@ WITH "_S0" AS ( COUNT(*) AS N_ROWS FROM "_S0" "_S2" JOIN "_S1" "_S3" - ON CAST("_S3".Y AS CLOB) LIKE CONCAT('%', CAST("_S2".X AS CLOB)) + ON CAST("_S3".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST("_S2".X AS VARCHAR2(4000))) GROUP BY "_S2".X ) diff --git a/tests/test_sql_refsols/user_range_collection_3_oracle.sql b/tests/test_sql_refsols/user_range_collection_3_oracle.sql index c89c71056..ce9fe88f5 100644 --- a/tests/test_sql_refsols/user_range_collection_3_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -523,7 +523,7 @@ WITH "_S0" AS ( COUNT(*) AS N_ROWS FROM "_S0" "_S0" JOIN "_S1" "_S1" - ON CAST("_S1".Y AS CLOB) LIKE CONCAT(CAST("_S0".X AS CLOB), '%') + ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST("_S0".X AS VARCHAR2(4000)), '%') GROUP BY "_S0".X ), "_S5" AS ( @@ -532,7 +532,7 @@ WITH "_S0" AS ( COUNT(*) AS N_ROWS FROM "_S0" "_S2" JOIN "_S1" "_S3" - ON CAST("_S3".Y AS CLOB) LIKE CONCAT('%', CAST("_S2".X AS CLOB)) + ON CAST("_S3".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST("_S2".X AS VARCHAR2(4000))) GROUP BY "_S2".X ) diff --git a/tests/test_sql_refsols/user_range_collection_5_oracle.sql b/tests/test_sql_refsols/user_range_collection_5_oracle.sql index c2f088997..2c420127b 100644 --- a/tests/test_sql_refsols/user_range_collection_5_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -30,7 +30,7 @@ WITH "_S2" AS ( ) SELECT "_S2".PART_SIZE AS part_size, - NVL("_S3".N_ROWS, 0) AS n_parts + COALESCE("_S3".N_ROWS, 0) AS n_parts FROM "_S2" "_S2" LEFT JOIN "_S3" "_S3" ON "_S2".PART_SIZE = "_S3".PART_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_6_oracle.sql b/tests/test_sql_refsols/user_range_collection_6_oracle.sql index 71abb2b31..223e7946d 100644 --- a/tests/test_sql_refsols/user_range_collection_6_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_6_oracle.sql @@ -1,6 +1,6 @@ WITH "_S5" AS ( SELECT - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) AS YEAR_O_ORDERDATE, COUNT(DISTINCT ORDERS.o_custkey) AS NDISTINCT_O_CUSTKEY FROM TPCH.ORDERS ORDERS JOIN TPCH.CUSTOMER CUSTOMER @@ -10,11 +10,11 @@ WITH "_S5" AS ( WHERE ORDERS.o_clerk = 'Clerk#000000925' GROUP BY - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) ) SELECT COLUMN1 AS year, - NVL("_S5".NDISTINCT_O_CUSTKEY, 0) AS n_orders + COALESCE("_S5".NDISTINCT_O_CUSTKEY, 0) AS n_orders FROM (VALUES (1990), (1991), diff --git a/tests/test_sql_refsols/week_offset_oracle.sql b/tests/test_sql_refsols/week_offset_oracle.sql index 62d73f30b..20ffb3729 100644 --- a/tests/test_sql_refsols/week_offset_oracle.sql +++ b/tests/test_sql_refsols/week_offset_oracle.sql @@ -1,14 +1,14 @@ SELECT sbtxdatetime AS date_time, - DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'WEEK') AS week_adj1, - DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, WEEK) AS week_adj2, - DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'HOUR'), 2, 'WEEK') AS week_adj3, - DATE_ADD(DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, SECOND), 2, 'WEEK') AS week_adj4, - DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'DAY'), 2, 'WEEK') AS week_adj5, - DATE_ADD(DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, MINUTE), 2, 'WEEK') AS week_adj6, - DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'MONTH'), 2, 'WEEK') AS week_adj7, - DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'YEAR'), 2, 'WEEK') AS week_adj8 + CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'week') AS week_adj1, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'week') AS week_adj2, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'hour') + NUMTODSINTERVAL(2, 'week') AS week_adj3, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'second') + NUMTODSINTERVAL(2, 'week') AS week_adj4, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'day') + NUMTODSINTERVAL(2, 'week') AS week_adj5, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'minute') + NUMTODSINTERVAL(2, 'week') AS week_adj6, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'month') + NUMTODSINTERVAL(2, 'week') AS week_adj7, + CAST(sbtxdatetime AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(2, 'week') AS week_adj8 FROM MAIN.SBTRANSACTION WHERE - EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 - AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 diff --git a/tests/test_sql_refsols/window_filter_order_1_oracle.sql b/tests/test_sql_refsols/window_filter_order_1_oracle.sql index e6e3eccd5..94011f3c1 100644 --- a/tests/test_sql_refsols/window_filter_order_1_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_1_oracle.sql @@ -3,7 +3,7 @@ WITH "_S3" AS ( o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1992 ), "_T2" AS ( SELECT COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY @@ -17,11 +17,11 @@ WITH "_S3" AS ( ), "_T" AS ( SELECT COUNT_O_CUSTKEY, - AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS "_W" + AVG(CAST(COALESCE(COUNT_O_CUSTKEY, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM "_T2" ) SELECT COUNT(*) AS n FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > COALESCE(COUNT_O_CUSTKEY, 0) diff --git a/tests/test_sql_refsols/window_filter_order_2_oracle.sql b/tests/test_sql_refsols/window_filter_order_2_oracle.sql index e6e3eccd5..94011f3c1 100644 --- a/tests/test_sql_refsols/window_filter_order_2_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_2_oracle.sql @@ -3,7 +3,7 @@ WITH "_S3" AS ( o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1992 ), "_T2" AS ( SELECT COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY @@ -17,11 +17,11 @@ WITH "_S3" AS ( ), "_T" AS ( SELECT COUNT_O_CUSTKEY, - AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS "_W" + AVG(CAST(COALESCE(COUNT_O_CUSTKEY, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM "_T2" ) SELECT COUNT(*) AS n FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > COALESCE(COUNT_O_CUSTKEY, 0) diff --git a/tests/test_sql_refsols/window_filter_order_3_oracle.sql b/tests/test_sql_refsols/window_filter_order_3_oracle.sql index e6e3eccd5..94011f3c1 100644 --- a/tests/test_sql_refsols/window_filter_order_3_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_3_oracle.sql @@ -3,7 +3,7 @@ WITH "_S3" AS ( o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1992 ), "_T2" AS ( SELECT COUNT("_S3".O_CUSTKEY) AS COUNT_O_CUSTKEY @@ -17,11 +17,11 @@ WITH "_S3" AS ( ), "_T" AS ( SELECT COUNT_O_CUSTKEY, - AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS "_W" + AVG(CAST(COALESCE(COUNT_O_CUSTKEY, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM "_T2" ) SELECT COUNT(*) AS n FROM "_T" WHERE - NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND "_W" > COALESCE(COUNT_O_CUSTKEY, 0) diff --git a/tests/test_sql_refsols/window_filter_order_4_oracle.sql b/tests/test_sql_refsols/window_filter_order_4_oracle.sql index 8a0aa7bdf..5c98e40a9 100644 --- a/tests/test_sql_refsols/window_filter_order_4_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_4_oracle.sql @@ -6,7 +6,7 @@ WITH "_T2" AS ( ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' JOIN TPCH.ORDERS ORDERS ON CUSTOMER.c_custkey = ORDERS.o_custkey - AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1992 GROUP BY ORDERS.o_custkey ), "_T" AS ( diff --git a/tests/test_sql_refsols/window_filter_order_5_oracle.sql b/tests/test_sql_refsols/window_filter_order_5_oracle.sql index 3176c19dd..e01d007ee 100644 --- a/tests/test_sql_refsols/window_filter_order_5_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_5_oracle.sql @@ -10,12 +10,12 @@ WITH "_S1" AS ( SELECT "_S1".C_ACCTBAL, "_S1".EXPR_0, - AVG(CAST(NVL("_S1".C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS "_W" + AVG(CAST(COALESCE("_S1".C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS LEFT JOIN "_S1" "_S1" ON ORDERS.o_custkey = "_S1".C_CUSTKEY WHERE - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1995 ) SELECT COUNT(*) AS n diff --git a/tests/test_sql_refsols/window_filter_order_6_oracle.sql b/tests/test_sql_refsols/window_filter_order_6_oracle.sql index 3176c19dd..e01d007ee 100644 --- a/tests/test_sql_refsols/window_filter_order_6_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_6_oracle.sql @@ -10,12 +10,12 @@ WITH "_S1" AS ( SELECT "_S1".C_ACCTBAL, "_S1".EXPR_0, - AVG(CAST(NVL("_S1".C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS "_W" + AVG(CAST(COALESCE("_S1".C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS LEFT JOIN "_S1" "_S1" ON ORDERS.o_custkey = "_S1".C_CUSTKEY WHERE - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1995 ) SELECT COUNT(*) AS n diff --git a/tests/test_sql_refsols/window_filter_order_7_oracle.sql b/tests/test_sql_refsols/window_filter_order_7_oracle.sql index 05ffe9a6d..7099f8330 100644 --- a/tests/test_sql_refsols/window_filter_order_7_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_7_oracle.sql @@ -6,7 +6,7 @@ WITH "_T" AS ( JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' WHERE - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1995 ) SELECT COUNT(*) AS n diff --git a/tests/test_sql_refsols/window_filter_order_8_oracle.sql b/tests/test_sql_refsols/window_filter_order_8_oracle.sql index 599f6fa7d..23cf9f286 100644 --- a/tests/test_sql_refsols/window_filter_order_8_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_8_oracle.sql @@ -3,8 +3,8 @@ WITH "_S3" AS ( o_custkey AS O_CUSTKEY FROM TPCH.ORDERS WHERE - EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 - AND EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) = 1 + AND EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1998 ), "_T2" AS ( SELECT ANY_VALUE(CUSTOMER.c_acctbal) AS ANYTHING_C_ACCTBAL, @@ -20,7 +20,7 @@ WITH "_S3" AS ( SELECT ANYTHING_C_ACCTBAL, COUNT_O_CUSTKEY, - SUM(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0)) OVER () AS "_W" + SUM(COALESCE(COUNT_O_CUSTKEY, 0)) OVER () AS "_W" FROM "_T2" ) SELECT diff --git a/tests/test_sql_refsols/window_filter_order_9_oracle.sql b/tests/test_sql_refsols/window_filter_order_9_oracle.sql index 17ab358bc..a12d765e4 100644 --- a/tests/test_sql_refsols/window_filter_order_9_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_9_oracle.sql @@ -1,7 +1,7 @@ WITH "_S3" AS ( SELECT 1 AS EXPR_0, - NVL(SUM(ORDERS.o_totalprice), 0) AS TOTAL_SPENT, + COALESCE(SUM(ORDERS.o_totalprice), 0) AS TOTAL_SPENT, CUSTOMER.c_custkey AS C_CUSTKEY FROM TPCH.CUSTOMER CUSTOMER LEFT JOIN TPCH.ORDERS ORDERS diff --git a/tests/test_sql_refsols/year_month_nation_orders_oracle.sql b/tests/test_sql_refsols/year_month_nation_orders_oracle.sql index da9a6a46a..6c7c1e353 100644 --- a/tests/test_sql_refsols/year_month_nation_orders_oracle.sql +++ b/tests/test_sql_refsols/year_month_nation_orders_oracle.sql @@ -1,7 +1,7 @@ SELECT NATION.n_name AS nation_name, - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS order_year, - EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS order_month, + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) AS order_year, + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)) AS order_month, COUNT(*) AS n_orders FROM TPCH.REGION REGION JOIN TPCH.NATION NATION @@ -13,8 +13,8 @@ JOIN TPCH.ORDERS ORDERS WHERE REGION.r_name IN ('ASIA', 'AFRICA') GROUP BY - EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)), - EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)), + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)), + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)), NATION.n_name ORDER BY 4 DESC NULLS LAST diff --git a/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql index a8cbe61c9..9ec097740 100644 --- a/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql +++ b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql @@ -1,10 +1,10 @@ WITH "_T0" AS ( SELECT - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS YEAR_O_ORDERDATE, COUNT(*) AS N_ROWS FROM TPCH.ORDERS GROUP BY - EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) ) SELECT YEAR_O_ORDERDATE AS year, From c36871bc4ac9cd2b7f746139578f7468bf5dc210 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 20 Feb 2026 16:16:00 -0600 Subject: [PATCH 14/48] adding oracle defog fixture --- tests/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/conftest.py b/tests/conftest.py index e9d6456ee..db84234d2 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -279,7 +279,7 @@ def impl(name: str) -> GraphMetadata: @pytest.fixture(scope="session") -def get_postgres_oracle_graphs() -> graph_fetcher: +def get_oracle_defog_graphs() -> graph_fetcher: """ Returns the graphs for the defog database in Oracle. """ From a179a9e2597f6e69eef7ebde290b101efd496c24 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 20 Feb 2026 17:31:39 -0600 Subject: [PATCH 15/48] fixing quoted alias, adding dataframe collection oracle refsol --- pydough/sqlglot/execute_relational.py | 2 + .../dataframe_collection_best_oracle.sql | 32 + ...ataframe_collection_correlation_oracle.sql | 37 ++ .../dataframe_collection_cross_oracle.sql | 25 + .../dataframe_collection_datatypes_oracle.sql | 12 + ...frame_collection_highest_rating_oracle.sql | 80 +++ .../dataframe_collection_inf_oracle.sql | 9 + ...lection_language_highest_rating_oracle.sql | 81 +++ .../dataframe_collection_numbers_oracle.sql | 13 + .../dataframe_collection_partition_oracle.sql | 23 + .../dataframe_collection_strings_oracle.sql | 11 + ...rame_collection_taught_recently_oracle.sql | 79 +++ ...aframe_collection_teacher_class_oracle.sql | 79 +++ ...aframe_collection_teacher_count_oracle.sql | 96 +++ ...ollection_teacher_lowest_rating_oracle.sql | 79 +++ .../dataframe_collection_top_k_oracle.sql | 21 + ...ame_collection_unique_partition_oracle.sql | 16 + ...dataframe_collection_where_date_oracle.sql | 25 + .../dataframe_collection_where_oracle.sql | 65 ++ ...ame_collection_window_functions_oracle.sql | 83 +++ .../defog_dealership_adv13_oracle.sql | 36 ++ .../defog_dealership_adv8_oracle.sql | 41 ++ .../defog_ewallet_adv11_mysql.sql | 4 +- .../defog_ewallet_adv11_snowflake.sql | 4 +- .../defog_restaurants_gen11_oracle.sql | 16 +- .../defog_restaurants_gen14_oracle.sql | 5 +- .../defog_restaurants_gen15_oracle.sql | 2 +- .../defog_restaurants_gen8_oracle.sql | 2 +- tests/test_sql_refsols/donor_3276_oracle.sql | 7 + .../movielens_2274_oracle.sql | 11 + .../simple_dataframe_collection_1_oracle.sql | 12 + .../simple_dataframe_collection_2_oracle.sql | 8 + .../simple_dataframe_collection_3_oracle.sql | 10 + .../simple_dataframe_collection_4_oracle.sql | 8 + .../simple_range_6_oracle.sql | 45 ++ .../simple_range_7_oracle.sql | 20 + .../simple_range_8_oracle.sql | 25 + .../simple_range_9_oracle.sql | 8 + .../user_range_collection_2_oracle.sql | 79 +-- .../user_range_collection_3_oracle.sql | 562 +++++++++++++++++- .../user_range_collection_5_oracle.sql | 38 +- 41 files changed, 1711 insertions(+), 100 deletions(-) create mode 100644 tests/test_sql_refsols/dataframe_collection_best_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_cross_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_inf_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_partition_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_strings_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_where_oracle.sql create mode 100644 tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv13_oracle.sql create mode 100644 tests/test_sql_refsols/defog_dealership_adv8_oracle.sql create mode 100644 tests/test_sql_refsols/donor_3276_oracle.sql create mode 100644 tests/test_sql_refsols/movielens_2274_oracle.sql create mode 100644 tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql create mode 100644 tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql create mode 100644 tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql create mode 100644 tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_6_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_7_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_8_oracle.sql create mode 100644 tests/test_sql_refsols/simple_range_9_oracle.sql diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index 75ae0e8ba..ca6cd1788 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -359,9 +359,11 @@ def fix_column_case( # Handle expressions with aliases if isinstance(expr, Alias): identifier = expr.args.get("alias") + quoted = quoted or identifier.args.get("quoted", False) identifier.set("this", col_name) identifier.set("quoted", quoted) elif isinstance(expr, Column): + quoted = quoted or expr.this.this.args.get("quoted", False) expr.this.this.set("this", col_name) expr.this.this.set("quoted", quoted) diff --git a/tests/test_sql_refsols/dataframe_collection_best_oracle.sql b/tests/test_sql_refsols/dataframe_collection_best_oracle.sql new file mode 100644 index 000000000..beef71d29 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_best_oracle.sql @@ -0,0 +1,32 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS PRIORITY_LVL, + COLUMN2 AS TAX_RATE + FROM (VALUES + ('1-URGENT', 0.05), + ('2-HIGH', 0.04), + ('3-MEDIUM', 0.03), + ('4-NOT SPECIFIED', 0.02)) AS PRIORITY_TAXES(PRIORITY_LVL, TAX_RATE) +), "_T" AS ( + SELECT + ORDERS.o_custkey AS O_CUSTKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ORDERS.o_orderpriority AS O_ORDERPRIORITY, + ORDERS.o_totalprice AS O_TOTALPRICE, + "_S1".TAX_RATE, + ROW_NUMBER() OVER (PARTITION BY ORDERS.o_orderkey ORDER BY ORDERS.o_totalprice + ORDERS.o_totalprice * "_S1".TAX_RATE) AS "_W" + FROM TPCH.ORDERS ORDERS + JOIN "_S1" "_S1" + ON ORDERS.o_orderpriority = "_S1".PRIORITY_LVL +) +SELECT + CUSTOMER.c_name AS name, + "_T".O_ORDERKEY AS order_key, + "_T".O_ORDERPRIORITY AS order_priority, + "_T".O_TOTALPRICE + "_T".O_TOTALPRICE * "_T".TAX_RATE AS cheapest_order_price +FROM TPCH.CUSTOMER CUSTOMER +JOIN "_T" "_T" + ON CUSTOMER.c_custkey = "_T".O_CUSTKEY AND "_T"."_W" = 1 +ORDER BY + 4 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql b/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql new file mode 100644 index 000000000..bbef47879 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql @@ -0,0 +1,37 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS KEY, + COLUMN3 AS LANGUAGE + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES_3(KEY, CLASS_NAME, LANGUAGE) +), "_S3" AS ( + SELECT + COLUMN1 AS KEY, + COUNT(*) AS N_ROWS + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES_2(KEY, CLASS_NAME, LANGUAGE) + JOIN "_S1" "_S1" + ON COLUMN1 <> "_S1".KEY AND COLUMN3 = "_S1".LANGUAGE + GROUP BY + COLUMN1 +) +SELECT + COLUMN2 AS class_name, + COLUMN3 AS language, + COALESCE("_S3".N_ROWS, 0) AS n_other_classes +FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) +LEFT JOIN "_S3" "_S3" + ON COLUMN1 = "_S3".KEY diff --git a/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql b/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql new file mode 100644 index 000000000..2694a42ce --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql @@ -0,0 +1,25 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS ORDER_ID, + COLUMN2 AS USER_ID, + COLUMN3 AS AMOUNT + FROM (VALUES + (101.0, 1.0, 250.0), + (102.0, 2.0, 150.5), + (103.0, 1.0, 300.0), + (104.0, 3.0, 450.75), + (105.0, 2.0, 200.0)) AS ORDERS(ORDER_ID, USER_ID, AMOUNT) +) +SELECT + COLUMN1 AS id1, + COLUMN2 AS name1, + "_S1".ORDER_ID AS order_id, + "_S1".AMOUNT AS amount +FROM (VALUES + (1, 'John'), + (2, 'Jane'), + (3, 'Bob'), + (4, 'Alice'), + (5, 'Charlie')) AS USERS(ID_, NAME) +JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".USER_ID diff --git a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql new file mode 100644 index 000000000..24ff057ff --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql @@ -0,0 +1,12 @@ +SELECT + COLUMN1 AS string_col, + COLUMN2 AS int_col, + COLUMN3 AS float_col, + COLUMN4 AS nullable_int_col, + COLUMN5 AS bool_col, + COLUMN6 AS null_col, + COLUMN7 AS datetime_col +FROM (VALUES + ('red', 0, 1.5, 1.0, 1, NULL, CAST('2024-01-01 00:00:00' AS TIMESTAMP)), + ('orange', 1, 2.0, NULL, 0, NULL, CAST('2024-01-02 00:00:00' AS TIMESTAMP)), + (NULL, 2, NULL, 7.0, 0, NULL, NULL)) AS ALLDATATYPES(STRING_COL, INT_COL, FLOAT_COL, NULLABLE_INT_COL, BOOL_COL, NULL_COL, DATETIME_COL) diff --git a/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql new file mode 100644 index 000000000..87006fcb2 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql @@ -0,0 +1,80 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS CLASS_KEY, + COLUMN2 AS TEACHER_ID, + COLUMN3 AS SEMESTER, + COLUMN4 AS RATING + FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +), "_T" AS ( + SELECT + COLUMN2 AS CLASS_NAME, + "_S1".SEMESTER, + "_S1".TEACHER_ID, + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".RATING DESC) AS "_W" + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".CLASS_KEY +), "_S3" AS ( + SELECT + COLUMN1 AS TID, + COLUMN2 AS FIRST_NAME, + COLUMN3 AS LAST_NAME + FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) +) +SELECT + "_T".CLASS_NAME AS class_name, + "_T".SEMESTER AS last_semester, + "_S3".FIRST_NAME AS teacher_first_name, + "_S3".LAST_NAME AS teacher_last_name +FROM "_T" "_T" +LEFT JOIN "_S3" "_S3" + ON "_S3".TID = "_T".TEACHER_ID +WHERE + "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql new file mode 100644 index 000000000..827741260 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql @@ -0,0 +1,9 @@ +SELECT + COLUMN1 AS py_float, + COLUMN2 AS np_float64, + COLUMN3 AS np_float32 +FROM (VALUES + (1.5, -2.25, 0.0), + (NULL, NULL, NULL), + ('Infinity', 'Infinity', 'Infinity'), + ('-Infinity', '-Infinity', '-Infinity')) AS INFINTY(PY_FLOAT, NP_FLOAT64, NP_FLOAT32) diff --git a/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql new file mode 100644 index 000000000..690dee3d8 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql @@ -0,0 +1,81 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS CLASS_KEY, + COLUMN2 AS TEACHER_ID, + COLUMN4 AS RATING + FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +), "_T" AS ( + SELECT + COLUMN3 AS LANGUAGE, + "_S1".RATING, + "_S1".TEACHER_ID, + ROW_NUMBER() OVER (PARTITION BY COLUMN3 ORDER BY "_S1".RATING DESC) AS "_W" + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".CLASS_KEY + WHERE + NOT COLUMN3 IS NULL +), "_S3" AS ( + SELECT + COLUMN1 AS TID, + COLUMN2 AS FIRST_NAME, + COLUMN3 AS LAST_NAME + FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) +) +SELECT + "_T".LANGUAGE AS language, + "_T".RATING AS rating, + "_S3".FIRST_NAME AS first_name, + "_S3".LAST_NAME AS last_name +FROM "_T" "_T" +LEFT JOIN "_S3" "_S3" + ON "_S3".TID = "_T".TEACHER_ID +WHERE + "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql b/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql new file mode 100644 index 000000000..050a09f92 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql @@ -0,0 +1,13 @@ +SELECT + COLUMN1 AS pyd_numbers, + COLUMN2 AS py_float, + COLUMN3 AS np_float64, + COLUMN4 AS np_float32, + COLUMN5 AS null_vs_nan, + COLUMN6 AS decimal_val +FROM (VALUES + (10.0, 1.5, 1.5, 1.5, NULL, 1.50), + (-3.0, 0.0, 0.0, 3.33333, NULL, 0.00), + (3.56, 10.0001, 4.4444444, 0.0, NULL, -2.25), + (NULL, -2.25, -2.25, -2.25, 1.0, NULL), + (NULL, NULL, NULL, NULL, 0.0, NULL)) AS NUMBERS(PYD_NUMBERS, PY_FLOAT, NP_FLOAT64, NP_FLOAT32, NULL_VS_NAN, DECIMAL_VAL) diff --git a/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql b/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql new file mode 100644 index 000000000..2a3437ef6 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql @@ -0,0 +1,23 @@ +WITH "_S1" AS ( + SELECT + COLUMN2 AS RULE_CATEGORY, + COLUMN3 AS DISCOUNT + FROM (VALUES + (1, 'A', 0.1), + (2, 'B', 0.15), + (3, 'C', 0.05)) AS PRICING_COLLECTION(RULE_ID, RULE_CATEGORY, DISCOUNT) +) +SELECT + COLUMN2 AS product_category, + AVG(COLUMN3) AS avg_price, + COUNT(*) AS n_products, + MIN("_S1".DISCOUNT) AS min_discount +FROM (VALUES + (1, 'A', 17.99), + (2, 'B', 45.65), + (3, 'A', 15.0), + (4, 'B', 10.99)) AS PRODUCTS_COLLECTION(PRODUCT_ID, PRODUCT_CATEGORY, PRICE) +JOIN "_S1" "_S1" + ON COLUMN2 = "_S1".RULE_CATEGORY +GROUP BY + COLUMN2 diff --git a/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql b/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql new file mode 100644 index 000000000..7212c0271 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql @@ -0,0 +1,11 @@ +SELECT + COLUMN1 AS normal_strings, + COLUMN2 AS empty_string, + COLUMN3 AS special_characters +FROM (VALUES + ('hello', '', '''simple quoted'''), + ('world', 'not_empty', '"double quoted"'), + ('pydough', '', 'unicode_ß_Γ§_ΓΌ'), + (NULL, NULL, NULL), + ('test_string', ' ', 'tap_space newline_ +_test')) AS STRINGS(NORMAL_STRINGS, EMPTY_STRING, SPECIAL_CHARACTERS) diff --git a/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql b/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql new file mode 100644 index 000000000..2d0c8e09a --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql @@ -0,0 +1,79 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS CLASS_KEY, + COLUMN2 AS TEACHER_ID, + COLUMN3 AS SEMESTER + FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +), "_T" AS ( + SELECT + COLUMN2 AS CLASS_NAME, + "_S1".SEMESTER, + "_S1".TEACHER_ID, + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".SEMESTER DESC) AS "_W" + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".CLASS_KEY +), "_S3" AS ( + SELECT + COLUMN1 AS TID, + COLUMN2 AS FIRST_NAME, + COLUMN3 AS LAST_NAME + FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) +) +SELECT + "_T".CLASS_NAME AS class_name, + "_T".SEMESTER AS last_semester, + "_S3".FIRST_NAME AS teacher_first_name, + "_S3".LAST_NAME AS teacher_last_name +FROM "_T" "_T" +LEFT JOIN "_S3" "_S3" + ON "_S3".TID = "_T".TEACHER_ID +WHERE + "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql b/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql new file mode 100644 index 000000000..50f5cd37c --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql @@ -0,0 +1,79 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS CLASS_KEY, + COLUMN2 AS TEACHER_ID, + COLUMN3 AS SEMESTER + FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +), "_T" AS ( + SELECT + "_S1".CLASS_KEY, + COLUMN2 AS FIRST_NAME, + COLUMN3 AS LAST_NAME, + "_S1".SEMESTER, + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".SEMESTER DESC) AS "_W" + FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".TEACHER_ID +), "_S3" AS ( + SELECT + COLUMN1 AS KEY, + COLUMN2 AS CLASS_NAME + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) +) +SELECT + "_T".FIRST_NAME AS first_name, + "_T".LAST_NAME AS last_name, + "_T".SEMESTER AS recent_semester, + "_S3".CLASS_NAME AS class_name +FROM "_T" "_T" +LEFT JOIN "_S3" "_S3" + ON "_S3".KEY = "_T".CLASS_KEY +WHERE + "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql b/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql new file mode 100644 index 000000000..74dadfe56 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql @@ -0,0 +1,96 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS CLASS_KEY, + COLUMN2 AS TEACHER_ID + FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING_2(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +), "_S3" AS ( + SELECT + COLUMN1 AS TID, + COLUMN2 AS FIRST_NAME, + COLUMN3 AS LAST_NAME + FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) +) +SELECT + "_S3".FIRST_NAME AS first_name, + "_S3".LAST_NAME AS last_name, + COUNT(*) AS n_teachers +FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".CLASS_KEY AND COLUMN2 <> "_S1".TEACHER_ID +JOIN "_S3" "_S3" + ON COLUMN2 = "_S3".TID +GROUP BY + "_S3".FIRST_NAME, + "_S3".LAST_NAME diff --git a/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql new file mode 100644 index 000000000..e3023ff6b --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql @@ -0,0 +1,79 @@ +WITH "_S1" AS ( + SELECT + COLUMN1 AS CLASS_KEY, + COLUMN2 AS TEACHER_ID, + COLUMN4 AS RATING + FROM (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) +), "_T" AS ( + SELECT + "_S1".CLASS_KEY, + COLUMN2 AS FIRST_NAME, + COLUMN3 AS LAST_NAME, + "_S1".RATING, + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".RATING DESC) AS "_W" + FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + JOIN "_S1" "_S1" + ON COLUMN1 = "_S1".TEACHER_ID +), "_S3" AS ( + SELECT + COLUMN1 AS KEY, + COLUMN2 AS CLASS_NAME + FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) +) +SELECT + "_T".FIRST_NAME AS first_name, + "_T".LAST_NAME AS last_name, + "_T".RATING AS rating, + "_S3".CLASS_NAME AS class_name +FROM "_T" "_T" +LEFT JOIN "_S3" "_S3" + ON "_S3".KEY = "_T".CLASS_KEY +WHERE + "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql b/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql new file mode 100644 index 000000000..0573a6efc --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql @@ -0,0 +1,21 @@ +SELECT + PART.p_name AS name, + COLUMN1 AS shipping_type, + LINEITEM.l_extendedprice AS extended_price, + LINEITEM.l_discount + COLUMN2 AS added_discount, + LINEITEM.l_extendedprice * ( + 1 - ( + LINEITEM.l_discount + COLUMN2 + ) + ) AS final_price +FROM (VALUES + ('REG AIR', 0.05), + ('SHIP', 0.06), + ('TRUCK', 0.05)) AS DISCOUNTS(SHIPPING_TYPE, ADDED_DISCOUNT) +JOIN TPCH.LINEITEM LINEITEM + ON COLUMN1 = LINEITEM.l_shipmode +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey +ORDER BY + 5 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql b/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql new file mode 100644 index 000000000..88fcbb2f9 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql @@ -0,0 +1,16 @@ +SELECT DISTINCT + COLUMN2 AS first_name, + COLUMN3 AS last_name +FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) diff --git a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql new file mode 100644 index 000000000..c44ebaa2c --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql @@ -0,0 +1,25 @@ +SELECT + COLUMN1 AS clerk_id, + COUNT(*) AS n_orders +FROM (VALUES + ( + 'Clerk#000000456', + CAST('1996-01-01 00:00:00' AS TIMESTAMP), + CAST('1996-02-01 00:00:00' AS TIMESTAMP) + ), + ( + 'Clerk#000000743', + CAST('1995-06-01 00:00:00' AS TIMESTAMP), + CAST('1995-07-01 00:00:00' AS TIMESTAMP) + ), + ( + 'Clerk#000000547', + CAST('1995-11-01 00:00:00' AS TIMESTAMP), + CAST('1995-12-01 00:00:00' AS TIMESTAMP) + )) AS DATES(CLERK_ID, START_DATE, END_DATE) +JOIN TPCH.ORDERS ORDERS + ON COLUMN1 = ORDERS.o_clerk + AND COLUMN2 <= CAST(ORDERS.o_orderdate AS TIMESTAMP) + AND COLUMN3 >= CAST(ORDERS.o_orderdate AS TIMESTAMP) +GROUP BY + COLUMN1 diff --git a/tests/test_sql_refsols/dataframe_collection_where_oracle.sql b/tests/test_sql_refsols/dataframe_collection_where_oracle.sql new file mode 100644 index 000000000..5e6f6b8a6 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_where_oracle.sql @@ -0,0 +1,65 @@ +WITH "_S1" AS ( + SELECT + s_acctbal AS S_ACCTBAL, + s_nationkey AS S_NATIONKEY + FROM TPCH.SUPPLIER +), "_S2" AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), "_S3" AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), "_S5" AS ( + SELECT + "_S2".N_NATIONKEY, + "_S3".R_NAME + FROM "_S2" "_S2" + JOIN "_S3" "_S3" + ON "_S2".N_REGIONKEY = "_S3".R_REGIONKEY +), "_S12" AS ( + SELECT DISTINCT + "_S5".R_NAME + FROM (VALUES + ('AFRICA', 5000.32), + ('AMERICA', 8000.0), + ('ASIA', 4600.32), + ('EUROPE', 6400.5), + ('MIDDLE EAST', 8999.99)) AS THRESHOLDS_COLLECTION(REGION_NAME, MIN_ACCOUNT_BALANCE) + JOIN "_S1" "_S1" + ON COLUMN2 < "_S1".S_ACCTBAL + JOIN "_S5" "_S5" + ON COLUMN1 = "_S5".R_NAME AND "_S1".S_NATIONKEY = "_S5".N_NATIONKEY +), "_S11" AS ( + SELECT + "_S8".N_NATIONKEY, + "_S9".R_NAME + FROM "_S2" "_S8" + JOIN "_S3" "_S9" + ON "_S8".N_REGIONKEY = "_S9".R_REGIONKEY +), "_S13" AS ( + SELECT + "_S11".R_NAME, + COUNT(*) AS N_ROWS + FROM (VALUES + ('AFRICA', 5000.32), + ('AMERICA', 8000.0), + ('ASIA', 4600.32), + ('EUROPE', 6400.5), + ('MIDDLE EAST', 8999.99)) AS THRESHOLDS_COLLECTION_2(REGION_NAME, MIN_ACCOUNT_BALANCE) + JOIN "_S1" "_S7" + ON COLUMN2 < "_S7".S_ACCTBAL + JOIN "_S11" "_S11" + ON COLUMN1 = "_S11".R_NAME AND "_S11".N_NATIONKEY = "_S7".S_NATIONKEY + GROUP BY + "_S11".R_NAME +) +SELECT + "_S12".R_NAME AS sup_region_name, + "_S13".N_ROWS AS n_suppliers +FROM "_S12" "_S12" +JOIN "_S13" "_S13" + ON "_S12".R_NAME = "_S13".R_NAME diff --git a/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql b/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql new file mode 100644 index 000000000..6458bb312 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql @@ -0,0 +1,83 @@ +WITH "_T" AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + CUSTOMER.c_mktsegment AS C_MKTSEGMENT, + CUSTOMER.c_name AS C_NAME, + COLUMN2 AS MRK_SEGMENT, + NATION.n_name AS N_NAME, + COLUMN1 AS NATION_NAME, + NTILE(1000) OVER (ORDER BY CUSTOMER.c_acctbal) AS "_W" + FROM (VALUES + ('UNITED STATES', 'BUILDING'), + ('JAPAN', 'AUTOMOBILE'), + ('BRAZIL', 'MACHINERY')) AS CUSTOMERS_FILTERS(NATION_NAME, MRK_SEGMENT) + CROSS JOIN TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +), "_S6" AS ( + SELECT + "_T".C_CUSTKEY, + ANY_VALUE("_T".C_ACCTBAL) AS ANYTHING_C_ACCTBAL, + ANY_VALUE("_T".C_NAME) AS ANYTHING_C_NAME, + ANY_VALUE("_T".NATION_NAME) AS ANYTHING_NATION_NAME, + COUNT(ORDERS.o_custkey) AS COUNT_O_CUSTKEY + FROM "_T" "_T" + LEFT JOIN TPCH.ORDERS ORDERS + ON ORDERS.o_custkey = "_T".C_CUSTKEY + WHERE + "_T".C_MKTSEGMENT = "_T".MRK_SEGMENT + AND "_T".NATION_NAME = "_T".N_NAME + AND "_T"."_W" > 996 + GROUP BY + "_T".C_CUSTKEY +), "_T4" AS ( + SELECT + o_custkey AS O_CUSTKEY, + ( + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_custkey ORDER BY o_orderdate) AS DATE)) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_custkey ORDER BY o_orderdate) AS DATE)) + ) AS MONTH_DIFF + FROM TPCH.ORDERS +), "_S7" AS ( + SELECT + O_CUSTKEY, + AVG(MONTH_DIFF) AS AVG_MONTH_DIFF + FROM "_T4" + GROUP BY + O_CUSTKEY +), "_T6" AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_totalprice - LEAD(o_totalprice, 1) OVER (PARTITION BY o_custkey ORDER BY o_orderdate) AS PRICE_DIFF + FROM TPCH.ORDERS +), "_S9" AS ( + SELECT + O_CUSTKEY, + AVG(PRICE_DIFF) AS AVG_PRICE_DIFF + FROM "_T6" + GROUP BY + O_CUSTKEY +) +SELECT + "_S6".ANYTHING_C_NAME AS name, + ROW_NUMBER() OVER (PARTITION BY "_S6".ANYTHING_NATION_NAME ORDER BY "_S6".ANYTHING_C_ACCTBAL DESC) AS ranking_balance, + COALESCE("_S6".COUNT_O_CUSTKEY, 0) AS n_orders, + "_S7".AVG_MONTH_DIFF AS avg_month_orders, + "_S9".AVG_PRICE_DIFF AS avg_price_diff, + "_S6".ANYTHING_C_ACCTBAL / SUM("_S6".ANYTHING_C_ACCTBAL) OVER () AS proportion, + CASE + WHEN "_S6".ANYTHING_C_ACCTBAL > AVG(CAST("_S6".ANYTHING_C_ACCTBAL AS DOUBLE PRECISION)) OVER () + THEN TRUE + ELSE FALSE + END AS above_avg, + COUNT("_S6".ANYTHING_C_ACCTBAL) OVER (ORDER BY "_S6".ANYTHING_C_ACCTBAL ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_poorer, + "_S6".ANYTHING_C_ACCTBAL / COUNT(*) OVER () AS ratio +FROM "_S6" "_S6" +LEFT JOIN "_S7" "_S7" + ON "_S6".C_CUSTKEY = "_S7".O_CUSTKEY +LEFT JOIN "_S9" "_S9" + ON "_S6".C_CUSTKEY = "_S9".O_CUSTKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql new file mode 100644 index 000000000..de9b307ed --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql @@ -0,0 +1,36 @@ +WITH "_S1" AS ( + SELECT + TRUNC(CAST(payment_date AS TIMESTAMP), 'MONTH') AS START_MONTH, + SUM(payment_amount) AS SUM_PAYMENT_AMOUNT + FROM MAIN.PAYMENTS_RECEIVED + GROUP BY + TRUNC(CAST(payment_date AS TIMESTAMP), 'MONTH') +), "_T0" AS ( + SELECT + DATETIME("_S1".START_MONTH, COLUMN1 || ' months') AS DT, + SUM(CASE WHEN COLUMN1 > 0 THEN 0 ELSE COALESCE("_S1".SUM_PAYMENT_AMOUNT, 0) END) AS SUM_PAYMENT + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9), + (10), + (11)) AS MONTHS(N) + JOIN "_S1" "_S1" + ON ( + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(1, 'hour') + ) >= DATETIME("_S1".START_MONTH, COLUMN1 || ' months') + GROUP BY + DATETIME("_S1".START_MONTH, COLUMN1 || ' months') +) +SELECT + DT AS dt, + SUM_PAYMENT AS total_payments, + SUM_PAYMENT - LAG(SUM_PAYMENT, 1) OVER (ORDER BY DT) AS MoM_change +FROM "_T0" diff --git a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql new file mode 100644 index 000000000..646e049f7 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql @@ -0,0 +1,41 @@ +WITH "_S6" AS ( + SELECT DISTINCT + COLUMN1 AS MONTH_START + FROM (VALUES + (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS MONTHS_RANGE(MONTH_START) + CROSS JOIN MAIN.SALES SALES +), "_S7" AS ( + SELECT + COLUMN1 AS MONTH_START, + COUNT(*) AS N_ROWS, + SUM(SALES.sale_price) AS SUM_SALE_PRICE + FROM (VALUES + (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), + (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS MONTHS_RANGE_2(MONTH_START) + JOIN MAIN.SALES SALES + ON TO_CHAR(COLUMN1, '%Y-%m') = TO_CHAR(SALES.sale_date, '%Y-%m') + JOIN MAIN.SALESPERSONS SALESPERSONS + ON EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) <= 2023 + AND EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) >= 2022 + AND SALES.salesperson_id = SALESPERSONS."_id" + GROUP BY + COLUMN1 +) +SELECT + TO_CHAR("_S6".MONTH_START, '%Y-%m-%d') AS month, + COALESCE("_S7".N_ROWS, 0) AS PMSPS, + COALESCE("_S7".SUM_SALE_PRICE, 0) AS PMSR +FROM "_S6" "_S6" +LEFT JOIN "_S7" "_S7" + ON "_S6".MONTH_START = "_S7".MONTH_START +ORDER BY + "_S6".MONTH_START NULLS FIRST diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql b/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql index 015fd0cdc..4ad794e0a 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_mysql.sql @@ -3,8 +3,8 @@ SELECT SUM( TIMESTAMPDIFF(SECOND, user_sessions.session_start_ts, user_sessions.session_end_ts) ) AS total_duration -FROM main.users AS users -JOIN main.user_sessions AS user_sessions +FROM ewallet.users AS users +JOIN ewallet.user_sessions AS user_sessions ON user_sessions.session_end_ts < CAST('2023-06-08' AS DATE) AND user_sessions.session_start_ts >= CAST('2023-06-01' AS DATE) AND user_sessions.user_id = users.uid diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql b/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql index 932a59624..ef986a644 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv11_snowflake.sql @@ -7,8 +7,8 @@ SELECT CAST(user_sessions.session_end_ts AS DATETIME) ) ) AS total_duration -FROM main.users AS users -JOIN main.user_sessions AS user_sessions +FROM ewallet.users AS users +JOIN ewallet.user_sessions AS user_sessions ON user_sessions.session_end_ts < CAST('2023-06-08' AS DATE) AND user_sessions.session_start_ts >= CAST('2023-06-01' AS DATE) AND user_sessions.user_id = users.uid diff --git a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql index 3fe0d0e05..ecb606335 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql @@ -1,15 +1,3 @@ -WITH "_S0" AS ( - SELECT - COUNT(*) AS N_ROWS - FROM MAIN.RESTAURANT - WHERE - rating > 4.5 -), "_S1" AS ( - SELECT - COUNT(*) AS N_ROWS - FROM MAIN.RESTAURANT -) SELECT - "_S0".N_ROWS / NULLIF("_S1".N_ROWS, 0) AS ratio -FROM "_S0" "_S0" -CROSS JOIN "_S1" "_S1" + SUM(rating > 4.5) / NULLIF(COUNT(*), 0) AS ratio +FROM MAIN.RESTAURANT diff --git a/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql index f5ed57cf5..442a90119 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql @@ -1,5 +1,8 @@ SELECT - COALESCE(SUM(LOWER(food_type) = 'vegan'), 0) / NULLIF(SUM(LOWER(food_type) <> 'vegan'), 0) AS ratio + SUM(LOWER(food_type) = 'vegan') / NULLIF(SUM(LOWER(food_type) <> 'vegan'), 0) AS ratio FROM MAIN.RESTAURANT WHERE LOWER(city_name) = 'san francisco' + AND ( + LOWER(food_type) <> 'vegan' OR LOWER(food_type) = 'vegan' + ) diff --git a/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql index 6424e1314..575d4a461 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql @@ -1,5 +1,5 @@ SELECT - COALESCE(SUM(LOWER(food_type) = 'italian'), 0) / NULLIF(COUNT(*), 0) AS ratio + SUM(LOWER(food_type) = 'italian') / NULLIF(COUNT(*), 0) AS ratio FROM MAIN.RESTAURANT WHERE LOWER(city_name) = 'los angeles' diff --git a/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql index a96442ae1..bec2c68df 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql @@ -12,7 +12,7 @@ WITH "_S1" AS ( ), "_S7" AS ( SELECT "_S3".REGION, - SUM(CASE WHEN NOT RESTAURANT.rating IS NULL THEN 1 ELSE 0 END) AS SUM_EXPR, + SUM(NOT RESTAURANT.rating IS NULL) AS SUM_EXPR, SUM(RESTAURANT.rating) AS SUM_RATING FROM MAIN.LOCATION LOCATION LEFT JOIN "_S1" "_S3" diff --git a/tests/test_sql_refsols/donor_3276_oracle.sql b/tests/test_sql_refsols/donor_3276_oracle.sql new file mode 100644 index 000000000..d627ee754 --- /dev/null +++ b/tests/test_sql_refsols/donor_3276_oracle.sql @@ -0,0 +1,7 @@ +SELECT + ( + 100.0 * SUM(LOWER(school_metro) = 'suburban') + ) / COUNT(*) AS percentage_suburban +FROM MAIN.PROJECTS +WHERE + LOWER(school_city) = 'santa barbara' diff --git a/tests/test_sql_refsols/movielens_2274_oracle.sql b/tests/test_sql_refsols/movielens_2274_oracle.sql new file mode 100644 index 000000000..c64452894 --- /dev/null +++ b/tests/test_sql_refsols/movielens_2274_oracle.sql @@ -0,0 +1,11 @@ +SELECT + CASE + WHEN COUNT(*) > 0 + THEN ( + 100.0 * SUM(LOWER(USERS.u_gender) = 'f') + ) / COUNT(*) + ELSE 0.0 + END AS percentage_of_female_users +FROM MAIN.USERS USERS +JOIN MAIN.U2BASE U2BASE + ON U2BASE.rating = 2 AND U2BASE.userid = USERS.userid diff --git a/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql new file mode 100644 index 000000000..f5ebc2f30 --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql @@ -0,0 +1,12 @@ +SELECT + COLUMN1 AS idx, + COLUMN2 AS color +FROM (VALUES + (0, 'red'), + (1, 'orange'), + (2, 'yellow'), + (3, 'green'), + (4, 'blue'), + (5, 'indigo'), + (6, 'violet'), + (7, NULL)) AS RAINBOW(IDX, COLOR) diff --git a/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql new file mode 100644 index 000000000..2d0fac87b --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COLUMN1 AS signup_date, + COLUMN2 AS user_id +FROM (VALUES + (CAST('2024-01-10 00:00:00' AS TIMESTAMP), 1), + (CAST('2024-01-12 00:00:00' AS TIMESTAMP), 2), + (CAST('2024-02-01 00:00:00' AS TIMESTAMP), 3), + (CAST('2024-02-01 00:00:00' AS TIMESTAMP), 4)) AS USERS(SIGNUP_DATE, USER_ID) diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql new file mode 100644 index 000000000..c501f02af --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COLUMN1 AS user_id, + COLUMN2 AS "`name""[", + COLUMN3 AS "space country", + COLUMN4 AS "CAST" +FROM (VALUES + (1, 'Alice', 'US', 25), + (2, 'Bob', 'CR', 30), + (3, 'Charlie', 'US', 22), + (4, 'David', 'MX', 30)) AS USERS(USER_ID, "`name""[", "space country", "CAST") diff --git a/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql new file mode 100644 index 000000000..e03658053 --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COLUMN1 AS user_id, + COLUMN2 AS country +FROM (VALUES + (1, 'US'), + (2, 'CR'), + (3, 'US'), + (4, 'MX')) AS USERS(USER_ID, COUNTRY) diff --git a/tests/test_sql_refsols/simple_range_6_oracle.sql b/tests/test_sql_refsols/simple_range_6_oracle.sql new file mode 100644 index 000000000..0cd7de281 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_6_oracle.sql @@ -0,0 +1,45 @@ +SELECT + CAST(SUBSTR(CAST(COLUMN1 AS VARCHAR2(4000)), 1, 1) AS INT) AS first_digit, + COUNT(*) AS n +FROM (VALUES + (0), + (13), + (26), + (39), + (52), + (65), + (78), + (91), + (104), + (117), + (130), + (143), + (156), + (169), + (182), + (195), + (208), + (221), + (234), + (247), + (260), + (273), + (286), + (299), + (312), + (325), + (338), + (351), + (364), + (377), + (390), + (403), + (416), + (429), + (442), + (455), + (468), + (481), + (494)) AS TBL(V) +GROUP BY + CAST(SUBSTR(CAST(COLUMN1 AS VARCHAR2(4000)), 1, 1) AS INT) diff --git a/tests/test_sql_refsols/simple_range_7_oracle.sql b/tests/test_sql_refsols/simple_range_7_oracle.sql new file mode 100644 index 000000000..486ddee65 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_7_oracle.sql @@ -0,0 +1,20 @@ +SELECT + COLUMN1 + COLUMN1 AS s, + COUNT(*) AS n, + AVG(CAST(COLUMN1 * COLUMN1 AS DOUBLE PRECISION)) AS a +FROM (VALUES + (1), + (2), + (3), + (4), + (5), + (6)) AS D1(X) +CROSS JOIN (VALUES + (1), + (2), + (3), + (4), + (5), + (6)) AS D2(Y) +GROUP BY + COLUMN1 + COLUMN1 diff --git a/tests/test_sql_refsols/simple_range_8_oracle.sql b/tests/test_sql_refsols/simple_range_8_oracle.sql new file mode 100644 index 000000000..b34b9dba2 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_8_oracle.sql @@ -0,0 +1,25 @@ +SELECT + ( + COLUMN1 + COLUMN1 + ) + COLUMN1 AS s, + COUNT(*) AS n, + AVG(COLUMN1 * COLUMN1 * COLUMN1) AS a +FROM (VALUES + (1), + (2), + (3), + (4)) AS D1(X) +CROSS JOIN (VALUES + (1), + (2), + (3), + (4)) AS D2(Y) +CROSS JOIN (VALUES + (1), + (2), + (3), + (4)) AS D3(Z) +GROUP BY + ( + COLUMN1 + COLUMN1 + ) + COLUMN1 diff --git a/tests/test_sql_refsols/simple_range_9_oracle.sql b/tests/test_sql_refsols/simple_range_9_oracle.sql new file mode 100644 index 000000000..25b3f36de --- /dev/null +++ b/tests/test_sql_refsols/simple_range_9_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COLUMN1 AS "name space" +FROM (VALUES + (0), + (1), + (2), + (3), + (4)) AS "quoted-name"("name space") diff --git a/tests/test_sql_refsols/user_range_collection_2_oracle.sql b/tests/test_sql_refsols/user_range_collection_2_oracle.sql index ce9fe88f5..b5cf31be6 100644 --- a/tests/test_sql_refsols/user_range_collection_2_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -1,18 +1,4 @@ -WITH "_S0" AS ( - SELECT - COLUMN1 AS X - FROM (VALUES - (0), - (1), - (2), - (3), - (4), - (5), - (6), - (7), - (8), - (9)) AS A(X) -), "_S1" AS ( +WITH "_S1" AS ( SELECT COLUMN1 AS Y FROM (VALUES @@ -517,31 +503,52 @@ WITH "_S0" AS ( (996), (998), (1000)) AS B(Y) -), "_S4" AS ( +), "_S3" AS ( SELECT - "_S0".X, - COUNT(*) AS N_ROWS - FROM "_S0" "_S0" + COLUMN1 AS X, + SUM( + CAST("_S1".Y AS VARCHAR2(4000)) LIKE ( + CONCAT('%', CAST(COLUMN1 AS VARCHAR2(4000))) + ) + ) AS SUM_EXPR, + SUM( + CAST("_S1".Y AS VARCHAR2(4000)) LIKE ( + CONCAT(CAST(COLUMN1 AS VARCHAR2(4000)), '%') + ) + ) AS SUM_EXPR_5 + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A_2(X) JOIN "_S1" "_S1" - ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST("_S0".X AS VARCHAR2(4000)), '%') - GROUP BY - "_S0".X -), "_S5" AS ( - SELECT - "_S2".X, - COUNT(*) AS N_ROWS - FROM "_S0" "_S2" - JOIN "_S1" "_S3" - ON CAST("_S3".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST("_S2".X AS VARCHAR2(4000))) + ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(COLUMN1 AS VARCHAR2(4000))) + OR CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(COLUMN1 AS VARCHAR2(4000)), '%') GROUP BY - "_S2".X + COLUMN1 ) SELECT - "_S4".X AS x, - "_S4".N_ROWS AS n_prefix, - "_S5".N_ROWS AS n_suffix -FROM "_S4" "_S4" -JOIN "_S5" "_S5" - ON "_S4".X = "_S5".X + COLUMN1 AS x, + COALESCE("_S3".SUM_EXPR_5, 0) AS n_prefix, + COALESCE("_S3".SUM_EXPR, 0) AS n_suffix +FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A(X) +LEFT JOIN "_S3" "_S3" + ON COLUMN1 = "_S3".X ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_3_oracle.sql b/tests/test_sql_refsols/user_range_collection_3_oracle.sql index ce9fe88f5..8210a23cc 100644 --- a/tests/test_sql_refsols/user_range_collection_3_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -1,18 +1,509 @@ -WITH "_S0" AS ( +WITH "_S1" AS ( SELECT - COLUMN1 AS X + COLUMN1 AS Y FROM (VALUES (0), - (1), (2), - (3), (4), - (5), (6), - (7), (8), - (9)) AS A(X) -), "_S1" AS ( + (10), + (12), + (14), + (16), + (18), + (20), + (22), + (24), + (26), + (28), + (30), + (32), + (34), + (36), + (38), + (40), + (42), + (44), + (46), + (48), + (50), + (52), + (54), + (56), + (58), + (60), + (62), + (64), + (66), + (68), + (70), + (72), + (74), + (76), + (78), + (80), + (82), + (84), + (86), + (88), + (90), + (92), + (94), + (96), + (98), + (100), + (102), + (104), + (106), + (108), + (110), + (112), + (114), + (116), + (118), + (120), + (122), + (124), + (126), + (128), + (130), + (132), + (134), + (136), + (138), + (140), + (142), + (144), + (146), + (148), + (150), + (152), + (154), + (156), + (158), + (160), + (162), + (164), + (166), + (168), + (170), + (172), + (174), + (176), + (178), + (180), + (182), + (184), + (186), + (188), + (190), + (192), + (194), + (196), + (198), + (200), + (202), + (204), + (206), + (208), + (210), + (212), + (214), + (216), + (218), + (220), + (222), + (224), + (226), + (228), + (230), + (232), + (234), + (236), + (238), + (240), + (242), + (244), + (246), + (248), + (250), + (252), + (254), + (256), + (258), + (260), + (262), + (264), + (266), + (268), + (270), + (272), + (274), + (276), + (278), + (280), + (282), + (284), + (286), + (288), + (290), + (292), + (294), + (296), + (298), + (300), + (302), + (304), + (306), + (308), + (310), + (312), + (314), + (316), + (318), + (320), + (322), + (324), + (326), + (328), + (330), + (332), + (334), + (336), + (338), + (340), + (342), + (344), + (346), + (348), + (350), + (352), + (354), + (356), + (358), + (360), + (362), + (364), + (366), + (368), + (370), + (372), + (374), + (376), + (378), + (380), + (382), + (384), + (386), + (388), + (390), + (392), + (394), + (396), + (398), + (400), + (402), + (404), + (406), + (408), + (410), + (412), + (414), + (416), + (418), + (420), + (422), + (424), + (426), + (428), + (430), + (432), + (434), + (436), + (438), + (440), + (442), + (444), + (446), + (448), + (450), + (452), + (454), + (456), + (458), + (460), + (462), + (464), + (466), + (468), + (470), + (472), + (474), + (476), + (478), + (480), + (482), + (484), + (486), + (488), + (490), + (492), + (494), + (496), + (498), + (500), + (502), + (504), + (506), + (508), + (510), + (512), + (514), + (516), + (518), + (520), + (522), + (524), + (526), + (528), + (530), + (532), + (534), + (536), + (538), + (540), + (542), + (544), + (546), + (548), + (550), + (552), + (554), + (556), + (558), + (560), + (562), + (564), + (566), + (568), + (570), + (572), + (574), + (576), + (578), + (580), + (582), + (584), + (586), + (588), + (590), + (592), + (594), + (596), + (598), + (600), + (602), + (604), + (606), + (608), + (610), + (612), + (614), + (616), + (618), + (620), + (622), + (624), + (626), + (628), + (630), + (632), + (634), + (636), + (638), + (640), + (642), + (644), + (646), + (648), + (650), + (652), + (654), + (656), + (658), + (660), + (662), + (664), + (666), + (668), + (670), + (672), + (674), + (676), + (678), + (680), + (682), + (684), + (686), + (688), + (690), + (692), + (694), + (696), + (698), + (700), + (702), + (704), + (706), + (708), + (710), + (712), + (714), + (716), + (718), + (720), + (722), + (724), + (726), + (728), + (730), + (732), + (734), + (736), + (738), + (740), + (742), + (744), + (746), + (748), + (750), + (752), + (754), + (756), + (758), + (760), + (762), + (764), + (766), + (768), + (770), + (772), + (774), + (776), + (778), + (780), + (782), + (784), + (786), + (788), + (790), + (792), + (794), + (796), + (798), + (800), + (802), + (804), + (806), + (808), + (810), + (812), + (814), + (816), + (818), + (820), + (822), + (824), + (826), + (828), + (830), + (832), + (834), + (836), + (838), + (840), + (842), + (844), + (846), + (848), + (850), + (852), + (854), + (856), + (858), + (860), + (862), + (864), + (866), + (868), + (870), + (872), + (874), + (876), + (878), + (880), + (882), + (884), + (886), + (888), + (890), + (892), + (894), + (896), + (898), + (900), + (902), + (904), + (906), + (908), + (910), + (912), + (914), + (916), + (918), + (920), + (922), + (924), + (926), + (928), + (930), + (932), + (934), + (936), + (938), + (940), + (942), + (944), + (946), + (948), + (950), + (952), + (954), + (956), + (958), + (960), + (962), + (964), + (966), + (968), + (970), + (972), + (974), + (976), + (978), + (980), + (982), + (984), + (986), + (988), + (990), + (992), + (994), + (996), + (998), + (1000)) AS B(Y) +), "_S3" AS ( SELECT COLUMN1 AS Y FROM (VALUES @@ -516,32 +1007,47 @@ WITH "_S0" AS ( (994), (996), (998), - (1000)) AS B(Y) -), "_S4" AS ( - SELECT - "_S0".X, - COUNT(*) AS N_ROWS - FROM "_S0" "_S0" - JOIN "_S1" "_S1" - ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST("_S0".X AS VARCHAR2(4000)), '%') - GROUP BY - "_S0".X + (1000)) AS B_2(Y) ), "_S5" AS ( SELECT - "_S2".X, + COLUMN1 AS X, COUNT(*) AS N_ROWS - FROM "_S0" "_S2" - JOIN "_S1" "_S3" - ON CAST("_S3".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST("_S2".X AS VARCHAR2(4000))) + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A_2(X) + JOIN "_S3" "_S3" + ON CAST("_S3".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(COLUMN1 AS VARCHAR2(4000))) GROUP BY - "_S2".X + COLUMN1 ) SELECT - "_S4".X AS x, - "_S4".N_ROWS AS n_prefix, - "_S5".N_ROWS AS n_suffix -FROM "_S4" "_S4" + COLUMN1 AS x, + COUNT(*) AS n_prefix, + ANY_VALUE("_S5".N_ROWS) AS n_suffix +FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A(X) +JOIN "_S1" "_S1" + ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(COLUMN1 AS VARCHAR2(4000)), '%') JOIN "_S5" "_S5" - ON "_S4".X = "_S5".X + ON COLUMN1 = "_S5".X +GROUP BY + COLUMN1 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_5_oracle.sql b/tests/test_sql_refsols/user_range_collection_5_oracle.sql index 2c420127b..a9fc6099e 100644 --- a/tests/test_sql_refsols/user_range_collection_5_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -1,6 +1,7 @@ -WITH "_S2" AS ( +WITH "_S3" AS ( SELECT - COLUMN1 AS PART_SIZE + COLUMN1 AS PART_SIZE, + COUNT(*) AS N_ROWS FROM (VALUES (1), (6), @@ -13,24 +14,31 @@ WITH "_S2" AS ( (41), (46), (51), - (56)) AS SIZES(PART_SIZE) -), "_S3" AS ( - SELECT - "_S0".PART_SIZE, - COUNT(*) AS N_ROWS - FROM "_S2" "_S0" + (56)) AS SIZES_2(PART_SIZE) JOIN TPCH.PART PART - ON PART.p_name LIKE '%almond%' + ON COLUMN1 <= PART.p_size + AND PART.p_name LIKE '%almond%' AND PART.p_size <= ( - "_S0".PART_SIZE + 4 + COLUMN1 + 4 ) - AND PART.p_size >= "_S0".PART_SIZE GROUP BY - "_S0".PART_SIZE + COLUMN1 ) SELECT - "_S2".PART_SIZE AS part_size, + COLUMN1 AS part_size, COALESCE("_S3".N_ROWS, 0) AS n_parts -FROM "_S2" "_S2" +FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56)) AS SIZES(PART_SIZE) LEFT JOIN "_S3" "_S3" - ON "_S2".PART_SIZE = "_S3".PART_SIZE + ON COLUMN1 = "_S3".PART_SIZE From e6b912a8518f35efafdaacd0de8738e98f6f8795 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 23 Feb 2026 16:29:05 -0600 Subject: [PATCH 16/48] fix for anti joins in oracle and refsol updated --- pydough/sqlglot/sqlglot_relational_visitor.py | 4 + tests/test_relational_nodes_to_sqlglot.py | 108 ++++++++++-------- .../bad_child_reuse_5_ansi.sql | 12 +- .../bad_child_reuse_5_oracle.sql | 12 +- .../defog_academic_gen21_ansi.sql | 25 ++-- .../defog_academic_gen21_oracle.sql | 25 ++-- .../defog_academic_gen22_ansi.sql | 20 +++- .../defog_academic_gen22_oracle.sql | 20 +++- .../defog_academic_gen23_ansi.sql | 13 ++- .../defog_academic_gen23_oracle.sql | 13 ++- .../defog_academic_gen24_ansi.sql | 15 ++- .../defog_academic_gen24_oracle.sql | 15 ++- .../defog_broker_adv11_ansi.sql | 19 ++- .../defog_broker_adv11_oracle.sql | 19 ++- .../defog_broker_basic10_ansi.sql | 13 ++- .../defog_broker_basic10_oracle.sql | 13 ++- .../defog_broker_basic5_ansi.sql | 15 ++- .../defog_broker_basic5_oracle.sql | 15 ++- .../defog_broker_basic6_ansi.sql | 16 ++- .../defog_broker_basic6_oracle.sql | 16 ++- .../defog_broker_basic9_ansi.sql | 13 ++- .../defog_broker_basic9_oracle.sql | 13 ++- .../defog_dealership_basic1_ansi.sql | 13 ++- .../defog_dealership_basic1_oracle.sql | 13 ++- .../defog_dealership_basic2_ansi.sql | 13 ++- .../defog_dealership_basic2_oracle.sql | 13 ++- .../defog_dealership_basic3_ansi.sql | 19 ++- .../defog_dealership_basic3_oracle.sql | 19 ++- .../defog_dealership_basic4_ansi.sql | 13 ++- .../defog_dealership_basic4_oracle.sql | 13 ++- .../defog_dermtreatment_adv15_ansi.sql | 16 ++- .../defog_dermtreatment_adv15_oracle.sql | 16 ++- .../defog_dermtreatment_adv4_ansi.sql | 23 ++-- .../defog_dermtreatment_adv4_oracle.sql | 23 ++-- .../defog_dermtreatment_adv5_ansi.sql | 18 ++- .../defog_dermtreatment_adv5_oracle.sql | 18 ++- .../defog_dermtreatment_basic10_ansi.sql | 13 ++- .../defog_dermtreatment_basic10_oracle.sql | 13 ++- .../defog_dermtreatment_basic2_ansi.sql | 24 +++- .../defog_dermtreatment_basic2_oracle.sql | 24 +++- .../defog_dermtreatment_basic5_ansi.sql | 13 ++- .../defog_dermtreatment_basic5_oracle.sql | 13 ++- .../defog_dermtreatment_basic6_ansi.sql | 17 ++- .../defog_dermtreatment_basic6_oracle.sql | 17 ++- .../defog_dermtreatment_basic9_ansi.sql | 13 ++- .../defog_dermtreatment_basic9_oracle.sql | 13 ++- .../defog_ewallet_basic2_ansi.sql | 13 ++- .../defog_ewallet_basic2_oracle.sql | 13 ++- .../defog_ewallet_basic3_ansi.sql | 16 ++- .../defog_ewallet_basic3_oracle.sql | 16 ++- .../defog_ewallet_basic4_ansi.sql | 15 ++- .../defog_ewallet_basic4_oracle.sql | 15 ++- .../defog_ewallet_basic5_ansi.sql | 13 ++- .../defog_ewallet_basic5_oracle.sql | 13 ++- .../defog_ewallet_gen5_ansi.sql | 21 +++- .../defog_ewallet_gen5_oracle.sql | 25 ++-- .../defog_restaurants_gen18_ansi.sql | 24 +++- .../defog_restaurants_gen18_oracle.sql | 24 +++- .../epoch_num_predawn_cold_war_ansi.sql | 20 +++- .../epoch_num_predawn_cold_war_oracle.sql | 20 +++- .../has_cross_correlated_singular_ansi.sql | 13 ++- .../has_cross_correlated_singular_oracle.sql | 13 ++- .../test_sql_refsols/movielens_2274_ansi.sql | 15 ++- .../movielens_2274_oracle.sql | 15 ++- .../redundant_has_not_on_singular_ansi.sql | 17 ++- .../redundant_has_not_on_singular_oracle.sql | 17 ++- .../redundant_has_on_plural_ansi.sql | 15 ++- ...redundant_has_on_plural_lineitems_ansi.sql | 15 ++- ...dundant_has_on_plural_lineitems_oracle.sql | 15 ++- .../redundant_has_on_plural_oracle.sql | 15 ++- tests/test_sql_refsols/tpch_q21_ansi.sql | 24 ++-- tests/test_sql_refsols/tpch_q21_oracle.sql | 24 ++-- tests/test_sql_refsols/tpch_q22_ansi.sql | 12 +- tests/test_sql_refsols/tpch_q22_oracle.sql | 12 +- tests/test_sql_refsols/tpch_q4_ansi.sql | 15 ++- tests/test_sql_refsols/tpch_q4_oracle.sql | 15 ++- ...di_low_income_country_with_series_ansi.sql | 16 ++- ..._low_income_country_with_series_oracle.sql | 16 ++- .../window_filter_order_10_ansi.sql | 16 ++- .../window_filter_order_10_oracle.sql | 16 ++- 80 files changed, 1062 insertions(+), 326 deletions(-) diff --git a/pydough/sqlglot/sqlglot_relational_visitor.py b/pydough/sqlglot/sqlglot_relational_visitor.py index 7f9ca77f8..8d4b4d7eb 100644 --- a/pydough/sqlglot/sqlglot_relational_visitor.py +++ b/pydough/sqlglot/sqlglot_relational_visitor.py @@ -19,6 +19,7 @@ from sqlglot.expressions import Null as SQLGlotNull from sqlglot.expressions import Star as SQLGlotStar from sqlglot.expressions import convert as sqlglot_convert +from sqlglot.transforms import eliminate_semi_and_anti_joins from pydough.configs import PyDoughSession from pydough.database_connectors import DatabaseDialect @@ -420,6 +421,9 @@ def visit_join(self, join: Join) -> None: if join_type == "SEMI" and join.cardinality.singular: join_type == "INNER" query = query.join(subquery, on=cond_expr, join_type=join_type) + # This ensures the conversion of SEMI/ANTI joins to EXISTS/NOT EXISTS + # which is necessary later when optimizing + query = eliminate_semi_and_anti_joins(query) self._stack.append(query) def visit_project(self, project: Project) -> None: diff --git a/tests/test_relational_nodes_to_sqlglot.py b/tests/test_relational_nodes_to_sqlglot.py index 937390b2a..fac022e0a 100644 --- a/tests/test_relational_nodes_to_sqlglot.py +++ b/tests/test_relational_nodes_to_sqlglot.py @@ -15,11 +15,13 @@ Add, Binary, Column, + Exists, Expression, From, Length, Literal, Lower, + Not, Order, RowNumber, Select, @@ -1002,33 +1004,35 @@ def mkglot_func(op: type[Expression], args: list[Expression]) -> Expression: ), alias="_s0", ), - join=GlotJoin( - right_query=GlotFrom( - mkglot( - expressions=[ - Ident(this="a", quoted=False), - Ident(this="b", quoted=False), - ], - _from=GlotFrom( - Table(this=Ident(this="table", quoted=False)) + where=Exists( + this=mkglot( + expressions=[mk_literal(1, False)], + _from=GlotFrom( + mkglot( + expressions=[ + Ident(this="a", quoted=False), + Ident(this="b", quoted=False), + ], + _from=GlotFrom( + Table(this=Ident(this="table", quoted=False)) + ), ), + alias="_s1", ), - alias=TableAlias(this="_s1"), - ), - on=mkglot_func( - EQ, - [ - Column( - this=Ident(this="a", quoted=False), - table=Ident(this="_s0", quoted=False), - ), - Column( - this=Ident(this="a", quoted=False), - table=Ident(this="_s1", quoted=False), - ), - ], - ), - join_type="semi", + where=mkglot_func( + EQ, + [ + Column( + this=Ident(this="a", quoted=False), + table=Ident(this="_s0", quoted=False), + ), + Column( + this=Ident(this="a", quoted=False), + table=Ident(this="_s1", quoted=False), + ), + ], + ), + ) ), ), id="simple_semi_join", @@ -1065,37 +1069,41 @@ def mkglot_func(op: type[Expression], args: list[Expression]) -> Expression: Ident(this="a", quoted=False), Ident(this="b", quoted=False), ], - _from=GlotFrom(Table(this=Ident(this="table", quoted=False))), + _from=GlotFrom( + Table(this=Ident(this="table", quoted=False)), alias=None + ), ), alias="_s0", ), - join=GlotJoin( - right_query=GlotFrom( - mkglot( - expressions=[ - Ident(this="a", quoted=False), - Ident(this="b", quoted=False), - ], + where=Not( + this=Exists( + this=mkglot( + expressions=[mk_literal(1, False)], _from=GlotFrom( - Table(this=Ident(this="table", quoted=False)) - ), - ), - alias=TableAlias(this="_s1"), - ), - on=mkglot_func( - EQ, - [ - Column( - this=Ident(this="a", quoted=False), - table=Ident(this="_s0", quoted=False), + mkglot( + expressions=[ + Ident(this="a", quoted=False), + Ident(this="b", quoted=False), + ], + _from=GlotFrom( + Table(this=Ident(this="table", quoted=False)), + alias=None, + ), + ), + alias="_s1", ), - Column( - this=Ident(this="a", quoted=False), - table=Ident(this="_s1", quoted=False), + where=EQ( + this=Column( + this=Ident(this="a", quoted=False), + table=Ident(this="_s0", quoted=False), + ), + expression=Column( + this=Ident(this="a", quoted=False), + table=Ident(this="_s1", quoted=False), + ), ), - ], - ), - join_type="anti", + ) + ) ), ), id="simple_anti_join", diff --git a/tests/test_sql_refsols/bad_child_reuse_5_ansi.sql b/tests/test_sql_refsols/bad_child_reuse_5_ansi.sql index 2d8bd5e2d..bd396316f 100644 --- a/tests/test_sql_refsols/bad_child_reuse_5_ansi.sql +++ b/tests/test_sql_refsols/bad_child_reuse_5_ansi.sql @@ -21,13 +21,21 @@ WITH _t2 AS ( 1 DESC, 2 DESC LIMIT 10 +), _u_0 AS ( + SELECT + o_custkey AS _u_1 + FROM _t2 + GROUP BY + 1 ) SELECT _s2.c_custkey AS cust_key, COALESCE(_s2.n_rows, 0) AS n_orders FROM _s2 AS _s2 -JOIN _t2 AS _s3 - ON _s2.c_custkey = _s3.o_custkey +LEFT JOIN _u_0 AS _u_0 + ON _s2.c_custkey = _u_0._u_1 +WHERE + _u_0._u_1 IS NULL ORDER BY _s2.c_acctbal DESC, 1 DESC diff --git a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql index 93d05a844..919ca6fa9 100644 --- a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql +++ b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql @@ -21,13 +21,21 @@ WITH "_T2" AS ( 1 DESC NULLS LAST, 2 DESC NULLS LAST FETCH FIRST 10 ROWS ONLY +), "_u_0" AS ( + SELECT + O_CUSTKEY AS "_u_1" + FROM "_T2" + GROUP BY + O_CUSTKEY ) SELECT "_S2".C_CUSTKEY AS cust_key, COALESCE("_S2".N_ROWS, 0) AS n_orders FROM "_S2" "_S2" -JOIN "_T2" "_S3" - ON "_S2".C_CUSTKEY = "_S3".O_CUSTKEY +LEFT JOIN "_u_0" "_u_0" + ON "_S2".C_CUSTKEY = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL ORDER BY "_S2".C_ACCTBAL DESC NULLS LAST, 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen21_ansi.sql b/tests/test_sql_refsols/defog_academic_gen21_ansi.sql index e28abbbc1..e0c5c9c96 100644 --- a/tests/test_sql_refsols/defog_academic_gen21_ansi.sql +++ b/tests/test_sql_refsols/defog_academic_gen21_ansi.sql @@ -1,12 +1,21 @@ +WITH _u_0 AS ( + SELECT + author.oid AS _u_1 + FROM main.author AS author + JOIN main.writes AS writes + ON author.aid = writes.aid + JOIN main.domain_publication AS domain_publication + ON domain_publication.pid = writes.pid + JOIN main.domain AS domain + ON domain.did = domain_publication.did AND domain.name = 'Machine Learning' + GROUP BY + 1 +) SELECT organization.name AS oranization_name, organization.oid AS organization_id FROM main.organization AS organization -JOIN main.author AS author - ON author.oid = organization.oid -JOIN main.writes AS writes - ON author.aid = writes.aid -JOIN main.domain_publication AS domain_publication - ON domain_publication.pid = writes.pid -JOIN main.domain AS domain - ON domain.did = domain_publication.did AND domain.name = 'Machine Learning' +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = organization.oid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_academic_gen21_oracle.sql b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql index aa793bf3f..2b11f8126 100644 --- a/tests/test_sql_refsols/defog_academic_gen21_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql @@ -1,12 +1,21 @@ +WITH "_u_0" AS ( + SELECT + AUTHOR.oid AS "_u_1" + FROM MAIN.AUTHOR AUTHOR + JOIN MAIN.WRITES WRITES + ON AUTHOR.aid = WRITES.aid + JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid + JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did AND DOMAIN.name = 'Machine Learning' + GROUP BY + AUTHOR.oid +) SELECT ORGANIZATION.name AS oranization_name, ORGANIZATION.oid AS organization_id FROM MAIN.ORGANIZATION ORGANIZATION -JOIN MAIN.AUTHOR AUTHOR - ON AUTHOR.oid = ORGANIZATION.oid -JOIN MAIN.WRITES WRITES - ON AUTHOR.aid = WRITES.aid -JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION - ON DOMAIN_PUBLICATION.pid = WRITES.pid -JOIN MAIN.DOMAIN DOMAIN - ON DOMAIN.did = DOMAIN_PUBLICATION.did AND DOMAIN.name = 'Machine Learning' +LEFT JOIN "_u_0" "_u_0" + ON ORGANIZATION.oid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_academic_gen22_ansi.sql b/tests/test_sql_refsols/defog_academic_gen22_ansi.sql index ca70ec1eb..53ec2291e 100644 --- a/tests/test_sql_refsols/defog_academic_gen22_ansi.sql +++ b/tests/test_sql_refsols/defog_academic_gen22_ansi.sql @@ -3,14 +3,22 @@ WITH _s0 AS ( aid, did FROM main.domain_author +), _u_0 AS ( + SELECT + _s0.aid AS _u_1 + FROM _s0 AS _s0 + JOIN _s0 AS _s1 + ON _s0.did = _s1.did + JOIN main.author AS author + ON LOWER(author.name) LIKE '%martin%' AND _s1.aid = author.aid + GROUP BY + 1 ) SELECT author.name, author.aid AS author_id FROM main.author AS author -JOIN _s0 AS _s0 - ON _s0.aid = author.aid -JOIN _s0 AS _s1 - ON _s0.did = _s1.did -JOIN main.author AS author_2 - ON LOWER(author_2.name) LIKE '%martin%' AND _s1.aid = author_2.aid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = author.aid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_academic_gen22_oracle.sql b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql index c9e088c13..affeda650 100644 --- a/tests/test_sql_refsols/defog_academic_gen22_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql @@ -3,14 +3,22 @@ WITH "_S0" AS ( aid AS AID, did AS DID FROM MAIN.DOMAIN_AUTHOR +), "_u_0" AS ( + SELECT + "_S0".AID AS "_u_1" + FROM "_S0" "_S0" + JOIN "_S0" "_S1" + ON "_S0".DID = "_S1".DID + JOIN MAIN.AUTHOR AUTHOR + ON AUTHOR.aid = "_S1".AID AND LOWER(AUTHOR.name) LIKE '%martin%' + GROUP BY + "_S0".AID ) SELECT AUTHOR.name, AUTHOR.aid AS author_id FROM MAIN.AUTHOR AUTHOR -JOIN "_S0" "_S0" - ON AUTHOR.aid = "_S0".AID -JOIN "_S0" "_S1" - ON "_S0".DID = "_S1".DID -JOIN MAIN.AUTHOR AUTHOR_2 - ON AUTHOR_2.aid = "_S1".AID AND LOWER(AUTHOR_2.name) LIKE '%martin%' +LEFT JOIN "_u_0" "_u_0" + ON AUTHOR.aid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_academic_gen23_ansi.sql b/tests/test_sql_refsols/defog_academic_gen23_ansi.sql index f8b4b7733..4104c0016 100644 --- a/tests/test_sql_refsols/defog_academic_gen23_ansi.sql +++ b/tests/test_sql_refsols/defog_academic_gen23_ansi.sql @@ -1,6 +1,15 @@ +WITH _u_0 AS ( + SELECT + oid AS _u_1 + FROM main.organization + GROUP BY + 1 +) SELECT author.name, author.aid AS author_id FROM main.author AS author -JOIN main.organization AS organization - ON author.oid = organization.oid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = author.oid +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_academic_gen23_oracle.sql b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql index 56dd99741..156bcc464 100644 --- a/tests/test_sql_refsols/defog_academic_gen23_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql @@ -1,6 +1,15 @@ +WITH "_u_0" AS ( + SELECT + oid AS "_u_1" + FROM MAIN.ORGANIZATION + GROUP BY + oid +) SELECT AUTHOR.name, AUTHOR.aid AS author_id FROM MAIN.AUTHOR AUTHOR -JOIN MAIN.ORGANIZATION ORGANIZATION - ON AUTHOR.oid = ORGANIZATION.oid +LEFT JOIN "_u_0" "_u_0" + ON AUTHOR.oid = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_academic_gen24_ansi.sql b/tests/test_sql_refsols/defog_academic_gen24_ansi.sql index 709d36693..8b9e27d18 100644 --- a/tests/test_sql_refsols/defog_academic_gen24_ansi.sql +++ b/tests/test_sql_refsols/defog_academic_gen24_ansi.sql @@ -1,7 +1,7 @@ -WITH _s7 AS ( +WITH _u_0 AS ( SELECT - domain_conference.cid, - writes.pid + domain_conference.cid AS _u_1, + writes.pid AS _u_2 FROM main.writes AS writes JOIN main.domain_author AS domain_author ON domain_author.aid = writes.aid @@ -9,11 +9,14 @@ WITH _s7 AS ( ON LOWER(domain.name) LIKE '%sociology%' AND domain.did = domain_author.did JOIN main.domain_conference AS domain_conference ON domain.did = domain_conference.did + GROUP BY + 1, + 2 ) SELECT publication.title FROM main.publication AS publication -JOIN _s7 AS _s7 - ON _s7.cid = publication.cid AND _s7.pid = publication.pid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = publication.cid AND _u_0._u_2 = publication.pid WHERE - publication.year = 2020 + NOT _u_0._u_1 IS NULL AND publication.year = 2020 diff --git a/tests/test_sql_refsols/defog_academic_gen24_oracle.sql b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql index aa489d190..098e3337e 100644 --- a/tests/test_sql_refsols/defog_academic_gen24_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql @@ -1,7 +1,7 @@ -WITH "_S7" AS ( +WITH "_u_0" AS ( SELECT - DOMAIN_CONFERENCE.cid AS CID, - WRITES.pid AS PID + DOMAIN_CONFERENCE.cid AS "_u_1", + WRITES.pid AS "_u_2" FROM MAIN.WRITES WRITES JOIN MAIN.DOMAIN_AUTHOR DOMAIN_AUTHOR ON DOMAIN_AUTHOR.aid = WRITES.aid @@ -9,11 +9,14 @@ WITH "_S7" AS ( ON DOMAIN.did = DOMAIN_AUTHOR.did AND LOWER(DOMAIN.name) LIKE '%sociology%' JOIN MAIN.DOMAIN_CONFERENCE DOMAIN_CONFERENCE ON DOMAIN.did = DOMAIN_CONFERENCE.did + GROUP BY + DOMAIN_CONFERENCE.cid, + WRITES.pid ) SELECT PUBLICATION.title FROM MAIN.PUBLICATION PUBLICATION -JOIN "_S7" "_S7" - ON PUBLICATION.cid = "_S7".CID AND PUBLICATION.pid = "_S7".PID +LEFT JOIN "_u_0" "_u_0" + ON PUBLICATION.cid = "_u_0"."_u_1" AND PUBLICATION.pid = "_u_0"."_u_2" WHERE - PUBLICATION.year = 2020 + NOT "_u_0"."_u_1" IS NULL AND PUBLICATION.year = 2020 diff --git a/tests/test_sql_refsols/defog_broker_adv11_ansi.sql b/tests/test_sql_refsols/defog_broker_adv11_ansi.sql index 296a827b2..e1dc3aa43 100644 --- a/tests/test_sql_refsols/defog_broker_adv11_ansi.sql +++ b/tests/test_sql_refsols/defog_broker_adv11_ansi.sql @@ -1,10 +1,17 @@ +WITH _u_0 AS ( + SELECT + sbtransaction.sbtxcustid AS _u_1 + FROM main.sbtransaction AS sbtransaction + JOIN main.sbticker AS sbticker + ON sbticker.sbtickerid = sbtransaction.sbtxtickerid + AND sbticker.sbtickersymbol IN ('AMZN', 'AAPL', 'GOOGL', 'META', 'NFLX') + GROUP BY + 1 +) SELECT COUNT(*) AS n_customers FROM main.sbcustomer AS sbcustomer -JOIN main.sbtransaction AS sbtransaction - ON sbcustomer.sbcustid = sbtransaction.sbtxcustid -JOIN main.sbticker AS sbticker - ON sbticker.sbtickerid = sbtransaction.sbtxtickerid - AND sbticker.sbtickersymbol IN ('AMZN', 'AAPL', 'GOOGL', 'META', 'NFLX') +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = sbcustomer.sbcustid WHERE - sbcustomer.sbcustemail LIKE '%.com' + NOT _u_0._u_1 IS NULL AND sbcustomer.sbcustemail LIKE '%.com' diff --git a/tests/test_sql_refsols/defog_broker_adv11_oracle.sql b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql index 3a46a6f5e..fe0770b5e 100644 --- a/tests/test_sql_refsols/defog_broker_adv11_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql @@ -1,10 +1,17 @@ +WITH "_u_0" AS ( + SELECT + SBTRANSACTION.sbtxcustid AS "_u_1" + FROM MAIN.SBTRANSACTION SBTRANSACTION + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickersymbol IN ('AMZN', 'AAPL', 'GOOGL', 'META', 'NFLX') + GROUP BY + SBTRANSACTION.sbtxcustid +) SELECT COUNT(*) AS n_customers FROM MAIN.SBCUSTOMER SBCUSTOMER -JOIN MAIN.SBTRANSACTION SBTRANSACTION - ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid -JOIN MAIN.SBTICKER SBTICKER - ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid - AND SBTICKER.sbtickersymbol IN ('AMZN', 'AAPL', 'GOOGL', 'META', 'NFLX') +LEFT JOIN "_u_0" "_u_0" + ON SBCUSTOMER.sbcustid = "_u_0"."_u_1" WHERE - SBCUSTOMER.sbcustemail LIKE '%.com' + NOT "_u_0"."_u_1" IS NULL AND SBCUSTOMER.sbcustemail LIKE '%.com' diff --git a/tests/test_sql_refsols/defog_broker_basic10_ansi.sql b/tests/test_sql_refsols/defog_broker_basic10_ansi.sql index c241e7b2b..1b3a16cf5 100644 --- a/tests/test_sql_refsols/defog_broker_basic10_ansi.sql +++ b/tests/test_sql_refsols/defog_broker_basic10_ansi.sql @@ -1,6 +1,15 @@ +WITH _u_0 AS ( + SELECT + sbdptickerid AS _u_1 + FROM main.sbdailyprice + GROUP BY + 1 +) SELECT sbticker.sbtickerid AS _id, sbticker.sbtickersymbol AS symbol FROM main.sbticker AS sbticker -JOIN main.sbdailyprice AS sbdailyprice - ON sbdailyprice.sbdptickerid = sbticker.sbtickerid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = sbticker.sbtickerid +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic10_oracle.sql b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql index 2adfc549e..ddd74032e 100644 --- a/tests/test_sql_refsols/defog_broker_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql @@ -1,6 +1,15 @@ +WITH "_u_0" AS ( + SELECT + sbdptickerid AS "_u_1" + FROM MAIN.SBDAILYPRICE + GROUP BY + sbdptickerid +) SELECT SBTICKER.sbtickerid AS "_id", SBTICKER.sbtickersymbol AS symbol FROM MAIN.SBTICKER SBTICKER -JOIN MAIN.SBDAILYPRICE SBDAILYPRICE - ON SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid +LEFT JOIN "_u_0" "_u_0" + ON SBTICKER.sbtickerid = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic5_ansi.sql b/tests/test_sql_refsols/defog_broker_basic5_ansi.sql index c10e1f661..669d92e42 100644 --- a/tests/test_sql_refsols/defog_broker_basic5_ansi.sql +++ b/tests/test_sql_refsols/defog_broker_basic5_ansi.sql @@ -1,5 +1,16 @@ +WITH _u_0 AS ( + SELECT + sbtxcustid AS _u_1 + FROM main.sbtransaction + WHERE + sbtxtype = 'buy' + GROUP BY + 1 +) SELECT sbcustomer.sbcustid AS _id FROM main.sbcustomer AS sbcustomer -JOIN main.sbtransaction AS sbtransaction - ON sbcustomer.sbcustid = sbtransaction.sbtxcustid AND sbtransaction.sbtxtype = 'buy' +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = sbcustomer.sbcustid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic5_oracle.sql b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql index a654464c9..70cf23747 100644 --- a/tests/test_sql_refsols/defog_broker_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql @@ -1,5 +1,16 @@ +WITH "_u_0" AS ( + SELECT + sbtxcustid AS "_u_1" + FROM MAIN.SBTRANSACTION + WHERE + sbtxtype = 'buy' + GROUP BY + sbtxcustid +) SELECT SBCUSTOMER.sbcustid AS "_id" FROM MAIN.SBCUSTOMER SBCUSTOMER -JOIN MAIN.SBTRANSACTION SBTRANSACTION - ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid AND SBTRANSACTION.sbtxtype = 'buy' +LEFT JOIN "_u_0" "_u_0" + ON SBCUSTOMER.sbcustid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic6_ansi.sql b/tests/test_sql_refsols/defog_broker_basic6_ansi.sql index 2da031248..170c215bd 100644 --- a/tests/test_sql_refsols/defog_broker_basic6_ansi.sql +++ b/tests/test_sql_refsols/defog_broker_basic6_ansi.sql @@ -1,6 +1,16 @@ +WITH _u_0 AS ( + SELECT + sbdptickerid AS _u_1 + FROM main.sbdailyprice + WHERE + sbdpdate >= CAST('2023-04-01' AS DATE) + GROUP BY + 1 +) SELECT sbticker.sbtickerid AS _id FROM main.sbticker AS sbticker -JOIN main.sbdailyprice AS sbdailyprice - ON sbdailyprice.sbdpdate >= CAST('2023-04-01' AS DATE) - AND sbdailyprice.sbdptickerid = sbticker.sbtickerid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = sbticker.sbtickerid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic6_oracle.sql b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql index d98f14363..fcbc32619 100644 --- a/tests/test_sql_refsols/defog_broker_basic6_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql @@ -1,6 +1,16 @@ +WITH "_u_0" AS ( + SELECT + sbdptickerid AS "_u_1" + FROM MAIN.SBDAILYPRICE + WHERE + sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') + GROUP BY + sbdptickerid +) SELECT SBTICKER.sbtickerid AS "_id" FROM MAIN.SBTICKER SBTICKER -JOIN MAIN.SBDAILYPRICE SBDAILYPRICE - ON SBDAILYPRICE.sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') - AND SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid +LEFT JOIN "_u_0" "_u_0" + ON SBTICKER.sbtickerid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic9_ansi.sql b/tests/test_sql_refsols/defog_broker_basic9_ansi.sql index b1d447858..f96baada7 100644 --- a/tests/test_sql_refsols/defog_broker_basic9_ansi.sql +++ b/tests/test_sql_refsols/defog_broker_basic9_ansi.sql @@ -1,6 +1,15 @@ +WITH _u_0 AS ( + SELECT + sbtxcustid AS _u_1 + FROM main.sbtransaction + GROUP BY + 1 +) SELECT sbcustomer.sbcustid AS _id, sbcustomer.sbcustname AS name FROM main.sbcustomer AS sbcustomer -JOIN main.sbtransaction AS sbtransaction - ON sbcustomer.sbcustid = sbtransaction.sbtxcustid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = sbcustomer.sbcustid +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_broker_basic9_oracle.sql b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql index 626c335e8..dbffc9064 100644 --- a/tests/test_sql_refsols/defog_broker_basic9_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql @@ -1,6 +1,15 @@ +WITH "_u_0" AS ( + SELECT + sbtxcustid AS "_u_1" + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) SELECT SBCUSTOMER.sbcustid AS "_id", SBCUSTOMER.sbcustname AS name FROM MAIN.SBCUSTOMER SBCUSTOMER -JOIN MAIN.SBTRANSACTION SBTRANSACTION - ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid +LEFT JOIN "_u_0" "_u_0" + ON SBCUSTOMER.sbcustid = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic1_ansi.sql b/tests/test_sql_refsols/defog_dealership_basic1_ansi.sql index 989d9cff0..bbd756397 100644 --- a/tests/test_sql_refsols/defog_dealership_basic1_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_basic1_ansi.sql @@ -1,8 +1,17 @@ +WITH _u_0 AS ( + SELECT + car_id AS _u_1 + FROM main.sales + GROUP BY + 1 +) SELECT cars._id, cars.make, cars.model, cars.year FROM main.cars AS cars -JOIN main.sales AS sales - ON cars._id = sales.car_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = cars._id +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql index 9aa0abe60..e81d1523f 100644 --- a/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql @@ -1,8 +1,17 @@ +WITH "_u_0" AS ( + SELECT + car_id AS "_u_1" + FROM MAIN.SALES + GROUP BY + car_id +) SELECT CARS."_id", CARS.make, CARS.model, CARS.year FROM MAIN.CARS CARS -JOIN MAIN.SALES SALES - ON CARS."_id" = SALES.car_id +LEFT JOIN "_u_0" "_u_0" + ON CARS."_id" = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic2_ansi.sql b/tests/test_sql_refsols/defog_dealership_basic2_ansi.sql index a5986c275..16cb73183 100644 --- a/tests/test_sql_refsols/defog_dealership_basic2_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_basic2_ansi.sql @@ -1,5 +1,14 @@ +WITH _u_0 AS ( + SELECT + customer_id AS _u_1 + FROM main.sales + GROUP BY + 1 +) SELECT customers._id FROM main.customers AS customers -JOIN main.sales AS sales - ON customers._id = sales.customer_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = customers._id +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql index d8d9fb956..0226adadc 100644 --- a/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql @@ -1,5 +1,14 @@ +WITH "_u_0" AS ( + SELECT + customer_id AS "_u_1" + FROM MAIN.SALES + GROUP BY + customer_id +) SELECT CUSTOMERS."_id" FROM MAIN.CUSTOMERS CUSTOMERS -JOIN MAIN.SALES SALES - ON CUSTOMERS."_id" = SALES.customer_id +LEFT JOIN "_u_0" "_u_0" + ON CUSTOMERS."_id" = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic3_ansi.sql b/tests/test_sql_refsols/defog_dealership_basic3_ansi.sql index 04f650379..4310aba26 100644 --- a/tests/test_sql_refsols/defog_dealership_basic3_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_basic3_ansi.sql @@ -1,8 +1,17 @@ +WITH _u_0 AS ( + SELECT + sales.salesperson_id AS _u_1 + FROM main.sales AS sales + JOIN main.payments_received AS payments_received + ON payments_received.payment_method = 'cash' + AND payments_received.sale_id = sales._id + GROUP BY + 1 +) SELECT salespersons._id AS salesperson_id FROM main.salespersons AS salespersons -JOIN main.sales AS sales - ON sales.salesperson_id = salespersons._id -JOIN main.payments_received AS payments_received - ON payments_received.payment_method = 'cash' - AND payments_received.sale_id = sales._id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = salespersons._id +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql index 54603aaf0..765d7a83c 100644 --- a/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql @@ -1,8 +1,17 @@ +WITH "_u_0" AS ( + SELECT + SALES.salesperson_id AS "_u_1" + FROM MAIN.SALES SALES + JOIN MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED + ON PAYMENTS_RECEIVED.payment_method = 'cash' + AND PAYMENTS_RECEIVED.sale_id = SALES."_id" + GROUP BY + SALES.salesperson_id +) SELECT SALESPERSONS."_id" AS salesperson_id FROM MAIN.SALESPERSONS SALESPERSONS -JOIN MAIN.SALES SALES - ON SALES.salesperson_id = SALESPERSONS."_id" -JOIN MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED - ON PAYMENTS_RECEIVED.payment_method = 'cash' - AND PAYMENTS_RECEIVED.sale_id = SALES."_id" +LEFT JOIN "_u_0" "_u_0" + ON SALESPERSONS."_id" = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic4_ansi.sql b/tests/test_sql_refsols/defog_dealership_basic4_ansi.sql index 9d0ce87c8..8d94ed4be 100644 --- a/tests/test_sql_refsols/defog_dealership_basic4_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_basic4_ansi.sql @@ -1,7 +1,16 @@ +WITH _u_0 AS ( + SELECT + salesperson_id AS _u_1 + FROM main.sales + GROUP BY + 1 +) SELECT salespersons._id, salespersons.first_name, salespersons.last_name FROM main.salespersons AS salespersons -JOIN main.sales AS sales - ON sales.salesperson_id = salespersons._id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = salespersons._id +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql index 43376b4de..deb8447da 100644 --- a/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql @@ -1,7 +1,16 @@ +WITH "_u_0" AS ( + SELECT + salesperson_id AS "_u_1" + FROM MAIN.SALES + GROUP BY + salesperson_id +) SELECT SALESPERSONS."_id", SALESPERSONS.first_name, SALESPERSONS.last_name FROM MAIN.SALESPERSONS SALESPERSONS -JOIN MAIN.SALES SALES - ON SALES.salesperson_id = SALESPERSONS."_id" +LEFT JOIN "_u_0" "_u_0" + ON SALESPERSONS."_id" = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_ansi.sql index 88abd7b0b..be10c192f 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv15_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_ansi.sql @@ -1,4 +1,12 @@ -WITH _s3 AS ( +WITH _u_0 AS ( + SELECT + drug_id AS _u_1 + FROM main.treatments + WHERE + NOT end_dt IS NULL + GROUP BY + 1 +), _s3 AS ( SELECT drug_id, AVG( @@ -14,7 +22,9 @@ SELECT drugs.drug_name, _s3.avg_ddd FROM main.drugs AS drugs -JOIN main.treatments AS treatments - ON NOT treatments.end_dt IS NULL AND drugs.drug_id = treatments.drug_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = drugs.drug_id LEFT JOIN _s3 AS _s3 ON _s3.drug_id = drugs.drug_id +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql index 9232e2d7f..d3b436690 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -1,4 +1,12 @@ -WITH "_S3" AS ( +WITH "_u_0" AS ( + SELECT + drug_id AS "_u_1" + FROM MAIN.TREATMENTS + WHERE + NOT end_dt IS NULL + GROUP BY + drug_id +), "_S3" AS ( SELECT drug_id AS DRUG_ID, AVG( @@ -20,7 +28,9 @@ SELECT DRUGS.drug_name, "_S3".AVG_DDD AS avg_ddd FROM MAIN.DRUGS DRUGS -JOIN MAIN.TREATMENTS TREATMENTS - ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT TREATMENTS.end_dt IS NULL +LEFT JOIN "_u_0" "_u_0" + ON DRUGS.drug_id = "_u_0"."_u_1" LEFT JOIN "_S3" "_S3" ON DRUGS.drug_id = "_S3".DRUG_ID +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv4_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_adv4_ansi.sql index 9bcb9e42a..1a238f9cb 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv4_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv4_ansi.sql @@ -1,10 +1,19 @@ +WITH _u_0 AS ( + SELECT + treatments.patient_id AS _u_1 + FROM main.treatments AS treatments + JOIN main.diagnoses AS diagnoses + ON LOWER(diagnoses.diag_name) = 'psoriasis vulgaris' + AND diagnoses.diag_id = treatments.diag_id + JOIN main.drugs AS drugs + ON LOWER(drugs.drug_type) = 'biologic' AND drugs.drug_id = treatments.drug_id + GROUP BY + 1 +) SELECT COUNT(*) AS patient_count FROM main.patients AS patients -JOIN main.treatments AS treatments - ON patients.patient_id = treatments.patient_id -JOIN main.diagnoses AS diagnoses - ON LOWER(diagnoses.diag_name) = 'psoriasis vulgaris' - AND diagnoses.diag_id = treatments.diag_id -JOIN main.drugs AS drugs - ON LOWER(drugs.drug_type) = 'biologic' AND drugs.drug_id = treatments.drug_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = patients.patient_id +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql index 53e8a3e3d..046397694 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql @@ -1,10 +1,19 @@ +WITH "_u_0" AS ( + SELECT + TREATMENTS.patient_id AS "_u_1" + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.DIAGNOSES DIAGNOSES + ON DIAGNOSES.diag_id = TREATMENTS.diag_id + AND LOWER(DIAGNOSES.diag_name) = 'psoriasis vulgaris' + JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND LOWER(DRUGS.drug_type) = 'biologic' + GROUP BY + TREATMENTS.patient_id +) SELECT COUNT(*) AS patient_count FROM MAIN.PATIENTS PATIENTS -JOIN MAIN.TREATMENTS TREATMENTS - ON PATIENTS.patient_id = TREATMENTS.patient_id -JOIN MAIN.DIAGNOSES DIAGNOSES - ON DIAGNOSES.diag_id = TREATMENTS.diag_id - AND LOWER(DIAGNOSES.diag_name) = 'psoriasis vulgaris' -JOIN MAIN.DRUGS DRUGS - ON DRUGS.drug_id = TREATMENTS.drug_id AND LOWER(DRUGS.drug_type) = 'biologic' +LEFT JOIN "_u_0" "_u_0" + ON PATIENTS.patient_id = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv5_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_adv5_ansi.sql index e86b2495d..15ee16145 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv5_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_ansi.sql @@ -1,11 +1,19 @@ -WITH _t1 AS ( +WITH _u_0 AS ( SELECT - MIN(EXTRACT(YEAR FROM CAST(treatments_2.start_dt AS DATETIME))) AS min_year_start_dt + patient_id AS _u_1 + FROM main.treatments + GROUP BY + 1 +), _t1 AS ( + SELECT + MIN(EXTRACT(YEAR FROM CAST(treatments.start_dt AS DATETIME))) AS min_year_start_dt FROM main.patients AS patients - JOIN main.treatments AS treatments + LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = patients.patient_id + LEFT JOIN main.treatments AS treatments ON patients.patient_id = treatments.patient_id - LEFT JOIN main.treatments AS treatments_2 - ON patients.patient_id = treatments_2.patient_id + WHERE + NOT _u_0._u_1 IS NULL GROUP BY patients.patient_id ), _t0 AS ( diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql index d22d810a7..8880cb617 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql @@ -1,11 +1,19 @@ -WITH "_T1" AS ( +WITH "_u_0" AS ( SELECT - MIN(EXTRACT(YEAR FROM CAST(TREATMENTS_2.start_dt AS DATE))) AS MIN_YEAR_START_DT + patient_id AS "_u_1" + FROM MAIN.TREATMENTS + GROUP BY + patient_id +), "_T1" AS ( + SELECT + MIN(EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE))) AS MIN_YEAR_START_DT FROM MAIN.PATIENTS PATIENTS - JOIN MAIN.TREATMENTS TREATMENTS + LEFT JOIN "_u_0" "_u_0" + ON PATIENTS.patient_id = "_u_0"."_u_1" + LEFT JOIN MAIN.TREATMENTS TREATMENTS ON PATIENTS.patient_id = TREATMENTS.patient_id - LEFT JOIN MAIN.TREATMENTS TREATMENTS_2 - ON PATIENTS.patient_id = TREATMENTS_2.patient_id + WHERE + NOT "_u_0"."_u_1" IS NULL GROUP BY PATIENTS.patient_id ), "_T0" AS ( diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic10_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_basic10_ansi.sql index 6d6652145..f8775f649 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic10_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic10_ansi.sql @@ -1,6 +1,15 @@ +WITH _u_0 AS ( + SELECT + drug_id AS _u_1 + FROM main.treatments + GROUP BY + 1 +) SELECT drugs.drug_id, drugs.drug_name FROM main.drugs AS drugs -JOIN main.treatments AS treatments - ON drugs.drug_id = treatments.drug_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = drugs.drug_id +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql index f83061557..9ed9076d2 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql @@ -1,6 +1,15 @@ +WITH "_u_0" AS ( + SELECT + drug_id AS "_u_1" + FROM MAIN.TREATMENTS + GROUP BY + drug_id +) SELECT DRUGS.drug_id, DRUGS.drug_name FROM MAIN.DRUGS DRUGS -JOIN MAIN.TREATMENTS TREATMENTS - ON DRUGS.drug_id = TREATMENTS.drug_id +LEFT JOIN "_u_0" "_u_0" + ON DRUGS.drug_id = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic2_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_basic2_ansi.sql index 212edfb9c..64d3bfe81 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic2_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_ansi.sql @@ -13,6 +13,12 @@ WITH _t2 AS ( FROM main.outcomes WHERE NOT day100_pasi_score IS NULL +), _u_0 AS ( + SELECT + treatment_id AS _u_1 + FROM _t3 + GROUP BY + 1 ), _s3 AS ( SELECT ins_type, @@ -23,10 +29,18 @@ WITH _t2 AS ( _s3.ins_type, COUNT(DISTINCT _t2.patient_id) AS ndistinct_patient_id FROM _t2 AS _t2 - JOIN _t3 AS _t3 - ON _t2.treatment_id = _t3.treatment_id + LEFT JOIN _u_0 AS _u_0 + ON _t2.treatment_id = _u_0._u_1 JOIN _s3 AS _s3 ON _s3.patient_id = _t2.patient_id + WHERE + NOT _u_0._u_1 IS NULL + GROUP BY + 1 +), _u_2 AS ( + SELECT + treatment_id AS _u_3 + FROM _t3 GROUP BY 1 ), _s9 AS ( @@ -42,12 +56,14 @@ WITH _t2 AS ( SUM(_s9.sum_day100_pasi_score) / SUM(_s9.count_day100_pasi_score) AS avg_day100_pasi_score, _s7.ins_type FROM _t2 AS _t6 - JOIN _t3 AS _t7 - ON _t6.treatment_id = _t7.treatment_id + LEFT JOIN _u_2 AS _u_2 + ON _t6.treatment_id = _u_2._u_3 JOIN _s3 AS _s7 ON _s7.patient_id = _t6.patient_id JOIN _s9 AS _s9 ON _s9.treatment_id = _t6.treatment_id + WHERE + NOT _u_2._u_3 IS NULL GROUP BY 2 ) diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql index db219fa69..0c6016235 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql @@ -13,6 +13,12 @@ WITH "_T2" AS ( FROM MAIN.OUTCOMES WHERE NOT day100_pasi_score IS NULL +), "_u_0" AS ( + SELECT + TREATMENT_ID AS "_u_1" + FROM "_T3" + GROUP BY + TREATMENT_ID ), "_S3" AS ( SELECT ins_type AS INS_TYPE, @@ -23,12 +29,20 @@ WITH "_T2" AS ( "_S3".INS_TYPE, COUNT(DISTINCT "_T2".PATIENT_ID) AS NDISTINCT_PATIENT_ID FROM "_T2" "_T2" - JOIN "_T3" "_T3" - ON "_T2".TREATMENT_ID = "_T3".TREATMENT_ID + LEFT JOIN "_u_0" "_u_0" + ON "_T2".TREATMENT_ID = "_u_0"."_u_1" JOIN "_S3" "_S3" ON "_S3".PATIENT_ID = "_T2".PATIENT_ID + WHERE + NOT "_u_0"."_u_1" IS NULL GROUP BY "_S3".INS_TYPE +), "_u_2" AS ( + SELECT + TREATMENT_ID AS "_u_3" + FROM "_T3" + GROUP BY + TREATMENT_ID ), "_S9" AS ( SELECT treatment_id AS TREATMENT_ID, @@ -42,12 +56,14 @@ WITH "_T2" AS ( SUM("_S9".SUM_DAY100_PASI_SCORE) / SUM("_S9".COUNT_DAY100_PASI_SCORE) AS AVG_DAY100_PASI_SCORE, "_S7".INS_TYPE FROM "_T2" "_T6" - JOIN "_T3" "_T7" - ON "_T6".TREATMENT_ID = "_T7".TREATMENT_ID + LEFT JOIN "_u_2" "_u_2" + ON "_T6".TREATMENT_ID = "_u_2"."_u_3" JOIN "_S3" "_S7" ON "_S7".PATIENT_ID = "_T6".PATIENT_ID JOIN "_S9" "_S9" ON "_S9".TREATMENT_ID = "_T6".TREATMENT_ID + WHERE + NOT "_u_2"."_u_3" IS NULL GROUP BY "_S7".INS_TYPE ) diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic5_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_basic5_ansi.sql index 3c7775b42..f48f8fd90 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic5_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic5_ansi.sql @@ -1,7 +1,16 @@ +WITH _u_0 AS ( + SELECT + doc_id AS _u_1 + FROM main.treatments + GROUP BY + 1 +) SELECT doctors.doc_id, doctors.first_name, doctors.last_name FROM main.doctors AS doctors -JOIN main.treatments AS treatments - ON doctors.doc_id = treatments.doc_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = doctors.doc_id +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql index 07f71c274..e14d6a2a5 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql @@ -1,7 +1,16 @@ +WITH "_u_0" AS ( + SELECT + doc_id AS "_u_1" + FROM MAIN.TREATMENTS + GROUP BY + doc_id +) SELECT DOCTORS.doc_id, DOCTORS.first_name, DOCTORS.last_name FROM MAIN.DOCTORS DOCTORS -JOIN MAIN.TREATMENTS TREATMENTS - ON DOCTORS.doc_id = TREATMENTS.doc_id +LEFT JOIN "_u_0" "_u_0" + ON DOCTORS.doc_id = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic6_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_basic6_ansi.sql index 909349816..5999efcc3 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic6_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic6_ansi.sql @@ -1,9 +1,18 @@ +WITH _u_0 AS ( + SELECT + treatments.patient_id AS _u_1 + FROM main.treatments AS treatments + JOIN main.outcomes AS outcomes + ON outcomes.treatment_id = treatments.treatment_id + GROUP BY + 1 +) SELECT patients.patient_id, patients.first_name, patients.last_name FROM main.patients AS patients -JOIN main.treatments AS treatments - ON patients.patient_id = treatments.patient_id -JOIN main.outcomes AS outcomes - ON outcomes.treatment_id = treatments.treatment_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = patients.patient_id +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql index 6998557e6..5c2425013 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql @@ -1,9 +1,18 @@ +WITH "_u_0" AS ( + SELECT + TREATMENTS.patient_id AS "_u_1" + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.OUTCOMES OUTCOMES + ON OUTCOMES.treatment_id = TREATMENTS.treatment_id + GROUP BY + TREATMENTS.patient_id +) SELECT PATIENTS.patient_id, PATIENTS.first_name, PATIENTS.last_name FROM MAIN.PATIENTS PATIENTS -JOIN MAIN.TREATMENTS TREATMENTS - ON PATIENTS.patient_id = TREATMENTS.patient_id -JOIN MAIN.OUTCOMES OUTCOMES - ON OUTCOMES.treatment_id = TREATMENTS.treatment_id +LEFT JOIN "_u_0" "_u_0" + ON PATIENTS.patient_id = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic9_ansi.sql b/tests/test_sql_refsols/defog_dermtreatment_basic9_ansi.sql index c53417119..4d0660da7 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic9_ansi.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic9_ansi.sql @@ -1,7 +1,16 @@ +WITH _u_0 AS ( + SELECT + patient_id AS _u_1 + FROM main.treatments + GROUP BY + 1 +) SELECT patients.patient_id, patients.first_name, patients.last_name FROM main.patients AS patients -JOIN main.treatments AS treatments - ON patients.patient_id = treatments.patient_id +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = patients.patient_id +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql index c6256e898..5dfffa6c4 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql @@ -1,7 +1,16 @@ +WITH "_u_0" AS ( + SELECT + patient_id AS "_u_1" + FROM MAIN.TREATMENTS + GROUP BY + patient_id +) SELECT PATIENTS.patient_id, PATIENTS.first_name, PATIENTS.last_name FROM MAIN.PATIENTS PATIENTS -JOIN MAIN.TREATMENTS TREATMENTS - ON PATIENTS.patient_id = TREATMENTS.patient_id +LEFT JOIN "_u_0" "_u_0" + ON PATIENTS.patient_id = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic2_ansi.sql b/tests/test_sql_refsols/defog_ewallet_basic2_ansi.sql index a9d80af14..9ca419d96 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic2_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic2_ansi.sql @@ -1,6 +1,15 @@ +WITH _u_0 AS ( + SELECT + merchant_id AS _u_1 + FROM main.coupons + GROUP BY + 1 +) SELECT merchants.mid AS merchant_id, merchants.name AS merchant_name FROM main.merchants AS merchants -JOIN main.coupons AS coupons - ON coupons.merchant_id = merchants.mid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = merchants.mid +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql index 8a6bdf8d9..04ff871d4 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql @@ -1,6 +1,15 @@ +WITH "_u_0" AS ( + SELECT + merchant_id AS "_u_1" + FROM MAIN.COUPONS + GROUP BY + merchant_id +) SELECT MERCHANTS.mid AS merchant_id, MERCHANTS.name AS merchant_name FROM MAIN.MERCHANTS MERCHANTS -JOIN MAIN.COUPONS COUPONS - ON COUPONS.merchant_id = MERCHANTS.mid +LEFT JOIN "_u_0" "_u_0" + ON MERCHANTS.mid = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic3_ansi.sql b/tests/test_sql_refsols/defog_ewallet_basic3_ansi.sql index ed5e5d632..80b4b414d 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic3_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic3_ansi.sql @@ -1,6 +1,16 @@ +WITH _u_0 AS ( + SELECT + receiver_id AS _u_1 + FROM main.wallet_transactions_daily + WHERE + receiver_type = 1 + GROUP BY + 1 +) SELECT merchants.mid AS merchant FROM main.merchants AS merchants -JOIN main.wallet_transactions_daily AS wallet_transactions_daily - ON merchants.mid = wallet_transactions_daily.receiver_id - AND wallet_transactions_daily.receiver_type = 1 +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = merchants.mid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql index 6a3d1b881..ab9c12081 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql @@ -1,6 +1,16 @@ +WITH "_u_0" AS ( + SELECT + receiver_id AS "_u_1" + FROM MAIN.WALLET_TRANSACTIONS_DAILY + WHERE + receiver_type = 1 + GROUP BY + receiver_id +) SELECT MERCHANTS.mid AS merchant FROM MAIN.MERCHANTS MERCHANTS -JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY - ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id - AND WALLET_TRANSACTIONS_DAILY.receiver_type = 1 +LEFT JOIN "_u_0" "_u_0" + ON MERCHANTS.mid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic4_ansi.sql b/tests/test_sql_refsols/defog_ewallet_basic4_ansi.sql index c6c00d779..b831e9388 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic4_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic4_ansi.sql @@ -1,5 +1,16 @@ +WITH _u_0 AS ( + SELECT + user_id AS _u_1 + FROM main.notifications + WHERE + type = 'transaction' + GROUP BY + 1 +) SELECT users.uid AS user_id FROM main.users AS users -JOIN main.notifications AS notifications - ON notifications.type = 'transaction' AND notifications.user_id = users.uid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = users.uid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql index 4d70d0ac7..46556c698 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql @@ -1,5 +1,16 @@ +WITH "_u_0" AS ( + SELECT + user_id AS "_u_1" + FROM MAIN.NOTIFICATIONS + WHERE + type = 'transaction' + GROUP BY + user_id +) SELECT USERS.uid AS user_id FROM MAIN.USERS USERS -JOIN MAIN.NOTIFICATIONS NOTIFICATIONS - ON NOTIFICATIONS.type = 'transaction' AND NOTIFICATIONS.user_id = USERS.uid +LEFT JOIN "_u_0" "_u_0" + ON USERS.uid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic5_ansi.sql b/tests/test_sql_refsols/defog_ewallet_basic5_ansi.sql index dff11a488..b1a33dd01 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic5_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic5_ansi.sql @@ -1,6 +1,15 @@ +WITH _u_0 AS ( + SELECT + user_id AS _u_1 + FROM main.notifications + GROUP BY + 1 +) SELECT users.uid, users.username FROM main.users AS users -JOIN main.notifications AS notifications - ON notifications.user_id = users.uid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = users.uid +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql index c4afae6f5..6d65082a9 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql @@ -1,6 +1,15 @@ +WITH "_u_0" AS ( + SELECT + user_id AS "_u_1" + FROM MAIN.NOTIFICATIONS + GROUP BY + user_id +) SELECT USERS.uid, USERS.username FROM MAIN.USERS USERS -JOIN MAIN.NOTIFICATIONS NOTIFICATIONS - ON NOTIFICATIONS.user_id = USERS.uid +LEFT JOIN "_u_0" "_u_0" + ON USERS.uid = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_ansi.sql b/tests/test_sql_refsols/defog_ewallet_gen5_ansi.sql index d14b826f2..fb0cc8af3 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen5_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen5_ansi.sql @@ -1,11 +1,20 @@ +WITH _u_0 AS ( + SELECT + notifications.user_id AS _u_1 + FROM main.notifications AS notifications + JOIN main.users AS users + ON notifications.created_at <= DATE_ADD(CAST(users.created_at AS TIMESTAMP), 1, 'YEAR') + AND notifications.created_at >= users.created_at + AND notifications.user_id = users.uid + GROUP BY + 1 +) SELECT users.username, users.email, users.created_at FROM main.users AS users -JOIN main.notifications AS notifications - ON notifications.user_id = users.uid -JOIN main.users AS users_2 - ON notifications.created_at <= DATE_ADD(CAST(users_2.created_at AS TIMESTAMP), 1, 'YEAR') - AND notifications.created_at >= users_2.created_at - AND notifications.user_id = users_2.uid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = users.uid +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql index 45935bd00..839319b6d 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -1,13 +1,22 @@ +WITH "_u_0" AS ( + SELECT + NOTIFICATIONS.user_id AS "_u_1" + FROM MAIN.NOTIFICATIONS NOTIFICATIONS + JOIN MAIN.USERS USERS + ON NOTIFICATIONS.created_at <= ( + CAST(USERS.created_at AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + ) + AND NOTIFICATIONS.created_at >= USERS.created_at + AND NOTIFICATIONS.user_id = USERS.uid + GROUP BY + NOTIFICATIONS.user_id +) SELECT USERS.username, USERS.email, USERS.created_at FROM MAIN.USERS USERS -JOIN MAIN.NOTIFICATIONS NOTIFICATIONS - ON NOTIFICATIONS.user_id = USERS.uid -JOIN MAIN.USERS USERS_2 - ON NOTIFICATIONS.created_at <= ( - CAST(USERS_2.created_at AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') - ) - AND NOTIFICATIONS.created_at >= USERS_2.created_at - AND NOTIFICATIONS.user_id = USERS_2.uid +LEFT JOIN "_u_0" "_u_0" + ON USERS.uid = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/defog_restaurants_gen18_ansi.sql b/tests/test_sql_refsols/defog_restaurants_gen18_ansi.sql index c12293c26..96c57b245 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen18_ansi.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen18_ansi.sql @@ -7,12 +7,26 @@ WITH _s0 AS ( SELECT city_name FROM main.restaurant +), _u_0 AS ( + SELECT + city_name AS _u_1 + FROM _s1 + GROUP BY + 1 ), _s6 AS ( SELECT DISTINCT _s0.region FROM _s0 AS _s0 - JOIN _s1 AS _s1 - ON _s0.city_name = _s1.city_name + LEFT JOIN _u_0 AS _u_0 + ON _s0.city_name = _u_0._u_1 + WHERE + NOT _u_0._u_1 IS NULL +), _u_2 AS ( + SELECT + city_name AS _u_3 + FROM _s1 + GROUP BY + 1 ), _s5 AS ( SELECT city_name, @@ -26,10 +40,12 @@ WITH _s0 AS ( SUM(_s5.sum_rating) / SUM(_s5.count_rating) AS avg_rating, _s2.region FROM _s0 AS _s2 - JOIN _s1 AS _s3 - ON _s2.city_name = _s3.city_name + LEFT JOIN _u_2 AS _u_2 + ON _s2.city_name = _u_2._u_3 JOIN _s5 AS _s5 ON _s2.city_name = _s5.city_name + WHERE + NOT _u_2._u_3 IS NULL GROUP BY 2 ) diff --git a/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql index 6a2320f36..63f68c3d5 100644 --- a/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql +++ b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql @@ -7,12 +7,26 @@ WITH "_S0" AS ( SELECT city_name AS CITY_NAME FROM MAIN.RESTAURANT +), "_u_0" AS ( + SELECT + CITY_NAME AS "_u_1" + FROM "_S1" + GROUP BY + CITY_NAME ), "_S6" AS ( SELECT DISTINCT "_S0".REGION FROM "_S0" "_S0" - JOIN "_S1" "_S1" - ON "_S0".CITY_NAME = "_S1".CITY_NAME + LEFT JOIN "_u_0" "_u_0" + ON "_S0".CITY_NAME = "_u_0"."_u_1" + WHERE + NOT "_u_0"."_u_1" IS NULL +), "_u_2" AS ( + SELECT + CITY_NAME AS "_u_3" + FROM "_S1" + GROUP BY + CITY_NAME ), "_S5" AS ( SELECT city_name AS CITY_NAME, @@ -26,10 +40,12 @@ WITH "_S0" AS ( SUM("_S5".SUM_RATING) / SUM("_S5".COUNT_RATING) AS AVG_RATING, "_S2".REGION FROM "_S0" "_S2" - JOIN "_S1" "_S3" - ON "_S2".CITY_NAME = "_S3".CITY_NAME + LEFT JOIN "_u_2" "_u_2" + ON "_S2".CITY_NAME = "_u_2"."_u_3" JOIN "_S5" "_S5" ON "_S2".CITY_NAME = "_S5".CITY_NAME + WHERE + NOT "_u_2"."_u_3" IS NULL GROUP BY "_S2".REGION ) diff --git a/tests/test_sql_refsols/epoch_num_predawn_cold_war_ansi.sql b/tests/test_sql_refsols/epoch_num_predawn_cold_war_ansi.sql index c23e12993..d31a16e18 100644 --- a/tests/test_sql_refsols/epoch_num_predawn_cold_war_ansi.sql +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_ansi.sql @@ -3,6 +3,16 @@ WITH _s0 AS ( ev_dt, ev_key FROM events +), _u_0 AS ( + SELECT + _s2.ev_key AS _u_1 + FROM _s0 AS _s2 + JOIN eras AS eras + ON eras.er_end_year > EXTRACT(YEAR FROM CAST(_s2.ev_dt AS DATETIME)) + AND eras.er_name = 'Cold War' + AND eras.er_start_year <= EXTRACT(YEAR FROM CAST(_s2.ev_dt AS DATETIME)) + GROUP BY + 1 ) SELECT COUNT(DISTINCT _s0.ev_key) AS n_events @@ -11,9 +21,7 @@ JOIN times AS times ON times.t_end_hour > EXTRACT(HOUR FROM CAST(_s0.ev_dt AS DATETIME)) AND times.t_name = 'Pre-Dawn' AND times.t_start_hour <= EXTRACT(HOUR FROM CAST(_s0.ev_dt AS DATETIME)) -JOIN _s0 AS _s2 - ON _s0.ev_key = _s2.ev_key -JOIN eras AS eras - ON eras.er_end_year > EXTRACT(YEAR FROM CAST(_s2.ev_dt AS DATETIME)) - AND eras.er_name = 'Cold War' - AND eras.er_start_year <= EXTRACT(YEAR FROM CAST(_s2.ev_dt AS DATETIME)) +LEFT JOIN _u_0 AS _u_0 + ON _s0.ev_key = _u_0._u_1 +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql index e4b64d002..02afb1d37 100644 --- a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql @@ -3,6 +3,16 @@ WITH "_S0" AS ( ev_dt AS EV_DT, ev_key AS EV_KEY FROM EVENTS +), "_u_0" AS ( + SELECT + "_S2".EV_KEY AS "_u_1" + FROM "_S0" "_S2" + JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATE)) + AND ERAS.er_name = 'Cold War' + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATE)) + GROUP BY + "_S2".EV_KEY ) SELECT COUNT(DISTINCT "_S0".EV_KEY) AS n_events @@ -11,9 +21,7 @@ JOIN TIMES TIMES ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST("_S0".EV_DT AS TIMESTAMP)) AND TIMES.t_name = 'Pre-Dawn' AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S0".EV_DT AS TIMESTAMP)) -JOIN "_S0" "_S2" - ON "_S0".EV_KEY = "_S2".EV_KEY -JOIN ERAS ERAS - ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATE)) - AND ERAS.er_name = 'Cold War' - AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST("_S2".EV_DT AS DATE)) +LEFT JOIN "_u_0" "_u_0" + ON "_S0".EV_KEY = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/has_cross_correlated_singular_ansi.sql b/tests/test_sql_refsols/has_cross_correlated_singular_ansi.sql index edf6ee242..afc70b571 100644 --- a/tests/test_sql_refsols/has_cross_correlated_singular_ansi.sql +++ b/tests/test_sql_refsols/has_cross_correlated_singular_ansi.sql @@ -1,5 +1,14 @@ +WITH _u_0 AS ( + SELECT + n_nationkey AS _u_1 + FROM tpch.nation + GROUP BY + 1 +) SELECT COUNT(*) AS n FROM tpch.customer AS customer -JOIN tpch.nation AS nation - ON customer.c_nationkey = nation.n_nationkey +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = customer.c_nationkey +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql b/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql index 14638501b..9162d185a 100644 --- a/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql +++ b/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql @@ -1,5 +1,14 @@ +WITH "_u_0" AS ( + SELECT + n_nationkey AS "_u_1" + FROM TPCH.NATION + GROUP BY + n_nationkey +) SELECT COUNT(*) AS n FROM TPCH.CUSTOMER CUSTOMER -JOIN TPCH.NATION NATION - ON CUSTOMER.c_nationkey = NATION.n_nationkey +LEFT JOIN "_u_0" "_u_0" + ON CUSTOMER.c_nationkey = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/movielens_2274_ansi.sql b/tests/test_sql_refsols/movielens_2274_ansi.sql index 24541f689..4dcbd4e83 100644 --- a/tests/test_sql_refsols/movielens_2274_ansi.sql +++ b/tests/test_sql_refsols/movielens_2274_ansi.sql @@ -1,3 +1,12 @@ +WITH _u_0 AS ( + SELECT + userid AS _u_1 + FROM main.u2base + WHERE + rating = 2 + GROUP BY + 1 +) SELECT CASE WHEN COUNT(*) > 0 @@ -7,5 +16,7 @@ SELECT ELSE 0.0 END AS percentage_of_female_users FROM main.users AS users -JOIN main.u2base AS u2base - ON u2base.rating = 2 AND u2base.userid = users.userid +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = users.userid +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/movielens_2274_oracle.sql b/tests/test_sql_refsols/movielens_2274_oracle.sql index c64452894..d0adcdd69 100644 --- a/tests/test_sql_refsols/movielens_2274_oracle.sql +++ b/tests/test_sql_refsols/movielens_2274_oracle.sql @@ -1,3 +1,12 @@ +WITH "_u_0" AS ( + SELECT + userid AS "_u_1" + FROM MAIN.U2BASE + WHERE + rating = 2 + GROUP BY + userid +) SELECT CASE WHEN COUNT(*) > 0 @@ -7,5 +16,7 @@ SELECT ELSE 0.0 END AS percentage_of_female_users FROM MAIN.USERS USERS -JOIN MAIN.U2BASE U2BASE - ON U2BASE.rating = 2 AND U2BASE.userid = USERS.userid +LEFT JOIN "_u_0" "_u_0" + ON USERS.userid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/redundant_has_not_on_singular_ansi.sql b/tests/test_sql_refsols/redundant_has_not_on_singular_ansi.sql index 666260dff..431b9ed82 100644 --- a/tests/test_sql_refsols/redundant_has_not_on_singular_ansi.sql +++ b/tests/test_sql_refsols/redundant_has_not_on_singular_ansi.sql @@ -1,7 +1,16 @@ +WITH _u_0 AS ( + SELECT + nation.n_nationkey AS _u_1 + FROM tpch.nation AS nation + JOIN tpch.region AS region + ON nation.n_regionkey = region.r_regionkey AND region.r_name = 'AFRICA' + GROUP BY + 1 +) SELECT COUNT(*) AS n FROM tpch.supplier AS supplier -JOIN tpch.nation AS nation - ON nation.n_nationkey = supplier.s_nationkey -JOIN tpch.region AS region - ON nation.n_regionkey = region.r_regionkey AND region.r_name = 'AFRICA' +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = supplier.s_nationkey +WHERE + _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql b/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql index 528d1a050..28f2159b4 100644 --- a/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql +++ b/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql @@ -1,7 +1,16 @@ +WITH "_u_0" AS ( + SELECT + NATION.n_nationkey AS "_u_1" + FROM TPCH.NATION NATION + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' + GROUP BY + NATION.n_nationkey +) SELECT COUNT(*) AS n FROM TPCH.SUPPLIER SUPPLIER -JOIN TPCH.NATION NATION - ON NATION.n_nationkey = SUPPLIER.s_nationkey -JOIN TPCH.REGION REGION - ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' +LEFT JOIN "_u_0" "_u_0" + ON SUPPLIER.s_nationkey = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/redundant_has_on_plural_ansi.sql b/tests/test_sql_refsols/redundant_has_on_plural_ansi.sql index 4b4b766b8..921bad30a 100644 --- a/tests/test_sql_refsols/redundant_has_on_plural_ansi.sql +++ b/tests/test_sql_refsols/redundant_has_on_plural_ansi.sql @@ -1,5 +1,16 @@ +WITH _u_0 AS ( + SELECT + o_custkey AS _u_1 + FROM tpch.orders + WHERE + o_totalprice > 400000 + GROUP BY + 1 +) SELECT COUNT(*) AS n FROM tpch.customer AS customer -JOIN tpch.orders AS orders - ON customer.c_custkey = orders.o_custkey AND orders.o_totalprice > 400000 +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = customer.c_custkey +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/redundant_has_on_plural_lineitems_ansi.sql b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_ansi.sql index bbc3107da..80a8e58a1 100644 --- a/tests/test_sql_refsols/redundant_has_on_plural_lineitems_ansi.sql +++ b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_ansi.sql @@ -1,5 +1,16 @@ +WITH _u_0 AS ( + SELECT + l_orderkey AS _u_1 + FROM tpch.lineitem + WHERE + l_quantity > 49 + GROUP BY + 1 +) SELECT COUNT(*) AS n FROM tpch.orders AS orders -JOIN tpch.lineitem AS lineitem - ON lineitem.l_orderkey = orders.o_orderkey AND lineitem.l_quantity > 49 +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = orders.o_orderkey +WHERE + NOT _u_0._u_1 IS NULL diff --git a/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql index 316b95c4d..2727bab70 100644 --- a/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql +++ b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql @@ -1,5 +1,16 @@ +WITH "_u_0" AS ( + SELECT + l_orderkey AS "_u_1" + FROM TPCH.LINEITEM + WHERE + l_quantity > 49 + GROUP BY + l_orderkey +) SELECT COUNT(*) AS n FROM TPCH.ORDERS ORDERS -JOIN TPCH.LINEITEM LINEITEM - ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_quantity > 49 +LEFT JOIN "_u_0" "_u_0" + ON ORDERS.o_orderkey = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql b/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql index 73e454239..14ff43049 100644 --- a/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql +++ b/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql @@ -1,5 +1,16 @@ +WITH "_u_0" AS ( + SELECT + o_custkey AS "_u_1" + FROM TPCH.ORDERS + WHERE + o_totalprice > 400000 + GROUP BY + o_custkey +) SELECT COUNT(*) AS n FROM TPCH.CUSTOMER CUSTOMER -JOIN TPCH.ORDERS ORDERS - ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_totalprice > 400000 +LEFT JOIN "_u_0" "_u_0" + ON CUSTOMER.c_custkey = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/tpch_q21_ansi.sql b/tests/test_sql_refsols/tpch_q21_ansi.sql index c95b9b937..f48509a01 100644 --- a/tests/test_sql_refsols/tpch_q21_ansi.sql +++ b/tests/test_sql_refsols/tpch_q21_ansi.sql @@ -24,20 +24,28 @@ WITH _t5 AS ( 1, 2, 3 -), _s11 AS ( +), _u_0 AS ( SELECT - _t3.anything_l_suppkey - FROM _t3 AS _t3 - JOIN _t5 AS _t6 - ON _t3.l_linenumber = _t6.l_linenumber - AND _t3.l_orderkey = _t6.l_orderkey - AND _t3.o_orderkey = _t6.l_orderkey + _t6.l_linenumber AS _u_1, + _t6.l_orderkey AS _u_2 + FROM _t5 AS _t6 JOIN tpch.lineitem AS lineitem ON _t6.l_orderkey = lineitem.l_orderkey AND _t6.l_suppkey <> lineitem.l_suppkey AND lineitem.l_commitdate < lineitem.l_receiptdate + GROUP BY + 1, + 2 +), _s11 AS ( + SELECT + _t3.anything_l_suppkey + FROM _t3 AS _t3 + LEFT JOIN _u_0 AS _u_0 + ON _t3.l_linenumber = _u_0._u_1 + AND _t3.l_orderkey = _u_0._u_2 + AND _t3.o_orderkey = _u_0._u_2 WHERE - _t3.anything_o_orderstatus = 'F' + _t3.anything_o_orderstatus = 'F' AND _u_0._u_1 IS NULL ) SELECT ANY_VALUE(supplier.s_name) AS S_NAME, diff --git a/tests/test_sql_refsols/tpch_q21_oracle.sql b/tests/test_sql_refsols/tpch_q21_oracle.sql index 38a59a6f6..e494d1ca8 100644 --- a/tests/test_sql_refsols/tpch_q21_oracle.sql +++ b/tests/test_sql_refsols/tpch_q21_oracle.sql @@ -24,20 +24,28 @@ WITH "_T5" AS ( "_T5".L_LINENUMBER, "_T5".L_ORDERKEY, ORDERS.o_orderkey -), "_S11" AS ( +), "_u_0" AS ( SELECT - "_T3".ANYTHING_L_SUPPKEY - FROM "_T3" "_T3" - JOIN "_T5" "_T6" - ON "_T3".L_LINENUMBER = "_T6".L_LINENUMBER - AND "_T3".L_ORDERKEY = "_T6".L_ORDERKEY - AND "_T3".O_ORDERKEY = "_T6".L_ORDERKEY + "_T6".L_LINENUMBER AS "_u_1", + "_T6".L_ORDERKEY AS "_u_2" + FROM "_T5" "_T6" JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate AND LINEITEM.l_orderkey = "_T6".L_ORDERKEY AND LINEITEM.l_suppkey <> "_T6".L_SUPPKEY + GROUP BY + "_T6".L_LINENUMBER, + "_T6".L_ORDERKEY +), "_S11" AS ( + SELECT + "_T3".ANYTHING_L_SUPPKEY + FROM "_T3" "_T3" + LEFT JOIN "_u_0" "_u_0" + ON "_T3".L_LINENUMBER = "_u_0"."_u_1" + AND "_T3".L_ORDERKEY = "_u_0"."_u_2" + AND "_T3".O_ORDERKEY = "_u_0"."_u_2" WHERE - "_T3".ANYTHING_O_ORDERSTATUS = 'F' + "_T3".ANYTHING_O_ORDERSTATUS = 'F' AND "_u_0"."_u_1" IS NULL ) SELECT ANY_VALUE(SUPPLIER.s_name) AS S_NAME, diff --git a/tests/test_sql_refsols/tpch_q22_ansi.sql b/tests/test_sql_refsols/tpch_q22_ansi.sql index 04ca82b32..ac8ce5c6b 100644 --- a/tests/test_sql_refsols/tpch_q22_ansi.sql +++ b/tests/test_sql_refsols/tpch_q22_ansi.sql @@ -5,6 +5,12 @@ WITH _s0 AS ( WHERE SUBSTRING(c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') AND c_acctbal > 0.0 +), _u_0 AS ( + SELECT + o_custkey AS _u_1 + FROM tpch.orders + GROUP BY + 1 ) SELECT SUBSTRING(customer.c_phone, 1, 2) AS CNTRY_CODE, @@ -14,8 +20,10 @@ FROM _s0 AS _s0 JOIN tpch.customer AS customer ON SUBSTRING(customer.c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') AND _s0.avg_c_acctbal < customer.c_acctbal -JOIN tpch.orders AS orders - ON customer.c_custkey = orders.o_custkey +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = customer.c_custkey +WHERE + _u_0._u_1 IS NULL GROUP BY 1 ORDER BY diff --git a/tests/test_sql_refsols/tpch_q22_oracle.sql b/tests/test_sql_refsols/tpch_q22_oracle.sql index f3418cf8a..9a2d9c134 100644 --- a/tests/test_sql_refsols/tpch_q22_oracle.sql +++ b/tests/test_sql_refsols/tpch_q22_oracle.sql @@ -5,6 +5,12 @@ WITH "_S0" AS ( WHERE c_acctbal > 0.0 AND SUBSTR(c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') +), "_u_0" AS ( + SELECT + o_custkey AS "_u_1" + FROM TPCH.ORDERS + GROUP BY + o_custkey ) SELECT SUBSTR(CUSTOMER.c_phone, 1, 2) AS CNTRY_CODE, @@ -14,8 +20,10 @@ FROM "_S0" "_S0" JOIN TPCH.CUSTOMER CUSTOMER ON CUSTOMER.c_acctbal > "_S0".AVG_C_ACCTBAL AND SUBSTR(CUSTOMER.c_phone, 1, 2) IN ('13', '31', '23', '29', '30', '18', '17') -JOIN TPCH.ORDERS ORDERS - ON CUSTOMER.c_custkey = ORDERS.o_custkey +LEFT JOIN "_u_0" "_u_0" + ON CUSTOMER.c_custkey = "_u_0"."_u_1" +WHERE + "_u_0"."_u_1" IS NULL GROUP BY SUBSTR(CUSTOMER.c_phone, 1, 2) ORDER BY diff --git a/tests/test_sql_refsols/tpch_q4_ansi.sql b/tests/test_sql_refsols/tpch_q4_ansi.sql index 9e3fffc2c..88782315c 100644 --- a/tests/test_sql_refsols/tpch_q4_ansi.sql +++ b/tests/test_sql_refsols/tpch_q4_ansi.sql @@ -1,13 +1,22 @@ +WITH _u_0 AS ( + SELECT + l_orderkey AS _u_1 + FROM tpch.lineitem + WHERE + l_commitdate < l_receiptdate + GROUP BY + 1 +) SELECT orders.o_orderpriority AS O_ORDERPRIORITY, COUNT(*) AS ORDER_COUNT FROM tpch.orders AS orders -JOIN tpch.lineitem AS lineitem - ON lineitem.l_commitdate < lineitem.l_receiptdate - AND lineitem.l_orderkey = orders.o_orderkey +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = orders.o_orderkey WHERE EXTRACT(MONTH FROM CAST(orders.o_orderdate AS DATETIME)) IN (7, 8, 9) AND EXTRACT(YEAR FROM CAST(orders.o_orderdate AS DATETIME)) = 1993 + AND NOT _u_0._u_1 IS NULL GROUP BY 1 ORDER BY diff --git a/tests/test_sql_refsols/tpch_q4_oracle.sql b/tests/test_sql_refsols/tpch_q4_oracle.sql index f89ec8ddf..3fc76856a 100644 --- a/tests/test_sql_refsols/tpch_q4_oracle.sql +++ b/tests/test_sql_refsols/tpch_q4_oracle.sql @@ -1,13 +1,22 @@ +WITH "_u_0" AS ( + SELECT + l_orderkey AS "_u_1" + FROM TPCH.LINEITEM + WHERE + l_commitdate < l_receiptdate + GROUP BY + l_orderkey +) SELECT ORDERS.o_orderpriority AS O_ORDERPRIORITY, COUNT(*) AS ORDER_COUNT FROM TPCH.ORDERS ORDERS -JOIN TPCH.LINEITEM LINEITEM - ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate - AND LINEITEM.l_orderkey = ORDERS.o_orderkey +LEFT JOIN "_u_0" "_u_0" + ON ORDERS.o_orderkey = "_u_0"."_u_1" WHERE EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATE)) IN (7, 8, 9) AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) = 1993 + AND NOT "_u_0"."_u_1" IS NULL GROUP BY ORDERS.o_orderpriority ORDER BY diff --git a/tests/test_sql_refsols/wdi_low_income_country_with_series_ansi.sql b/tests/test_sql_refsols/wdi_low_income_country_with_series_ansi.sql index 6d13fe38e..dbad26bb8 100644 --- a/tests/test_sql_refsols/wdi_low_income_country_with_series_ansi.sql +++ b/tests/test_sql_refsols/wdi_low_income_country_with_series_ansi.sql @@ -1,8 +1,16 @@ +WITH _u_0 AS ( + SELECT + countrycode AS _u_1 + FROM main.countrynotes + WHERE + seriescode = 'DT.DOD.DECT.CD' + GROUP BY + 1 +) SELECT country.countrycode AS country_code FROM main.country AS country -JOIN main.countrynotes AS countrynotes - ON country.countrycode = countrynotes.countrycode - AND countrynotes.seriescode = 'DT.DOD.DECT.CD' +LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = country.countrycode WHERE - country.incomegroup = 'Low income' + NOT _u_0._u_1 IS NULL AND country.incomegroup = 'Low income' diff --git a/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql index b14a8b8b9..b35630540 100644 --- a/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql +++ b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql @@ -1,8 +1,16 @@ +WITH "_u_0" AS ( + SELECT + countrycode AS "_u_1" + FROM MAIN.COUNTRYNOTES + WHERE + seriescode = 'DT.DOD.DECT.CD' + GROUP BY + countrycode +) SELECT COUNTRY.countrycode AS country_code FROM MAIN.COUNTRY COUNTRY -JOIN MAIN.COUNTRYNOTES COUNTRYNOTES - ON COUNTRY.countrycode = COUNTRYNOTES.countrycode - AND COUNTRYNOTES.seriescode = 'DT.DOD.DECT.CD' +LEFT JOIN "_u_0" "_u_0" + ON COUNTRY.countrycode = "_u_0"."_u_1" WHERE - COUNTRY.incomegroup = 'Low income' + COUNTRY.incomegroup = 'Low income' AND NOT "_u_0"."_u_1" IS NULL diff --git a/tests/test_sql_refsols/window_filter_order_10_ansi.sql b/tests/test_sql_refsols/window_filter_order_10_ansi.sql index 3736e8e2a..d6b97cba2 100644 --- a/tests/test_sql_refsols/window_filter_order_10_ansi.sql +++ b/tests/test_sql_refsols/window_filter_order_10_ansi.sql @@ -1,11 +1,19 @@ -WITH _t1 AS ( +WITH _u_0 AS ( + SELECT + c_custkey AS _u_1 + FROM tpch.customer + WHERE + c_mktsegment = 'BUILDING' + GROUP BY + 1 +), _t1 AS ( SELECT 1 AS "_" FROM tpch.orders AS orders - JOIN tpch.customer AS customer - ON customer.c_custkey = orders.o_custkey AND customer.c_mktsegment = 'BUILDING' + LEFT JOIN _u_0 AS _u_0 + ON _u_0._u_1 = orders.o_custkey WHERE - orders.o_clerk = 'Clerk#000000001' + _u_0._u_1 IS NULL AND orders.o_clerk = 'Clerk#000000001' QUALIFY orders.o_totalprice < ( 0.05 * AVG(CAST(NULL AS INT)) OVER () diff --git a/tests/test_sql_refsols/window_filter_order_10_oracle.sql b/tests/test_sql_refsols/window_filter_order_10_oracle.sql index 647afeae1..cdab2ebcf 100644 --- a/tests/test_sql_refsols/window_filter_order_10_oracle.sql +++ b/tests/test_sql_refsols/window_filter_order_10_oracle.sql @@ -1,12 +1,20 @@ -WITH "_T" AS ( +WITH "_u_0" AS ( + SELECT + c_custkey AS "_u_1" + FROM TPCH.CUSTOMER + WHERE + c_mktsegment = 'BUILDING' + GROUP BY + c_custkey +), "_T" AS ( SELECT ORDERS.o_totalprice AS O_TOTALPRICE, AVG(CAST(NULL AS INT)) OVER () AS "_W" FROM TPCH.ORDERS ORDERS - JOIN TPCH.CUSTOMER CUSTOMER - ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' + LEFT JOIN "_u_0" "_u_0" + ON ORDERS.o_custkey = "_u_0"."_u_1" WHERE - ORDERS.o_clerk = 'Clerk#000000001' + ORDERS.o_clerk = 'Clerk#000000001' AND "_u_0"."_u_1" IS NULL ) SELECT COUNT(*) AS n From b8ef6dd03bafdd7c8a0f8ab8ea890dad054d2d0d Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 25 Feb 2026 09:26:17 -0600 Subject: [PATCH 17/48] fixing cast datetime, and trunc --- pydough/sqlglot/execute_relational.py | 6 ++ pydough/sqlglot/override_unnest_subqueries.py | 35 ++++++- .../oracle_transform_bindings.py | 94 +++++++++++++++---- tests/test_metadata/oracle_defog_graphs.json | 2 +- .../defog_test_functions.py | 4 +- ...rnative_quarter_cum_ir_analysis_oracle.sql | 20 ++-- .../country_x_year_analysis_oracle.sql | 10 +- .../country_x_year_combos_oracle.sql | 4 +- .../cumulative_stock_analysis_oracle.sql | 4 +- ...dataframe_collection_where_date_oracle.sql | 4 +- tests/test_sql_refsols/datediff_oracle.sql | 4 +- .../datetime_current_oracle.sql | 4 +- .../datetime_functions_oracle.sql | 6 +- .../datetime_relative_oracle.sql | 6 +- .../datetime_sampler_oracle.sql | 70 +++++++------- .../defog_academic_gen18_ansi.sql | 3 +- .../defog_academic_gen18_mysql.sql | 5 +- .../defog_academic_gen18_oracle.sql | 3 +- .../defog_academic_gen18_postgres.sql | 3 +- .../defog_academic_gen18_snowflake.sql | 3 +- .../defog_academic_gen18_sqlite.sql | 3 +- .../defog_broker_adv16_oracle.sql | 2 +- .../defog_broker_adv2_oracle.sql | 2 +- .../defog_broker_adv7_oracle.sql | 4 +- .../defog_broker_adv8_oracle.sql | 4 +- .../defog_broker_adv9_oracle.sql | 8 +- .../defog_broker_basic1_oracle.sql | 2 +- .../defog_broker_gen2_oracle.sql | 2 +- .../defog_broker_gen4_oracle.sql | 2 +- .../defog_broker_gen5_oracle.sql | 4 +- .../defog_dealership_adv13_oracle.sql | 4 +- .../defog_dealership_adv1_oracle.sql | 4 +- .../defog_dealership_adv4_oracle.sql | 2 +- .../defog_dealership_basic10_oracle.sql | 2 +- .../defog_dealership_gen3_oracle.sql | 16 +++- .../defog_dealership_gen4_oracle.sql | 4 +- .../defog_dermtreatment_adv10_oracle.sql | 2 +- .../defog_dermtreatment_adv7_oracle.sql | 2 +- .../defog_dermtreatment_adv8_oracle.sql | 28 +++--- .../defog_dermtreatment_adv9_oracle.sql | 4 +- .../defog_dermtreatment_basic1_oracle.sql | 2 +- .../defog_dermtreatment_gen2_oracle.sql | 21 ++--- .../defog_dermtreatment_gen5_oracle.sql | 2 +- .../defog_ewallet_adv13_oracle.sql | 4 +- .../defog_ewallet_adv14_oracle.sql | 10 +- .../defog_ewallet_adv2_ansi.sql | 4 +- .../defog_ewallet_adv2_mysql.sql | 4 +- .../defog_ewallet_adv2_oracle.sql | 21 ++--- .../defog_ewallet_adv2_postgres.sql | 23 ++--- .../defog_ewallet_adv2_sqlite.sql | 13 +-- .../defog_ewallet_adv9_oracle.sql | 6 +- .../defog_ewallet_basic10_oracle.sql | 2 +- .../defog_ewallet_basic1_oracle.sql | 4 +- .../defog_ewallet_gen1_oracle.sql | 2 +- .../defog_ewallet_gen4_oracle.sql | 2 +- .../defog_ewallet_gen5_oracle.sql | 2 +- .../order_quarter_test_oracle.sql | 22 ++--- .../part_cross_part_b_oracle.sql | 6 +- .../part_cross_part_c_oracle.sql | 6 +- .../quarter_cum_ir_analysis_oracle.sql | 20 ++-- .../quarter_function_test_oracle.sql | 48 +++++----- .../simplification_4_oracle.sql | 2 +- tests/test_sql_refsols/smoke_b_oracle.sql | 26 ++--- ...saction_week_sampler_friday_one_oracle.sql | 2 +- ...action_week_sampler_friday_zero_oracle.sql | 2 +- ...saction_week_sampler_monday_one_oracle.sql | 2 +- ...action_week_sampler_monday_zero_oracle.sql | 2 +- ...ction_week_sampler_saturday_one_oracle.sql | 2 +- ...tion_week_sampler_saturday_zero_oracle.sql | 2 +- ...saction_week_sampler_sunday_one_oracle.sql | 2 +- ...action_week_sampler_sunday_zero_oracle.sql | 2 +- ...ction_week_sampler_thursday_one_oracle.sql | 2 +- ...tion_week_sampler_thursday_zero_oracle.sql | 2 +- ...action_week_sampler_tuesday_one_oracle.sql | 2 +- ...ction_week_sampler_tuesday_zero_oracle.sql | 2 +- ...tion_week_sampler_wednesday_one_oracle.sql | 2 +- ...ion_week_sampler_wednesday_zero_oracle.sql | 2 +- ...technograph_hot_purchase_window_oracle.sql | 4 +- ...chnograph_monthly_incident_rate_oracle.sql | 6 +- ...ve_incident_rate_goldcopperstar_oracle.sql | 4 +- ...umulative_incident_rate_overall_oracle.sql | 4 +- .../time_threshold_reached_oracle.sql | 6 +- tests/test_sql_refsols/week_offset_oracle.sql | 16 ++-- 83 files changed, 404 insertions(+), 307 deletions(-) diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index ca6cd1788..2ccb961f3 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -16,6 +16,7 @@ from sqlglot.dialects import Snowflake as SnowflakeDialect from sqlglot.dialects import SQLite as SQLiteDialect from sqlglot.dialects.mysql import MySQL +from sqlglot.dialects.oracle import Oracle from sqlglot.errors import SqlglotError from sqlglot.expressions import ( Alias, @@ -549,6 +550,11 @@ def change_sqlglot_dialect_configuration(dialect: DatabaseDialect) -> None: MySQL.Generator.VALUES_AS_TABLE = True # Keep the parenthesis around the values MySQL.Generator.WRAP_DERIVED_VALUES = True + case DatabaseDialect.ORACLE: + # This tells the Oracle generator to map DATETIME requests to DATE + Oracle.Generator.TYPE_MAPPING[ + sqlglot_expressions.DataType.Type.DATETIME + ] = "DATE" case _: pass diff --git a/pydough/sqlglot/override_unnest_subqueries.py b/pydough/sqlglot/override_unnest_subqueries.py index 5af75e7ba..e655ebfbc 100644 --- a/pydough/sqlglot/override_unnest_subqueries.py +++ b/pydough/sqlglot/override_unnest_subqueries.py @@ -4,7 +4,7 @@ from sqlglot import exp from sqlglot.helper import name_sequence -from sqlglot.optimizer.scope import ScopeType, traverse_scope +from sqlglot.optimizer.scope import Scope, ScopeType, traverse_scope from sqlglot.optimizer.unnest_subqueries import unnest, _replace, _other_operand # ruff: noqa @@ -35,10 +35,13 @@ def unnest_subqueries(expression): for scope in traverse_scope(expression): select = scope.expression parent = select.parent_select + # PYDOUGH CHANGE: use the overridden version of external_columns that + # correctly handles set operations + external_columns = get_scope_external_columns(scope) if not parent: continue if scope.external_columns: - decorrelate(select, parent, scope.external_columns, next_alias_name) + decorrelate(select, parent, external_columns, next_alias_name) elif scope.scope_type == ScopeType.SUBQUERY: unnest(select, parent, next_alias_name) @@ -220,3 +223,31 @@ def remove_aggs(node): join_alias=table_alias, copy=False, ) + + +def get_scope_external_columns(scope: Scope) -> list[exp.Column]: + """ + Overridden version of the external_columns property for Scope objects. + Columns that appear to reference sources in outer scopes. + + Returns: + list[exp.Column]: Column instances that don't reference + sources in the current scope. + """ + if scope._external_columns is None: + if isinstance(scope.expression, exp.SetOperation): + left, right = scope.union_scopes + scope._external_columns = left.external_columns + right.external_columns + else: + scope._external_columns = [ + c + for c in scope.columns + # PYDOUGH CHANGE: ignore SYSTIMESTAMP since it is a special case + # of a column that should not be considered external + if isinstance(c.this, exp.Identifier) + and c.this.this != "SYSTIMESTAMP" + and c.table not in scope.selected_sources + and c.table not in scope.semi_or_anti_join_tables + ] + + return scope._external_columns diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index 90c1ee207..aa05041dd 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -535,34 +535,90 @@ def convert_current_timestamp(self) -> SQLGlotExpression: ], ) + def coerce_to_timestamp(self, base: SQLGlotExpression) -> SQLGlotExpression: + return sqlglot_expressions.Cast( + this=base, to=sqlglot_expressions.DataType.build("DATE") + ) + + def apply_datetime_truncation( + self, base: SQLGlotExpression, unit: DateTimeUnit + ) -> SQLGlotExpression: + match unit: + case DateTimeUnit.HOUR | DateTimeUnit.MINUTE | DateTimeUnit.SECOND: + return sqlglot_expressions.TimestampTrunc( + this=self.make_datetime_arg(base), + unit=sqlglot_expressions.Var(this=unit.value.lower()), + ) + case DateTimeUnit.WEEK: + result = sqlglot_expressions.DateTrunc( + this=self.make_datetime_arg(base), + unit=sqlglot_expressions.Var(this="IW"), + ) + return result + case _: + return sqlglot_expressions.DateTrunc( + this=self.make_datetime_arg(base), + unit=sqlglot_expressions.Var(this=unit.value.lower()), + ) + def apply_datetime_offset( self, base: SQLGlotExpression, amt: int, unit: DateTimeUnit ) -> SQLGlotExpression: new_expr: SQLGlotExpression | None = None + original_amt: int = amt if amt < 0: amt *= -1 - interval: SQLGlotExpression = ( - sqlglot_expressions.Anonymous( - this="NUMTODSINTERVAL", - expressions=[ - sqlglot_expressions.convert(amt), - sqlglot_expressions.Literal.string(unit.value), - ], - ) - if unit not in [DateTimeUnit.YEAR, DateTimeUnit.MONTH] - else sqlglot_expressions.Anonymous( - this="NUMTOYMINTERVAL", - expressions=[ - sqlglot_expressions.convert(amt), - sqlglot_expressions.Literal.string(unit.value), - ], - ) - ) - if amt > 0: + interval: SQLGlotExpression + match unit: + case ( + DateTimeUnit.HOUR + | DateTimeUnit.MINUTE + | DateTimeUnit.SECOND + | DateTimeUnit.DAY + ): + interval = sqlglot_expressions.Anonymous( + this="NUMTODSINTERVAL", + expressions=[ + sqlglot_expressions.convert(amt), + sqlglot_expressions.Literal.string(unit.value), + ], + ) + case DateTimeUnit.WEEK: + # Oracle doesn't support week intervals, so we convert weeks to + # days by multiplying the amount by 7 and using a day interval + interval = sqlglot_expressions.Anonymous( + this="NUMTODSINTERVAL", + expressions=[ + sqlglot_expressions.convert(amt * 7), + sqlglot_expressions.Literal.string("DAY"), + ], + ) + case DateTimeUnit.QUARTER: + # Oracle doesn't support QUARTER in NUMTOYMINTERVAL. + # Convert quarters to months (1 quarter = 3 months). + interval = sqlglot_expressions.Anonymous( + this="NUMTOYMINTERVAL", + expressions=[ + sqlglot_expressions.convert(amt * 3), + sqlglot_expressions.Literal.string("MONTH"), + ], + ) + case DateTimeUnit.MONTH | DateTimeUnit.YEAR: + interval = sqlglot_expressions.Anonymous( + this="NUMTOYMINTERVAL", + expressions=[ + sqlglot_expressions.convert(amt), + sqlglot_expressions.Literal.string(unit.value), + ], + ) + case _: + raise ValueError(f"Unsupported unit '{unit}' for datetime offset.") + + if original_amt > 0: new_expr = sqlglot_expressions.Add(this=base, expression=interval) - elif amt < 0: + elif original_amt < 0: new_expr = sqlglot_expressions.Sub(this=base, expression=interval) else: new_expr = base diff --git a/tests/test_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json index b77252d11..1ef0d10d9 100644 --- a/tests/test_metadata/oracle_defog_graphs.json +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -2955,7 +2955,7 @@ { "name": "user_id", "type": "table column", - "column name": "user_id", + "column name": "\"USER_ID\"", "data type": "numeric", "description": "The id of the user who the session belongs to", "sample values": [1, 2, 3, 8, 10], diff --git a/tests/test_pydough_functions/defog_test_functions.py b/tests/test_pydough_functions/defog_test_functions.py index 99078cb4a..676b25821 100644 --- a/tests/test_pydough_functions/defog_test_functions.py +++ b/tests/test_pydough_functions/defog_test_functions.py @@ -1312,7 +1312,7 @@ def impl_defog_ewallet_adv2(): ) .CALCULATE( week=DATETIME(created_at, "start of week"), - is_weekend=ISIN(DAYOFWEEK(created_at), (5, 6)), + is_weekend=IFF(ISIN(DAYOFWEEK(created_at), (5, 6)), 1, 0), ) .PARTITION(name="weeks", by=week) .CALCULATE( @@ -2693,7 +2693,7 @@ def impl_defog_academic_gen18(): """ return journals.CALCULATE( name, journal_id, num_publications=COUNT(archives) - ).ORDER_BY(num_publications.DESC()) + ).ORDER_BY(num_publications.DESC(), name.ASC()) def impl_defog_academic_gen19(): diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql index ead79b626..89314244d 100644 --- a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -11,10 +11,10 @@ WITH "_S0" AS ( pr_name = 'RubyCopper-Star' ), "_S12" AS ( SELECT DISTINCT - TRUNC(CAST("_S0".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + TRUNC(CAST("_S0".CA_DT AS DATE), 'QUARTER') AS QUARTER FROM "_S0" "_S0" JOIN "_T2" "_T2" - ON "_S0".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S0".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S0".CA_DT >= "_T2".PR_RELEASE ), "_T5" AS ( SELECT @@ -32,34 +32,34 @@ WITH "_S0" AS ( ON COUNTRIES.co_name = 'CN' ), "_S13" AS ( SELECT - TRUNC(CAST("_S2".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + TRUNC(CAST("_S2".CA_DT AS DATE), 'QUARTER') AS QUARTER, COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID FROM "_S0" "_S2" JOIN "_T2" "_T4" - ON "_S2".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S2".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S2".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.INCIDENTS INCIDENTS - ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') JOIN "_S9" "_S9" ON INCIDENTS.in_repair_country_id = "_S9".CO_ID JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = "_S9".PR_ID GROUP BY - TRUNC(CAST("_S2".CA_DT AS TIMESTAMP), 'QUARTER') + TRUNC(CAST("_S2".CA_DT AS DATE), 'QUARTER') ), "_S21" AS ( SELECT - TRUNC(CAST("_S14".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + TRUNC(CAST("_S14".CA_DT AS DATE), 'QUARTER') AS QUARTER, COUNT(*) AS N_ROWS FROM "_S0" "_S14" JOIN "_T2" "_T8" - ON "_S14".CA_DT < TRUNC(CAST("_T8".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S14".CA_DT < TRUNC(CAST("_T8".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S14".CA_DT >= "_T8".PR_RELEASE JOIN MAIN.DEVICES DEVICES - ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') JOIN "_T5" "_T9" ON DEVICES.de_product_id = "_T9".PR_ID GROUP BY - TRUNC(CAST("_S14".CA_DT AS TIMESTAMP), 'QUARTER') + TRUNC(CAST("_S14".CA_DT AS DATE), 'QUARTER') ) SELECT "_S12".QUARTER AS quarter, diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql index 3cc39521d..e367f9353 100644 --- a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -24,11 +24,11 @@ WITH "_T1" AS ( CROSS JOIN "_T4" "_T7" JOIN "_S3" "_S7" ON "_S7".CA_DT < ( - CAST("_T7".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year') + CAST("_T7".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year') ) AND "_S7".CA_DT >= "_T7".PR_RELEASE JOIN MAIN.DEVICES DEVICES - ON "_S7".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON "_S7".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') JOIN MAIN.PRODUCTS PRODUCTS ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.COUNTRIES COUNTRIES @@ -39,20 +39,20 @@ WITH "_T1" AS ( "_T6".CO_NAME ), "_S17" AS ( SELECT - TRUNC(CAST("_S3".CA_DT AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + TRUNC(CAST("_S3".CA_DT AS DATE), 'YEAR') AS START_OF_YEAR, "_T3".CO_NAME, SUM("_S15".N_ROWS) AS SUM_N_ROWS FROM "_T1" "_T3" CROSS JOIN "_T4" "_T4" JOIN "_S3" "_S3" ON "_S3".CA_DT < ( - CAST("_T4".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year') + CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year') ) AND "_S3".CA_DT >= "_T4".PR_RELEASE LEFT JOIN "_S15" "_S15" ON "_S15".CA_DT = "_S3".CA_DT AND "_S15".CO_NAME = "_T3".CO_NAME GROUP BY - TRUNC(CAST("_S3".CA_DT AS TIMESTAMP), 'YEAR'), + TRUNC(CAST("_S3".CA_DT AS DATE), 'YEAR'), "_T3".CO_NAME ) SELECT diff --git a/tests/test_sql_refsols/country_x_year_combos_oracle.sql b/tests/test_sql_refsols/country_x_year_combos_oracle.sql index db95c2367..135d25b33 100644 --- a/tests/test_sql_refsols/country_x_year_combos_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_combos_oracle.sql @@ -6,14 +6,14 @@ WITH "_T1" AS ( NOT co_name LIKE '%C%' ), "_S5" AS ( SELECT DISTINCT - TRUNC(CAST(CALENDAR.ca_dt AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + TRUNC(CAST(CALENDAR.ca_dt AS DATE), 'YEAR') AS START_OF_YEAR, "_T3".CO_NAME FROM "_T1" "_T3" JOIN MAIN.PRODUCTS PRODUCTS ON PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.CALENDAR CALENDAR ON CALENDAR.ca_dt < ( - CAST(PRODUCTS.pr_release AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year') + CAST(PRODUCTS.pr_release AS DATE) + NUMTOYMINTERVAL(2, 'year') ) AND CALENDAR.ca_dt >= PRODUCTS.pr_release ) diff --git a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql index a35ad2aad..b9d4c4dcb 100644 --- a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql +++ b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql @@ -1,9 +1,9 @@ SELECT SBTRANSACTION.sbtxdatetime AS date_time, - COUNT(*) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS txn_within_day, + COUNT(*) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS txn_within_day, COUNT( CASE WHEN SBTRANSACTION.sbtxtype = 'buy' THEN SBTRANSACTION.sbtxtype ELSE NULL END - ) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_buys_within_day, + ) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_buys_within_day, ROUND( ( 100.0 * SUM(SBTICKER.sbtickersymbol IN ('AAPL', 'AMZN')) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) diff --git a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql index c44ebaa2c..5b6a137cd 100644 --- a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql @@ -19,7 +19,7 @@ FROM (VALUES )) AS DATES(CLERK_ID, START_DATE, END_DATE) JOIN TPCH.ORDERS ORDERS ON COLUMN1 = ORDERS.o_clerk - AND COLUMN2 <= CAST(ORDERS.o_orderdate AS TIMESTAMP) - AND COLUMN3 >= CAST(ORDERS.o_orderdate AS TIMESTAMP) + AND COLUMN2 <= CAST(ORDERS.o_orderdate AS DATE) + AND COLUMN3 >= CAST(ORDERS.o_orderdate AS DATE) GROUP BY COLUMN1 diff --git a/tests/test_sql_refsols/datediff_oracle.sql b/tests/test_sql_refsols/datediff_oracle.sql index 08b947083..8fa6c61dd 100644 --- a/tests/test_sql_refsols/datediff_oracle.sql +++ b/tests/test_sql_refsols/datediff_oracle.sql @@ -10,10 +10,10 @@ SELECT ) AS months_diff, TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') - CAST(sbtxdatetime AS DATE) AS days_diff, ( - TRUNC(CAST(TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'HH24') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATETIME), 'HH24') + TRUNC(CAST(TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'HH24') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'HH24') ) * 24 AS hours_diff, ( - TRUNC(CAST(TO_DATE('2023-04-03 13:16:30', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATETIME), 'MI') + TRUNC(CAST(TO_DATE('2023-04-03 13:16:30', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'MI') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'MI') ) * 1440 AS minutes_diff, ( TO_DATE('2023-04-03 13:16:30', 'YYYY-MM-DD HH24:MI:SS') - CAST(sbtxdatetime AS DATE) diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql index 32c98894b..9f5959909 100644 --- a/tests/test_sql_refsols/datetime_current_oracle.sql +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -1,6 +1,6 @@ SELECT - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(5, 'month') + NUMTODSINTERVAL(1, 'day') AS d1, + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(5, 'month') - NUMTODSINTERVAL(1, 'day') AS d1, TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(24, 'hour') AS d2, - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') + NUMTODSINTERVAL(12, 'hour') + NUMTODSINTERVAL(150, 'minute') + NUMTODSINTERVAL(2, 'second') AS d3 + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') + NUMTODSINTERVAL(12, 'hour') - NUMTODSINTERVAL(150, 'minute') + NUMTODSINTERVAL(2, 'second') AS d3 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/datetime_functions_oracle.sql b/tests/test_sql_refsols/datetime_functions_oracle.sql index a0a6ddc67..d1b86796d 100644 --- a/tests/test_sql_refsols/datetime_functions_oracle.sql +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -16,8 +16,8 @@ SELECT 23 AS hour_str, 59 AS minute_str, 59 AS second_ts, - CAST(CAST('1992-01-01' AS TIMESTAMP) AS DATE) - CAST(o_orderdate AS DATE) AS dd_col_str, - CAST(o_orderdate AS DATE) - CAST(CAST('1992-01-01' AS TIMESTAMP) AS DATE) AS dd_str_col, + CAST('1992-01-01' AS DATE) - CAST(o_orderdate AS DATE) AS dd_col_str, + CAST(o_orderdate AS DATE) - CAST('1992-01-01' AS DATE) AS dd_str_col, ( EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1995-10-10 00:00:00', 'YYYY-MM-DD HH24:MI:SS')) ) * 12 + ( @@ -26,7 +26,7 @@ SELECT EXTRACT(YEAR FROM TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS dd_col_dt, FLOOR( ( - TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS') - CAST(CAST('1992-01-01' AS TIMESTAMP) AS DATE) + ( + TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS') - CAST('1992-01-01' AS DATE) + ( MOD(( TO_CHAR('1992-01-01', 'D') + -1 ), 7) diff --git a/tests/test_sql_refsols/datetime_relative_oracle.sql b/tests/test_sql_refsols/datetime_relative_oracle.sql index 14080dde6..9be5cdcea 100644 --- a/tests/test_sql_refsols/datetime_relative_oracle.sql +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -8,9 +8,9 @@ WITH "_T0" AS ( FETCH FIRST 10 ROWS ONLY ) SELECT - TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'YEAR') AS d1, - TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'MONTH') AS d2, - CAST(O_ORDERDATE AS TIMESTAMP) + NUMTOYMINTERVAL(11, 'year') + NUMTOYMINTERVAL(9, 'month') + NUMTODSINTERVAL(7, 'day') + NUMTODSINTERVAL(5, 'hour') + NUMTODSINTERVAL(3, 'minute') + NUMTODSINTERVAL(1, 'second') AS d3, + TRUNC(CAST(O_ORDERDATE AS DATE), 'YEAR') AS d1, + TRUNC(CAST(O_ORDERDATE AS DATE), 'MONTH') AS d2, + CAST(O_ORDERDATE AS DATE) - NUMTOYMINTERVAL(11, 'year') + NUMTOYMINTERVAL(9, 'month') - NUMTODSINTERVAL(7, 'day') + NUMTODSINTERVAL(5, 'hour') - NUMTODSINTERVAL(3, 'minute') + NUMTODSINTERVAL(1, 'second') AS d3, TO_DATE('2025-07-04 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS d4, TO_DATE('2025-07-04 12:58:00', 'YYYY-MM-DD HH24:MI:SS') AS d5, TO_DATE('2025-07-26 02:45:25', 'YYYY-MM-DD HH24:MI:SS') AS d6 diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql index 098e3329b..4b76375cb 100644 --- a/tests/test_sql_refsols/datetime_sampler_oracle.sql +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -18,28 +18,28 @@ SELECT SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr16", SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr17", SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr18", - CAST(o_orderdate AS TIMESTAMP) AS "_expr19", + CAST(o_orderdate AS DATE) AS "_expr19", TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) AS "_expr20", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTODSINTERVAL(8, 'minute') + NUMTOYMINTERVAL(141, 'month') AS "_expr21", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTODSINTERVAL(8, 'minute') - NUMTOYMINTERVAL(141, 'month') AS "_expr21", TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), SECOND), HOUR) AS "_expr22", TIMESTAMP_TRUNC( TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), HOUR), SECOND), HOUR ) AS "_expr23", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(96, 'hour') + NUMTOYMINTERVAL(15, 'year') AS "_expr24", - TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(3, 'year'), MINUTE) + NUMTOYMINTERVAL(65, 'month') AS "_expr25", - TRUNC(CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(56, 'hour'), 'YEAR') AS "_expr26", + SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(96, 'hour') + NUMTOYMINTERVAL(15, 'year') AS "_expr24", + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') - NUMTOYMINTERVAL(3, 'year'), MINUTE) + NUMTOYMINTERVAL(65, 'month') AS "_expr25", + TRUNC(CAST(o_orderdate AS DATE) - NUMTODSINTERVAL(56, 'hour'), 'YEAR') AS "_expr26", TIMESTAMP_TRUNC( - TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(63, 'day'), MINUTE), + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(63, 'day'), MINUTE), SECOND ) AS "_expr27", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AS "_expr28", - TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(312, 'hour'), SECOND) + NUMTOYMINTERVAL(48, 'year') AS "_expr29", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(75, 'day'), 'DAY') + NUMTODSINTERVAL(600, 'minute') + NUMTODSINTERVAL(294, 'day') AS "_expr30", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(480, 'month') + NUMTOYMINTERVAL(45, 'year') AS "_expr31", + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(312, 'hour'), SECOND) + NUMTOYMINTERVAL(48, 'year') AS "_expr29", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(75, 'day'), 'DAY') + NUMTODSINTERVAL(600, 'minute') - NUMTODSINTERVAL(294, 'day') AS "_expr30", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(480, 'month') - NUMTOYMINTERVAL(45, 'year') AS "_expr31", TIMESTAMP_TRUNC( TRUNC( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(270, 'minute') + NUMTODSINTERVAL(34, 'second'), + SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(270, 'minute') - NUMTODSINTERVAL(34, 'second'), 'DAY' ), SECOND @@ -53,7 +53,7 @@ SELECT TO_DATE('2025-07-01 00:22:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr39", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') AS "_expr40", TRUNC( - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(82, 'second') + NUMTODSINTERVAL(415, 'second') + NUMTODSINTERVAL(160, 'second'), + CAST(o_orderdate AS DATE) + NUMTODSINTERVAL(82, 'second') + NUMTODSINTERVAL(415, 'second') - NUMTODSINTERVAL(160, 'second'), 'YEAR' ) AS "_expr41", SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(192, 'month') AS "_expr42", @@ -61,9 +61,9 @@ SELECT TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), HOUR), MINUTE), HOUR ) + NUMTODSINTERVAL(486, 'minute') AS "_expr43", - TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) + NUMTODSINTERVAL(50, 'hour') AS "_expr44", + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) - NUMTODSINTERVAL(50, 'hour') AS "_expr44", TIMESTAMP_TRUNC( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day') + NUMTOYMINTERVAL(72, 'month') + NUMTOYMINTERVAL(92, 'month'), + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day') + NUMTOYMINTERVAL(72, 'month') - NUMTOYMINTERVAL(92, 'month'), HOUR ) AS "_expr45", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(285, 'second'), 'DAY') AS "_expr46", @@ -71,13 +71,13 @@ SELECT TRUNC( TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(1, 'hour'), 'MONTH' - ) + NUMTODSINTERVAL(21, 'day') AS "_expr48", + ) - NUMTODSINTERVAL(21, 'day') AS "_expr48", SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(212, 'minute') + NUMTOYMINTERVAL(368, 'year') AS "_expr49", TO_DATE('2024-01-01', 'YYYY-MM-DD') AS "_expr50", TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr51", - TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(60, 'hour'), 'DAY'), MINUTE) + NUMTOYMINTERVAL(196, 'year') AS "_expr52", + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(60, 'hour'), 'DAY'), MINUTE) + NUMTOYMINTERVAL(196, 'year') AS "_expr52", TIMESTAMP_TRUNC( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(40, 'hour') + NUMTODSINTERVAL(385, 'day'), + SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(40, 'hour') - NUMTODSINTERVAL(385, 'day'), MINUTE ) + NUMTODSINTERVAL(29, 'hour') AS "_expr53", TIMESTAMP_TRUNC( @@ -89,8 +89,8 @@ SELECT TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), MINUTE), SECOND), 'DAY' ) + NUMTODSINTERVAL(78, 'second') AS "_expr56", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(136, 'hour') + NUMTODSINTERVAL(104, 'minute') + NUMTOYMINTERVAL(104, 'month') + NUMTODSINTERVAL(312, 'day') AS "_expr57", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(45, 'month') + NUMTODSINTERVAL(135, 'second') AS "_expr58", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(136, 'hour') + NUMTODSINTERVAL(104, 'minute') - NUMTOYMINTERVAL(104, 'month') + NUMTODSINTERVAL(312, 'day') AS "_expr57", + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(45, 'month') - NUMTODSINTERVAL(135, 'second') AS "_expr58", EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr59", 2025 AS "_expr60", 1999 AS "_expr61", @@ -109,12 +109,12 @@ SELECT EXTRACT(SECOND FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS TIMESTAMP)) AS "_expr74", 45 AS "_expr75", 0 AS "_expr76", - EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) AS "_expr77", + EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST('2018-02-14 12:41:06' AS DATE)) AS "_expr77", EXTRACT(YEAR FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS "_expr78", ( - EXTRACT(YEAR FROM CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) + EXTRACT(YEAR FROM CAST('1999-03-14' AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) ) * 12 + ( - EXTRACT(MONTH FROM CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) + EXTRACT(MONTH FROM CAST('1999-03-14' AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) ) AS "_expr79", ( EXTRACT(YEAR FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) @@ -122,53 +122,53 @@ SELECT EXTRACT(MONTH FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(MONTH FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) ) AS "_expr80", CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS "_expr81", - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE) AS "_expr82", + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST('1999-03-14' AS DATE) AS "_expr82", ( - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'HH24') + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'HH24') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'HH24') ) * 24 AS "_expr83", ( - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATETIME), 'HH24') + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'HH24') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATE), 'HH24') ) * 24 AS "_expr84", ( - TRUNC(CAST(TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'MI') + TRUNC(CAST(TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'MI') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'MI') ) * 1440 AS "_expr85", ( - TRUNC(CAST(TO_DATE('2021-01-01 07:35:00', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'MI') + TRUNC(CAST(TO_DATE('2021-01-01 07:35:00', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'MI') - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'MI') ) * 1440 AS "_expr86", ( TO_DATE('2021-01-01 07:35:00', 'YYYY-MM-DD HH24:MI:SS') - TO_DATE('2022-11-24', 'YYYY-MM-DD') ) * 86400 AS "_expr87", ( - CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE) - TO_DATE('2005-06-30', 'YYYY-MM-DD') + CAST('2018-02-14 12:41:06' AS DATE) - TO_DATE('2005-06-30', 'YYYY-MM-DD') ) * 86400 AS "_expr88", EXTRACT(YEAR FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS "_expr89", - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) AS "_expr90", + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('2018-02-14 12:41:06' AS DATE)) AS "_expr90", ( EXTRACT(YEAR FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) ) * 12 + ( EXTRACT(MONTH FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) ) AS "_expr91", ( - EXTRACT(YEAR FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) + EXTRACT(YEAR FROM CAST('2018-02-14 12:41:06' AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) ) * 12 + ( - EXTRACT(MONTH FROM CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) + EXTRACT(MONTH FROM CAST('2018-02-14 12:41:06' AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) ) AS "_expr92", CAST(o_orderdate AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS "_expr93", CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr94", ( - TRUNC(CAST(CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(TO_DATE('2022-11-24', 'YYYY-MM-DD') AS DATETIME), 'HH24') + TRUNC(CAST(CAST('1999-03-14' AS DATE) AS DATE), 'HH24') - TRUNC(CAST(TO_DATE('2022-11-24', 'YYYY-MM-DD') AS DATE), 'HH24') ) * 24 AS "_expr95", ( - TRUNC(CAST(TO_DATE('2020-12-31 00:31:06', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'HH24') - TRUNC(CAST(CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE) AS DATETIME), 'HH24') + TRUNC(CAST(TO_DATE('2020-12-31 00:31:06', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'HH24') - TRUNC(CAST(CAST('2018-02-14 12:41:06' AS DATE) AS DATE), 'HH24') ) * 24 AS "_expr96", ( - TRUNC(CAST(TO_DATE('2020-12-31 00:31:06', 'YYYY-MM-DD HH24:MI:SS') AS DATETIME), 'MI') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATETIME), 'MI') + TRUNC(CAST(TO_DATE('2020-12-31 00:31:06', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'MI') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATE), 'MI') ) * 1440 AS "_expr97", ( - TRUNC(CAST(CAST(CAST('2018-02-14 12:41:06' AS TIMESTAMP) AS DATE) AS DATETIME), 'MI') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATETIME), 'MI') + TRUNC(CAST(CAST('2018-02-14 12:41:06' AS DATE) AS DATE), 'MI') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'MI') ) * 1440 AS "_expr98", ( - CAST(CAST('1999-03-14' AS TIMESTAMP) AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) + CAST('1999-03-14' AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) ) * 86400 AS "_expr99", ( TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS') - TO_DATE('2022-11-24', 'YYYY-MM-DD') diff --git a/tests/test_sql_refsols/defog_academic_gen18_ansi.sql b/tests/test_sql_refsols/defog_academic_gen18_ansi.sql index 5e74d9732..0c76bc41e 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_ansi.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_ansi.sql @@ -14,4 +14,5 @@ FROM main.journal AS journal LEFT JOIN _s1 AS _s1 ON _s1.jid = journal.jid ORDER BY - 3 DESC + 3 DESC, + 1 diff --git a/tests/test_sql_refsols/defog_academic_gen18_mysql.sql b/tests/test_sql_refsols/defog_academic_gen18_mysql.sql index 19ad60584..2f5faa0d7 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_mysql.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_mysql.sql @@ -7,11 +7,12 @@ WITH _s1 AS ( 1 ) SELECT - journal.name, + journal.name COLLATE utf8mb4_bin AS name, journal.jid AS journal_id, COALESCE(_s1.n_rows, 0) AS num_publications FROM journal AS journal LEFT JOIN _s1 AS _s1 ON _s1.jid = journal.jid ORDER BY - 3 DESC + 3 DESC, + 1 diff --git a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql index 1e29049ab..21fff6ee5 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql @@ -14,4 +14,5 @@ FROM MAIN.JOURNAL JOURNAL LEFT JOIN "_S1" "_S1" ON JOURNAL.jid = "_S1".JID ORDER BY - 3 DESC NULLS LAST + 3 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen18_postgres.sql b/tests/test_sql_refsols/defog_academic_gen18_postgres.sql index 0a626646b..acd7d876f 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_postgres.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_postgres.sql @@ -14,4 +14,5 @@ FROM main.journal AS journal LEFT JOIN _s1 AS _s1 ON _s1.jid = journal.jid ORDER BY - 3 DESC NULLS LAST + 3 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen18_snowflake.sql b/tests/test_sql_refsols/defog_academic_gen18_snowflake.sql index 6aabf0fab..4ee861f56 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_snowflake.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_snowflake.sql @@ -14,4 +14,5 @@ FROM academic.journal AS journal LEFT JOIN _s1 AS _s1 ON _s1.jid = journal.jid ORDER BY - 3 DESC NULLS LAST + 3 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen18_sqlite.sql b/tests/test_sql_refsols/defog_academic_gen18_sqlite.sql index 5e74d9732..0c76bc41e 100644 --- a/tests/test_sql_refsols/defog_academic_gen18_sqlite.sql +++ b/tests/test_sql_refsols/defog_academic_gen18_sqlite.sql @@ -14,4 +14,5 @@ FROM main.journal AS journal LEFT JOIN _s1 AS _s1 ON _s1.jid = journal.jid ORDER BY - 3 DESC + 3 DESC, + 1 diff --git a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql index 1ed9f9be2..2ffb787a7 100644 --- a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -6,7 +6,7 @@ WITH "_S1" AS ( FROM MAIN.SBTRANSACTION WHERE sbtxdatetime >= ( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(1, 'month') + SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(1, 'month') ) AND sbtxtype = 'sell' GROUP BY diff --git a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql index a80790898..ada0fafd1 100644 --- a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql @@ -4,7 +4,7 @@ WITH "_S1" AS ( COUNT(*) AS N_ROWS FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(10, 'day'), 'DAY') + sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(10, 'day'), 'DAY') AND sbtxtype = 'buy' GROUP BY sbtxtickerid diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql index a9dc4d785..0dbda290c 100644 --- a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -28,7 +28,7 @@ WITH "_S2" AS ( FROM MAIN.SBCUSTOMER WHERE sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'MONTH') + AND sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'MONTH') GROUP BY LTRIM( NVL2( @@ -94,7 +94,7 @@ WITH "_S2" AS ( AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid WHERE SBCUSTOMER.sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'MONTH') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'MONTH') GROUP BY LTRIM( NVL2( diff --git a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql index 0f4a3a16e..078f1d66c 100644 --- a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql @@ -6,7 +6,7 @@ JOIN MAIN.SBCUSTOMER SBCUSTOMER ON LOWER(SBCUSTOMER.sbcustcountry) = 'usa' AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid WHERE - SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') AND SBTRANSACTION.sbtxdatetime >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NUMTODSINTERVAL(1, 'week') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') - NUMTODSINTERVAL(7, 'DAY') ) diff --git a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql index 2049353ec..9c6d3f03b 100644 --- a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql @@ -1,5 +1,5 @@ SELECT - TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') AS week, + TRUNC(CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) AS DATE), 'IW') AS week, COUNT(*) AS num_transactions, COALESCE( SUM(( @@ -14,9 +14,9 @@ JOIN MAIN.SBTICKER SBTICKER ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid AND SBTICKER.sbtickertype = 'stock' WHERE - SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') AND SBTRANSACTION.sbtxdatetime >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NUMTODSINTERVAL(8, 'week') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') - NUMTODSINTERVAL(56, 'DAY') ) GROUP BY - TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') + TRUNC(CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) AS DATE), 'IW') diff --git a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql index d49913b9b..ca833cfcf 100644 --- a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( SUM(sbtxamount) AS SUM_SBTXAMOUNT FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(30, 'day'), 'DAY') + sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(30, 'day'), 'DAY') GROUP BY sbtxcustid ) diff --git a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql index 0876ce6ff..64f24683a 100644 --- a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql @@ -3,4 +3,4 @@ SELECT FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid - AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(70, 'day'), 'DAY') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(70, 'day'), 'DAY') diff --git a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql index ed7e840e7..c107b294e 100644 --- a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql @@ -4,7 +4,7 @@ WITH "_S1" AS ( COUNT(*) AS N_ROWS FROM MAIN.SBTRANSACTION WHERE - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY') = TO_DATE('2023-04-01', 'YYYY-MM-DD') + TRUNC(CAST(sbtxdatetime AS DATE), 'DAY') = TO_DATE('2023-04-01', 'YYYY-MM-DD') AND sbtxtype = 'sell' GROUP BY sbtxcustid diff --git a/tests/test_sql_refsols/defog_broker_gen5_oracle.sql b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql index 733ffa193..694a27f2e 100644 --- a/tests/test_sql_refsols/defog_broker_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql @@ -1,5 +1,5 @@ SELECT - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') AS month, + TRUNC(CAST(sbtxdatetime AS DATE), 'MONTH') AS month, AVG(sbtxprice) AS avg_price FROM MAIN.SBTRANSACTION WHERE @@ -7,6 +7,6 @@ WHERE AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 AND sbtxstatus = 'success' GROUP BY - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') + TRUNC(CAST(sbtxdatetime AS DATE), 'MONTH') ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql index de9b307ed..0a056a4d5 100644 --- a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql @@ -1,10 +1,10 @@ WITH "_S1" AS ( SELECT - TRUNC(CAST(payment_date AS TIMESTAMP), 'MONTH') AS START_MONTH, + TRUNC(CAST(payment_date AS DATE), 'MONTH') AS START_MONTH, SUM(payment_amount) AS SUM_PAYMENT_AMOUNT FROM MAIN.PAYMENTS_RECEIVED GROUP BY - TRUNC(CAST(payment_date AS TIMESTAMP), 'MONTH') + TRUNC(CAST(payment_date AS DATE), 'MONTH') ), "_T0" AS ( SELECT DATETIME("_S1".START_MONTH, COLUMN1 || ' months') AS DT, diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql index 6853f2b14..574f6dcbb 100644 --- a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -1,5 +1,5 @@ SELECT - TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') AS payment_week, + TRUNC(CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) AS DATE), 'IW') AS payment_week, COUNT(*) AS total_payments, COALESCE( SUM( @@ -42,4 +42,4 @@ WHERE ) / 7 ) >= 1 GROUP BY - TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') + TRUNC(CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) AS DATE), 'IW') diff --git a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql index 7ff083df9..6f5ad39ef 100644 --- a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql @@ -5,7 +5,7 @@ FROM MAIN.CARS CARS JOIN MAIN.SALES SALES ON CARS."_id" = SALES.car_id AND SALES.sale_date >= ( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(30, 'day') + SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(30, 'day') ) WHERE LOWER(CARS.make) LIKE '%toyota%' diff --git a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql index 38ca04e29..7b1f68be0 100644 --- a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql @@ -6,7 +6,7 @@ WITH "_S1" AS ( FROM MAIN.SALES WHERE sale_date >= ( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(3, 'month') + SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(3, 'month') ) GROUP BY salesperson_id diff --git a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql index 32befecca..56a98e5c6 100644 --- a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql @@ -1,10 +1,22 @@ SELECT payment_date, payment_method, - NVL(SUM(payment_amount), 0) AS total_amount + COALESCE(SUM(payment_amount), 0) AS total_amount FROM MAIN.PAYMENTS_RECEIVED WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(payment_date AS DATETIME), WEEK) = 1 + FLOOR( + ( + CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(payment_date AS DATE) + ( + MOD(( + TO_CHAR(payment_date, 'D') + 5 + ), 7) + ) - ( + MOD(( + TO_CHAR('now', 'D') + 5 + ), 7) + ) + ) / 7 + ) = 1 GROUP BY payment_date, payment_method diff --git a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql index 9b932ce0c..493cbd135 100644 --- a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -1,13 +1,13 @@ WITH "_S0" AS ( SELECT - TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER') AS QUARTER, + TRUNC(CAST(sale_date AS DATE), 'QUARTER') AS QUARTER, customer_id AS CUSTOMER_ID, SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE EXTRACT(YEAR FROM CAST(sale_date AS DATE)) = 2023 GROUP BY - TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER'), + TRUNC(CAST(sale_date AS DATE), 'QUARTER'), customer_id ), "_T1" AS ( SELECT diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql index ec8b9d52c..f277dc356 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql @@ -5,7 +5,7 @@ WITH "_S3" AS ( FROM MAIN.TREATMENTS TREATMENTS JOIN MAIN.ADVERSE_EVENTS ADVERSE_EVENTS ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id - AND TRUNC(CAST(ADVERSE_EVENTS.reported_dt AS TIMESTAMP), 'MONTH') = TRUNC(CAST(TREATMENTS.start_dt AS TIMESTAMP), 'MONTH') + AND TRUNC(CAST(ADVERSE_EVENTS.reported_dt AS DATE), 'MONTH') = TRUNC(CAST(TREATMENTS.start_dt AS DATE), 'MONTH') GROUP BY TREATMENTS.drug_id ) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql index bc329c91a..0f96dca36 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql @@ -7,5 +7,5 @@ JOIN MAIN.PATIENTS PATIENTS WHERE TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND TREATMENTS.start_dt >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(6, 'month') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(6, 'month') ) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql index 20310940e..a94cf5354 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -1,33 +1,29 @@ WITH "_T0" AS ( SELECT - TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') AS START_MONTH, + TRUNC(CAST(start_dt AS DATE), 'MONTH') AS START_MONTH, COUNT(*) AS N_ROWS, COUNT(DISTINCT diag_id) AS NDISTINCT_DIAG_ID FROM MAIN.TREATMENTS WHERE ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(12, 'month') - ) <= TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') - AND TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(12, 'month') + ) <= TRUNC(CAST(start_dt AS DATE), 'MONTH') + AND TRUNC(CAST(start_dt AS DATE), 'MONTH') < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') GROUP BY - TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') + TRUNC(CAST(start_dt AS DATE), 'MONTH') ) SELECT LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(START_MONTH AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(START_MONTH AS DATE)), - NULL - ) || NVL2( + NVL2(EXTRACT(YEAR FROM START_MONTH), '-' || EXTRACT(YEAR FROM START_MONTH), NULL) || NVL2( CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))), -2) + WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) END, '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(START_MONTH AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(START_MONTH AS DATE))), -2) + WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) END, NULL ), diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql index 88928e476..eb69de4e5 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -29,7 +29,7 @@ WITH "_S2" AS ( WHERE start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND start_dt >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(3, 'month') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(3, 'month') ) GROUP BY LTRIM( @@ -89,7 +89,7 @@ WITH "_S2" AS ( WHERE TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND TREATMENTS.start_dt >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(3, 'month') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(3, 'month') ) GROUP BY LTRIM( diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql index 13a38c4e0..d397485fc 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( SUM(tot_drug_amt) AS SUM_TOT_DRUG_AMT FROM MAIN.TREATMENTS WHERE - start_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'DAY') + start_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'DAY') GROUP BY doc_id ), "_T1" AS ( diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql index 82e6555a8..914245f47 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql @@ -1,11 +1,4 @@ -WITH "_u_0" AS ( - SELECT - ARRAY_AGG(doc_id) AS DOC_ID, - year_reg AS "_u_1" - FROM MAIN.DOCTORS - GROUP BY - year_reg -), "_T" AS ( +WITH "_T" AS ( SELECT doc_id AS DOC_ID, start_dt AS START_DT, @@ -22,12 +15,12 @@ WITH "_u_0" AS ( "_W" = 1 ) SELECT - "_S0".LAST_NAME AS last_name, - "_S0".YEAR_REG AS year_reg, + DOCTORS.last_name, + DOCTORS.year_reg, "_S1".START_DT AS first_treatment_date, "_S1".TREATMENT_ID AS first_treatment_id -FROM "_u_0".DOC_ID -LEFT JOIN "_u_0" "_u_0" - ON "_u_0"."_u_1" = EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(2, 'year') AS DATE)) +FROM MAIN.DOCTORS DOCTORS LEFT JOIN "_S1" "_S1" - ON "_S0".DOC_ID = "_S1".DOC_ID + ON DOCTORS.doc_id = "_S1".DOC_ID +WHERE + DOCTORS.year_reg = EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(2, 'year') AS DATE)) diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql index 0037e526e..fb6cf1a7c 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql @@ -8,4 +8,4 @@ JOIN MAIN.DRUGS DRUGS ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT DRUGS.fda_appr_dt IS NULL WHERE NOT TREATMENTS.end_dt IS NULL - AND TREATMENTS.end_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(6, 'month'), 'DAY') + AND TREATMENTS.end_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql index cbc4f56f7..9049c3403 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql @@ -2,5 +2,5 @@ SELECT COUNT(*) AS TUC FROM MAIN.USER_SESSIONS WHERE - session_end_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(1, 'month'), 'DAY') - OR session_start_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(1, 'month'), 'DAY') + session_end_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(1, 'month'), 'DAY') + OR session_start_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(1, 'month'), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql index ee0d96e3b..869fb10c4 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql @@ -1,5 +1,11 @@ SELECT - NVL(SUM(status = 'success'), 0) / COUNT(*) AS "_expr0" + COALESCE(SUM(status = 'success'), 0) / NULLIF(COUNT(*), 0) AS "_expr0" FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE - DATEDIFF(CURRENT_TIMESTAMP, CAST(created_at AS DATETIME), MONTH) = 1 + ( + ( + EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(created_at AS DATE)) + ) * 12 + ( + EXTRACT(MONTH FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) - EXTRACT(MONTH FROM CAST(created_at AS DATE)) + ) + ) = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_ansi.sql b/tests/test_sql_refsols/defog_ewallet_adv2_ansi.sql index 6b3e74934..049fec3b5 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_ansi.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_ansi.sql @@ -1,11 +1,11 @@ SELECT DATE_TRUNC('WEEK', CAST(notifications.created_at AS TIMESTAMP)) AS week, COUNT(*) AS num_notifs, - COALESCE(SUM(( + SUM(( ( DAY_OF_WEEK(notifications.created_at) + 6 ) % 7 - ) IN (5, 6)), 0) AS weekend_notifs + ) IN (5, 6)) AS weekend_notifs FROM main.notifications AS notifications JOIN main.users AS users ON notifications.user_id = users.uid AND users.country IN ('US', 'CA') diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_mysql.sql b/tests/test_sql_refsols/defog_ewallet_adv2_mysql.sql index 9389642e9..97d8ddfc4 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_mysql.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_mysql.sql @@ -8,11 +8,11 @@ SELECT ) DAY ) AS DATE) AS week, COUNT(*) AS num_notifs, - COALESCE(SUM(( + SUM(( ( DAYOFWEEK(notifications.created_at) + 5 ) % 7 - ) IN (5, 6)), 0) AS weekend_notifs + ) IN (5, 6)) AS weekend_notifs FROM ewallet.notifications AS notifications JOIN ewallet.users AS users ON notifications.user_id = users.uid AND users.country IN ('US', 'CA') diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql index 7a8856bf6..1d1788de3 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql @@ -1,21 +1,18 @@ SELECT - TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') AS week, + TRUNC(CAST(CAST(NOTIFICATIONS.created_at AS DATE) AS DATE), 'IW') AS week, COUNT(*) AS num_notifs, - COALESCE( - SUM(( - MOD(( - TO_CHAR(NOTIFICATIONS.created_at, 'D') + 5 - ), 7) - ) IN (5, 6)), - 0 - ) AS weekend_notifs + SUM(( + MOD(( + TO_CHAR(NOTIFICATIONS.created_at, 'D') + 5 + ), 7) + ) IN (5, 6)) AS weekend_notifs FROM MAIN.NOTIFICATIONS NOTIFICATIONS JOIN MAIN.USERS USERS ON NOTIFICATIONS.user_id = USERS.uid AND USERS.country IN ('US', 'CA') WHERE - NOTIFICATIONS.created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NOTIFICATIONS.created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') AND NOTIFICATIONS.created_at >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'WEEK') + NUMTODSINTERVAL(3, 'week') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') - NUMTODSINTERVAL(21, 'DAY') ) GROUP BY - TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') + TRUNC(CAST(CAST(NOTIFICATIONS.created_at AS DATE) AS DATE), 'IW') diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_postgres.sql b/tests/test_sql_refsols/defog_ewallet_adv2_postgres.sql index 6f64c6920..2cfd37f2c 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_postgres.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_postgres.sql @@ -6,19 +6,16 @@ SELECT ) % 7 || ' days' AS INTERVAL) ) AS week, COUNT(*) AS num_notifs, - COALESCE( - SUM( - CASE - WHEN ( - ( - EXTRACT(DOW FROM CAST(notifications.created_at AS TIMESTAMP)) + 6 - ) % 7 - ) IN (5, 6) - THEN 1 - ELSE 0 - END - ), - 0 + SUM( + CASE + WHEN ( + ( + EXTRACT(DOW FROM CAST(notifications.created_at AS TIMESTAMP)) + 6 + ) % 7 + ) IN (5, 6) + THEN 1 + ELSE 0 + END ) AS weekend_notifs FROM main.notifications AS notifications JOIN main.users AS users diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_sqlite.sql b/tests/test_sql_refsols/defog_ewallet_adv2_sqlite.sql index 066e9ad16..e8851a5d2 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_sqlite.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_sqlite.sql @@ -7,15 +7,12 @@ SELECT 'start of day' ) AS week, COUNT(*) AS num_notifs, - COALESCE( - SUM( + SUM( + ( ( - ( - CAST(STRFTIME('%w', notifications.created_at) AS INTEGER) + 6 - ) % 7 - ) IN (5, 6) - ), - 0 + CAST(STRFTIME('%w', notifications.created_at) AS INTEGER) + 6 + ) % 7 + ) IN (5, 6) ) AS weekend_notifs FROM main.notifications AS notifications JOIN main.users AS users diff --git a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql index e5fce1dba..3802cf8a0 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql @@ -1,12 +1,12 @@ SELECT - TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') AS year_month, + TRUNC(CAST(created_at AS DATE), 'MONTH') AS year_month, COUNT(DISTINCT sender_id) AS active_users FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND created_at >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(2, 'month') + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(2, 'month') ) AND sender_type = 0 GROUP BY - TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') + TRUNC(CAST(created_at AS DATE), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql index 63f621ddf..e602608c1 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql @@ -4,7 +4,7 @@ WITH "_S1" AS ( receiver_id AS RECEIVER_ID FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE - created_at >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(150, 'day'), 'DAY') + created_at >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(150, 'day'), 'DAY') AND receiver_type = 1 ) SELECT diff --git a/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql index dfdbbd51f..7b5b817b2 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql @@ -1,5 +1,5 @@ SELECT - TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS TIMESTAMP), 'MONTH') AS month, + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE), 'MONTH') AS month, COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.sender_id) AS active_users FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY JOIN MAIN.USERS USERS @@ -9,4 +9,4 @@ WHERE AND WALLET_TRANSACTIONS_DAILY.sender_type = 0 AND WALLET_TRANSACTIONS_DAILY.status = 'success' GROUP BY - TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS TIMESTAMP), 'MONTH') + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql index fbb930523..0cc2e2312 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql @@ -19,7 +19,7 @@ WITH "_T0" AS ( AND MERCHANTS.mid = WALLET_MERCHANT_BALANCE_DAILY.merchant_id AND MERCHANTS.status = 'active' WHERE - TRUNC(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS TIMESTAMP), 'DAY') = TRUNC(CURRENT_TIMESTAMP, 'DAY') + TRUNC(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS DATE), 'DAY') = TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') ) SELECT AVG(EXPR_1) AS "_expr0" diff --git a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql index ea73ca5e6..554fab250 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql @@ -34,5 +34,5 @@ FROM "_S4" "_S4" JOIN "_T1" "_S5" ON "_S4".MID = "_S5".MERCHANT_ID AND "_S5".START_DATE <= ( - CAST("_S4".ANYTHING_CREATED_AT AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + CAST("_S4".ANYTHING_CREATED_AT AS DATE) + NUMTOYMINTERVAL(1, 'year') ) diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql index 839319b6d..bf62ab576 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -4,7 +4,7 @@ WITH "_u_0" AS ( FROM MAIN.NOTIFICATIONS NOTIFICATIONS JOIN MAIN.USERS USERS ON NOTIFICATIONS.created_at <= ( - CAST(USERS.created_at AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + CAST(USERS.created_at AS DATE) + NUMTOYMINTERVAL(1, 'year') ) AND NOTIFICATIONS.created_at >= USERS.created_at AND NOTIFICATIONS.user_id = USERS.uid diff --git a/tests/test_sql_refsols/order_quarter_test_oracle.sql b/tests/test_sql_refsols/order_quarter_test_oracle.sql index 7131ef5ab..7a0d40b1e 100644 --- a/tests/test_sql_refsols/order_quarter_test_oracle.sql +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -1,23 +1,23 @@ SELECT o_orderdate AS order_date, EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) AS quarter, - TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER') AS quarter_start, - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(1, 'quarter') AS next_quarter, - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(1, 'quarter') AS prev_quarter, - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(2, 'quarter') AS two_quarters_ahead, - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(2, 'quarter') AS two_quarters_behind, + TRUNC(CAST(o_orderdate AS DATE), 'QUARTER') AS quarter_start, + CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(3, 'MONTH') AS next_quarter, + CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(3, 'MONTH') AS prev_quarter, + CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(6, 'MONTH') AS two_quarters_ahead, + CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(6, 'MONTH') AS two_quarters_behind, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1995-01-01' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1995-01-01' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('1995-01-01' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST('1995-01-01' AS DATE)) ) AS quarters_since_1995, ( - EXTRACT(YEAR FROM CAST(CAST('2000-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) + EXTRACT(YEAR FROM CAST('2000-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2000-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) + EXTRACT(QUARTER FROM CAST('2000-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) ) AS quarters_until_2000, - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(4, 'quarter') AS same_quarter_prev_year, - CAST(o_orderdate AS TIMESTAMP) + NUMTODSINTERVAL(4, 'quarter') AS same_quarter_next_year + CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(12, 'MONTH') AS same_quarter_prev_year, + CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(12, 'MONTH') AS same_quarter_next_year FROM TPCH.ORDERS WHERE EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 1995 diff --git a/tests/test_sql_refsols/part_cross_part_b_oracle.sql b/tests/test_sql_refsols/part_cross_part_b_oracle.sql index 591c8b44e..868cf7abe 100644 --- a/tests/test_sql_refsols/part_cross_part_b_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_b_oracle.sql @@ -10,11 +10,11 @@ WITH "_S0" AS ( EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_S1" AS ( SELECT DISTINCT - TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + TRUNC(CAST(SBTXDATETIME AS DATE), 'MONTH') AS MONTH FROM "_T2" ), "_S3" AS ( SELECT DISTINCT - TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + TRUNC(CAST(SBTXDATETIME AS DATE), 'MONTH') AS MONTH FROM "_T2" ), "_S9" AS ( SELECT @@ -25,7 +25,7 @@ WITH "_S0" AS ( CROSS JOIN "_S3" "_S3" JOIN MAIN.SBTRANSACTION SBTRANSACTION ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 2023 - AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'MONTH') JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid AND SBCUSTOMER.sbcuststate = "_S2".SBCUSTSTATE diff --git a/tests/test_sql_refsols/part_cross_part_c_oracle.sql b/tests/test_sql_refsols/part_cross_part_c_oracle.sql index 69dd53b32..6a9bb0dee 100644 --- a/tests/test_sql_refsols/part_cross_part_c_oracle.sql +++ b/tests/test_sql_refsols/part_cross_part_c_oracle.sql @@ -10,11 +10,11 @@ WITH "_S0" AS ( EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_S1" AS ( SELECT DISTINCT - TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + TRUNC(CAST(SBTXDATETIME AS DATE), 'MONTH') AS MONTH FROM "_T2" ), "_S3" AS ( SELECT DISTINCT - TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + TRUNC(CAST(SBTXDATETIME AS DATE), 'MONTH') AS MONTH FROM "_T2" ), "_S9" AS ( SELECT @@ -25,7 +25,7 @@ WITH "_S0" AS ( CROSS JOIN "_S3" "_S3" JOIN MAIN.SBTRANSACTION SBTRANSACTION ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATE)) = 2023 - AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'MONTH') JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid AND SBCUSTOMER.sbcuststate = "_S2".SBCUSTSTATE diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql index 9aeef5f1f..50e497865 100644 --- a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -15,38 +15,38 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T4" JOIN "_S1" "_S3" - ON "_S3".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S3".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S3".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON DEVICES.de_product_id = 800544 - AND "_S3".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + AND "_S3".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') GROUP BY "_S3".CA_DT ), "_S22" AS ( SELECT - TRUNC(CAST("_S1".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + TRUNC(CAST("_S1".CA_DT AS DATE), 'QUARTER') AS QUARTER, SUM("_S7".N_ROWS) AS SUM_N_ROWS FROM "_T2" "_T2" JOIN "_S1" "_S1" - ON "_S1".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S1".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S1".CA_DT >= "_T2".PR_RELEASE LEFT JOIN "_S7" "_S7" ON "_S1".CA_DT = "_S7".CA_DT GROUP BY - TRUNC(CAST("_S1".CA_DT AS TIMESTAMP), 'QUARTER') + TRUNC(CAST("_S1".CA_DT AS DATE), 'QUARTER') ), "_S13" AS ( SELECT DISTINCT - TRUNC(CAST("_S11".CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + TRUNC(CAST("_S11".CA_DT AS DATE), 'QUARTER') AS QUARTER FROM "_T2" "_T10" JOIN "_S1" "_S11" - ON "_S11".CA_DT < TRUNC(CAST("_T10".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S11".CA_DT < TRUNC(CAST("_T10".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S11".CA_DT >= "_T10".PR_RELEASE ), "_S17" AS ( SELECT "_S15".CA_DT FROM "_T2" "_T11" JOIN "_S1" "_S15" - ON "_S15".CA_DT < TRUNC(CAST("_T11".PR_RELEASE AS TIMESTAMP) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S15".CA_DT < TRUNC(CAST("_T11".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') AND "_S15".CA_DT >= "_T11".PR_RELEASE ), "_S23" AS ( SELECT @@ -57,10 +57,10 @@ WITH "_T2" AS ( ON COUNTRIES.co_name = 'CN' CROSS JOIN "_S13" "_S13" JOIN "_S17" "_S17" - ON "_S13".QUARTER = TRUNC(CAST("_S17".CA_DT AS TIMESTAMP), 'QUARTER') + ON "_S13".QUARTER = TRUNC(CAST("_S17".CA_DT AS DATE), 'QUARTER') JOIN MAIN.INCIDENTS INCIDENTS ON COUNTRIES.co_id = INCIDENTS.in_repair_country_id - AND "_S17".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + AND "_S17".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = 800544 WHERE diff --git a/tests/test_sql_refsols/quarter_function_test_oracle.sql b/tests/test_sql_refsols/quarter_function_test_oracle.sql index 10bcb68c5..437b7a8f3 100644 --- a/tests/test_sql_refsols/quarter_function_test_oracle.sql +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -43,64 +43,64 @@ SELECT TO_DATE('2024-08-15', 'YYYY-MM-DD') AS syntax3, TO_DATE('2022-08-15', 'YYYY-MM-DD') AS syntax4, ( - EXTRACT(YEAR FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff1, ( - EXTRACT(YEAR FROM CAST(CAST('2023-07-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-07-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-07-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-07-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff2, ( - EXTRACT(YEAR FROM CAST(CAST('2023-10-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-10-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-10-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-10-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff3, ( - EXTRACT(YEAR FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-12-31' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-12-31' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff4, ( - EXTRACT(YEAR FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2024-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2024-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff5, ( - EXTRACT(YEAR FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2024-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2024-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff6, ( - EXTRACT(YEAR FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2022-10-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2024-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2022-10-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2024-04-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2022-10-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2024-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2022-10-15' AS DATE)) ) AS q_diff7, ( - EXTRACT(YEAR FROM CAST(CAST('2025-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2020-01-01' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2025-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2020-01-01' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2025-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2020-01-01' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2025-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2020-01-01' AS DATE)) ) AS q_diff8, ( - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-04-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-04-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-04-15' AS DATE)) ) AS q_diff9, ( - EXTRACT(YEAR FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2024-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-01-15' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2024-01-15' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2024-01-15' AS DATE)) ) AS q_diff10, ( - EXTRACT(YEAR FROM CAST(CAST('2023-04-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-03-31' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2023-04-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-03-31' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2023-04-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-03-31' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2023-04-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-03-31' AS DATE)) ) AS q_diff11, ( - EXTRACT(YEAR FROM CAST(CAST('2024-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST('2024-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-12-31' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(CAST('2024-01-01' AS TIMESTAMP) AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('2023-12-31' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST('2024-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-12-31' AS DATE)) ) AS q_diff12 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql index 385abc796..57f58fcd6 100644 --- a/tests/test_sql_refsols/simplification_4_oracle.sql +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -9,7 +9,7 @@ WITH "_T" AS ( ) SELECT SBTXDATETIME AS date_time, - TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'WEEK') + NUMTODSINTERVAL(8, 'week') AS s00, + TRUNC(CAST(CAST(SBTXDATETIME AS DATE) AS DATE), 'IW') - NUMTODSINTERVAL(56, 'DAY') AS s00, FALSE AS s01, EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (1, 2, 3) AS s02, EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (4, 5, 6) AS s03, diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql index d36c1044a..5b0d7da63 100644 --- a/tests/test_sql_refsols/smoke_b_oracle.sql +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -68,8 +68,8 @@ SELECT ), ':' ) AS b, - TRUNC(CAST(o_orderdate AS TIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(6, 'month') + NUMTODSINTERVAL(13, 'day') AS c, - TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER') + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(25, 'hour') AS d, + TRUNC(CAST(o_orderdate AS DATE), 'YEAR') + NUMTOYMINTERVAL(6, 'month') - NUMTODSINTERVAL(13, 'day') AS c, + TRUNC(CAST(o_orderdate AS DATE), 'QUARTER') + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(25, 'hour') AS d, TO_DATE('2025-01-01 12:35:00', 'YYYY-MM-DD HH24:MI:SS') AS e, TO_DATE('2025-07-22 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS f, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, @@ -77,20 +77,20 @@ SELECT NVL2(12, ';' || 12, NULL) || NVL2(20, ';' || 20, NULL) || NVL2(6, ';' || 6, NULL), ';' ) AS h, - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) AS i, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1993-05-25 12:45:36' AS DATE)) AS i, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1993-05-25 12:45:36' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST('1993-05-25 12:45:36' AS DATE)) ) AS j, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1993-05-25 12:45:36' AS DATE)) ) * 12 + ( - EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE)) + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM CAST('1993-05-25 12:45:36' AS DATE)) ) AS k, FLOOR( ( - CAST(o_orderdate AS DATE) - CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) + ( + CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) + ( MOD(( TO_CHAR('1993-05-25 12:45:36', 'D') + -1 ), 7) @@ -101,17 +101,17 @@ SELECT ) ) / 7 ) AS l, - CAST(o_orderdate AS DATE) - CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) AS m, + CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) AS m, ( - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'HH24') - TRUNC(CAST(CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) AS DATETIME), 'HH24') + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'HH24') - TRUNC(CAST(CAST('1993-05-25 12:45:36' AS DATE) AS DATE), 'HH24') ) * 24 AS n, ( - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATETIME), 'MI') - TRUNC(CAST(CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) AS DATETIME), 'MI') + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'MI') - TRUNC(CAST(CAST('1993-05-25 12:45:36' AS DATE) AS DATE), 'MI') ) * 1440 AS o, ( - CAST(o_orderdate AS DATE) - CAST(CAST('1993-05-25 12:45:36' AS TIMESTAMP) AS DATE) + CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) ) * 86400 AS p, - TRUNC(CAST(o_orderdate AS TIMESTAMP), 'WEEK') AS q + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'IW') AS q FROM TPCH.ORDERS WHERE o_clerk LIKE '%5' AND o_comment LIKE '%fo%' AND o_orderpriority LIKE '3%' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql index d10b30aee..0eb9299c0 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql index d717d1754..7e1dae063 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql index 4a88fd71c..41db613e1 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql index e58c89403..ada3d17f0 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql index 05f3feba9..bbb4e34d4 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql index 5b7d56dec..acac57829 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql index 4e176cadb..17bd59ad5 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql index 5c2483132..8e8995616 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql index c32f8fc3f..baa49f02a 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql index c787be52d..f1b4a7a1b 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql index 599cc58b8..f572c456b 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql index fbde2d92e..43a4bab80 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql index 3f5362969..2b43e5447 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql index ce549c8aa..214e9cd69 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql @@ -1,6 +1,6 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql index 495c40bf0..0f56df6c4 100644 --- a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql +++ b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql @@ -5,10 +5,10 @@ FROM MAIN.CALENDAR CALENDAR JOIN MAIN.CALENDAR CALENDAR_2 ON CALENDAR.ca_dt <= CALENDAR_2.ca_dt AND CALENDAR_2.ca_dt < ( - CAST(CALENDAR.ca_dt AS TIMESTAMP) + NUMTODSINTERVAL(5, 'day') + CAST(CALENDAR.ca_dt AS DATE) + NUMTODSINTERVAL(5, 'day') ) JOIN MAIN.DEVICES DEVICES - ON CALENDAR_2.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON CALENDAR_2.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') WHERE EXTRACT(YEAR FROM CAST(CALENDAR.ca_dt AS DATE)) = 2024 GROUP BY diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql index 8c1873360..a3b390900 100644 --- a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -18,10 +18,10 @@ WITH "_T2" AS ( FROM "_T2" "_T4" JOIN MAIN.CALENDAR CALENDAR ON CALENDAR.ca_dt >= ( - CAST("_T4".CA_DT AS TIMESTAMP) + NUMTOYMINTERVAL(6, 'month') + CAST("_T4".CA_DT AS DATE) - NUMTOYMINTERVAL(6, 'month') ) JOIN MAIN.DEVICES DEVICES - ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') JOIN "_T5" "_T5" ON DEVICES.de_production_country_id = "_T5".CO_ID GROUP BY @@ -32,7 +32,7 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T7" JOIN MAIN.INCIDENTS INCIDENTS - ON "_T7".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_T7".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id JOIN "_T5" "_T8" diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql index 051d86429..d4a144ecd 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql @@ -21,7 +21,7 @@ WITH "_S14" AS ( COUNT(*) AS N_ROWS FROM "_S6" "_S0" JOIN MAIN.INCIDENTS INCIDENTS - ON "_S0".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_S0".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id JOIN "_T5" "_T5" @@ -34,7 +34,7 @@ WITH "_S14" AS ( COUNT(*) AS N_ROWS FROM "_S6" "_S8" JOIN MAIN.DEVICES DEVICES - ON "_S8".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON "_S8".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') JOIN "_T5" "_T7" ON DEVICES.de_product_id = "_T7".PR_ID GROUP BY diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql index 33feef788..0ec8fb986 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql @@ -8,7 +8,7 @@ WITH "_S2" AS ( COUNT(*) AS N_ROWS FROM "_S2" "_S0" JOIN MAIN.DEVICES DEVICES - ON "_S0".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + ON "_S0".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') GROUP BY "_S0".CA_DT ), "_S7" AS ( @@ -17,7 +17,7 @@ WITH "_S2" AS ( COUNT(*) AS N_ROWS FROM "_S2" "_S4" JOIN MAIN.INCIDENTS INCIDENTS - ON "_S4".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + ON "_S4".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') GROUP BY "_S4".CA_DT ), "_T1" AS ( diff --git a/tests/test_sql_refsols/time_threshold_reached_oracle.sql b/tests/test_sql_refsols/time_threshold_reached_oracle.sql index 1a1403df1..e5e5f419f 100644 --- a/tests/test_sql_refsols/time_threshold_reached_oracle.sql +++ b/tests/test_sql_refsols/time_threshold_reached_oracle.sql @@ -2,15 +2,15 @@ WITH "_T3" AS ( SELECT sbtxdatetime AS SBTXDATETIME, ( - 100.0 * SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) - ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY')) AS PCT_OF_DAY + 100.0 * SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS DATE), 'DAY') ORDER BY sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) + ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS DATE), 'DAY')) AS PCT_OF_DAY FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_T" AS ( SELECT SBTXDATETIME, - ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'DAY') ORDER BY PCT_OF_DAY) AS "_W" + ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS DATE), 'DAY') ORDER BY PCT_OF_DAY) AS "_W" FROM "_T3" WHERE PCT_OF_DAY >= 50.0 diff --git a/tests/test_sql_refsols/week_offset_oracle.sql b/tests/test_sql_refsols/week_offset_oracle.sql index 20ffb3729..503f46793 100644 --- a/tests/test_sql_refsols/week_offset_oracle.sql +++ b/tests/test_sql_refsols/week_offset_oracle.sql @@ -1,13 +1,13 @@ SELECT sbtxdatetime AS date_time, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'week') AS week_adj1, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'week') AS week_adj2, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'hour') + NUMTODSINTERVAL(2, 'week') AS week_adj3, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'second') + NUMTODSINTERVAL(2, 'week') AS week_adj4, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'day') + NUMTODSINTERVAL(2, 'week') AS week_adj5, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTODSINTERVAL(1, 'minute') + NUMTODSINTERVAL(2, 'week') AS week_adj6, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'month') + NUMTODSINTERVAL(2, 'week') AS week_adj7, - CAST(sbtxdatetime AS TIMESTAMP) + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(2, 'week') AS week_adj8 + CAST(sbtxdatetime AS DATE) + NUMTODSINTERVAL(7, 'DAY') AS week_adj1, + CAST(sbtxdatetime AS DATE) - NUMTODSINTERVAL(7, 'DAY') AS week_adj2, + CAST(sbtxdatetime AS DATE) + NUMTODSINTERVAL(1, 'hour') + NUMTODSINTERVAL(14, 'DAY') AS week_adj3, + CAST(sbtxdatetime AS DATE) - NUMTODSINTERVAL(1, 'second') + NUMTODSINTERVAL(14, 'DAY') AS week_adj4, + CAST(sbtxdatetime AS DATE) + NUMTODSINTERVAL(1, 'day') + NUMTODSINTERVAL(14, 'DAY') AS week_adj5, + CAST(sbtxdatetime AS DATE) - NUMTODSINTERVAL(1, 'minute') + NUMTODSINTERVAL(14, 'DAY') AS week_adj6, + CAST(sbtxdatetime AS DATE) + NUMTOYMINTERVAL(1, 'month') + NUMTODSINTERVAL(14, 'DAY') AS week_adj7, + CAST(sbtxdatetime AS DATE) + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(14, 'DAY') AS week_adj8 FROM MAIN.SBTRANSACTION WHERE EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 From 299545183e744576b99a1857d7142f875a43e514 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 25 Feb 2026 13:08:17 -0600 Subject: [PATCH 18/48] quarter truncation fixed, add_months added --- .../oracle_transform_bindings.py | 15 +++++++++++---- tests/test_metadata/oracle_defog_graphs.json | 10 ++++++++++ .../defog_dealership_gen3_oracle.sql | 4 ++-- 3 files changed, 23 insertions(+), 6 deletions(-) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index aa05041dd..35c3dfb91 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -432,8 +432,8 @@ def convert_datediff( this=date2, expression=date1 ) - dow1: SQLGlotExpression = self.convert_dayofweek([args[1]], [types[1]]) - dow2: SQLGlotExpression = self.convert_dayofweek([args[2]], [types[2]]) + dow1: SQLGlotExpression = self.convert_dayofweek([date1], [types[1]]) + dow2: SQLGlotExpression = self.convert_dayofweek([date2], [types[2]]) division: SQLGlotExpression = sqlglot_expressions.Div( this=apply_parens( @@ -544,17 +544,24 @@ def apply_datetime_truncation( self, base: SQLGlotExpression, unit: DateTimeUnit ) -> SQLGlotExpression: match unit: + case DateTimeUnit.QUARTER: + return sqlglot_expressions.Anonymous( + this="TRUNC", + expressions=[ + self.make_datetime_arg(base), + sqlglot_expressions.Literal.string("Q"), + ], + ) case DateTimeUnit.HOUR | DateTimeUnit.MINUTE | DateTimeUnit.SECOND: return sqlglot_expressions.TimestampTrunc( this=self.make_datetime_arg(base), unit=sqlglot_expressions.Var(this=unit.value.lower()), ) case DateTimeUnit.WEEK: - result = sqlglot_expressions.DateTrunc( + return sqlglot_expressions.DateTrunc( this=self.make_datetime_arg(base), unit=sqlglot_expressions.Var(this="IW"), ) - return result case _: return sqlglot_expressions.DateTrunc( this=self.make_datetime_arg(base), diff --git a/tests/test_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json index 1ef0d10d9..553e6ff32 100644 --- a/tests/test_metadata/oracle_defog_graphs.json +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -1189,6 +1189,16 @@ "synonyms": ["purchase record", "vehicle sale", "car purchase"] } ], + "functions": [ + { + "name": "ADD_MONTHS", + "type": "sql macro", + "macro text": "ADD_MONTHS({0}, {1})", + "description": "Adds a number of months to a date value in oracle", + "input signature": {"type": "fixed arguments", "value": ["datetime", "numeric"]}, + "output signature": {"type": "constant", "value": "datetime"} + } + ], "additional definitions": [], "verified pydough analysis": [], "extra semantic info": {} diff --git a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql index 56a98e5c6..b803f23c8 100644 --- a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql @@ -8,11 +8,11 @@ WHERE ( CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(payment_date AS DATE) + ( MOD(( - TO_CHAR(payment_date, 'D') + 5 + TO_CHAR(CAST(payment_date AS DATE), 'D') + 5 ), 7) ) - ( MOD(( - TO_CHAR('now', 'D') + 5 + TO_CHAR(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE), 'D') + 5 ), 7) ) ) / 7 From 524fd30e7eba6a6d00ad7b302e427b90828bdec2 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 25 Feb 2026 14:46:37 -0600 Subject: [PATCH 19/48] dataframe and range collection support --- .../oracle_transform_bindings.py | 4 + ...rnative_quarter_cum_ir_analysis_oracle.sql | 16 +- .../dataframe_collection_best_oracle.sql | 23 +- ...ataframe_collection_correlation_oracle.sql | 27 +- .../dataframe_collection_cross_oracle.sql | 29 +- .../dataframe_collection_datatypes_oracle.sql | 14 +- ...frame_collection_highest_rating_oracle.sql | 69 +- .../dataframe_collection_inf_oracle.sql | 6 +- ...lection_language_highest_rating_oracle.sql | 70 +- .../dataframe_collection_numbers_oracle.sql | 12 +- .../dataframe_collection_partition_oracle.sql | 24 +- .../dataframe_collection_strings_oracle.sql | 6 +- ...rame_collection_taught_recently_oracle.sql | 68 +- ...aframe_collection_teacher_class_oracle.sql | 67 +- ...aframe_collection_teacher_count_oracle.sql | 113 +- ...ollection_teacher_lowest_rating_oracle.sql | 67 +- .../dataframe_collection_top_k_oracle.sql | 8 +- ...ame_collection_unique_partition_oracle.sql | 4 +- ...dataframe_collection_where_date_oracle.sql | 10 +- .../dataframe_collection_where_oracle.sql | 10 +- ...ame_collection_window_functions_oracle.sql | 4 +- .../datetime_functions_oracle.sql | 2 +- .../defog_dealership_adv13_oracle.sql | 8 +- .../defog_dealership_adv1_oracle.sql | 8 +- .../defog_dealership_adv8_oracle.sql | 8 +- .../defog_dealership_gen4_oracle.sql | 4 +- .../test_sql_refsols/double_cross_oracle.sql | 28 +- .../order_quarter_test_oracle.sql | 2 +- .../quarter_cum_ir_analysis_oracle.sql | 16 +- .../simple_dataframe_collection_1_oracle.sql | 4 +- .../simple_dataframe_collection_2_oracle.sql | 4 +- .../simple_dataframe_collection_3_oracle.sql | 8 +- .../simple_dataframe_collection_4_oracle.sql | 4 +- .../simple_range_1_oracle.sql | 2 +- .../simple_range_2_oracle.sql | 2 +- .../simple_range_3_oracle.sql | 2 +- .../simple_range_4_oracle.sql | 2 +- .../simple_range_6_oracle.sql | 4 +- .../simple_range_7_oracle.sql | 6 +- .../simple_range_8_oracle.sql | 10 +- .../simple_range_9_oracle.sql | 2 +- tests/test_sql_refsols/smoke_b_oracle.sql | 6 +- .../user_range_collection_1_oracle.sql | 4 +- .../user_range_collection_2_oracle.sql | 60 +- .../user_range_collection_3_oracle.sql | 1052 ++++++++--------- .../user_range_collection_4_oracle.sql | 8 +- .../user_range_collection_5_oracle.sql | 14 +- .../user_range_collection_6_oracle.sql | 4 +- 48 files changed, 913 insertions(+), 1012 deletions(-) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index 35c3dfb91..b99645939 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -36,6 +36,10 @@ def dialect_dow_mapping(self) -> dict[str, int]: "Saturday": 7, } + @property + def values_alias_column(self) -> bool: + return False + PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { pydop.ABS: "ABS", pydop.LARGEST: "GREATEST", diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql index 89314244d..e3a9a96a3 100644 --- a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -11,10 +11,10 @@ WITH "_S0" AS ( pr_name = 'RubyCopper-Star' ), "_S12" AS ( SELECT DISTINCT - TRUNC(CAST("_S0".CA_DT AS DATE), 'QUARTER') AS QUARTER + TRUNC(CAST(CAST("_S0".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER FROM "_S0" "_S0" JOIN "_T2" "_T2" - ON "_S0".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S0".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S0".CA_DT >= "_T2".PR_RELEASE ), "_T5" AS ( SELECT @@ -32,11 +32,11 @@ WITH "_S0" AS ( ON COUNTRIES.co_name = 'CN' ), "_S13" AS ( SELECT - TRUNC(CAST("_S2".CA_DT AS DATE), 'QUARTER') AS QUARTER, + TRUNC(CAST(CAST("_S2".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER, COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID FROM "_S0" "_S2" JOIN "_T2" "_T4" - ON "_S2".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S2".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S2".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.INCIDENTS INCIDENTS ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') @@ -45,21 +45,21 @@ WITH "_S0" AS ( JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = "_S9".PR_ID GROUP BY - TRUNC(CAST("_S2".CA_DT AS DATE), 'QUARTER') + TRUNC(CAST(CAST("_S2".CA_DT AS DATE) AS DATE), 'Q') ), "_S21" AS ( SELECT - TRUNC(CAST("_S14".CA_DT AS DATE), 'QUARTER') AS QUARTER, + TRUNC(CAST(CAST("_S14".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER, COUNT(*) AS N_ROWS FROM "_S0" "_S14" JOIN "_T2" "_T8" - ON "_S14".CA_DT < TRUNC(CAST("_T8".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S14".CA_DT < TRUNC(CAST("_T8".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S14".CA_DT >= "_T8".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') JOIN "_T5" "_T9" ON DEVICES.de_product_id = "_T9".PR_ID GROUP BY - TRUNC(CAST("_S14".CA_DT AS DATE), 'QUARTER') + TRUNC(CAST(CAST("_S14".CA_DT AS DATE) AS DATE), 'Q') ) SELECT "_S12".QUARTER AS quarter, diff --git a/tests/test_sql_refsols/dataframe_collection_best_oracle.sql b/tests/test_sql_refsols/dataframe_collection_best_oracle.sql index beef71d29..2d30185d8 100644 --- a/tests/test_sql_refsols/dataframe_collection_best_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_best_oracle.sql @@ -1,23 +1,18 @@ -WITH "_S1" AS ( - SELECT - COLUMN1 AS PRIORITY_LVL, - COLUMN2 AS TAX_RATE - FROM (VALUES - ('1-URGENT', 0.05), - ('2-HIGH', 0.04), - ('3-MEDIUM', 0.03), - ('4-NOT SPECIFIED', 0.02)) AS PRIORITY_TAXES(PRIORITY_LVL, TAX_RATE) -), "_T" AS ( +WITH "_T" AS ( SELECT ORDERS.o_custkey AS O_CUSTKEY, ORDERS.o_orderkey AS O_ORDERKEY, ORDERS.o_orderpriority AS O_ORDERPRIORITY, ORDERS.o_totalprice AS O_TOTALPRICE, - "_S1".TAX_RATE, - ROW_NUMBER() OVER (PARTITION BY ORDERS.o_orderkey ORDER BY ORDERS.o_totalprice + ORDERS.o_totalprice * "_S1".TAX_RATE) AS "_W" + PRIORITY_TAXES.TAX_RATE, + ROW_NUMBER() OVER (PARTITION BY ORDERS.o_orderkey ORDER BY ORDERS.o_totalprice + ORDERS.o_totalprice * PRIORITY_TAXES.TAX_RATE) AS "_W" FROM TPCH.ORDERS ORDERS - JOIN "_S1" "_S1" - ON ORDERS.o_orderpriority = "_S1".PRIORITY_LVL + JOIN (VALUES + ('1-URGENT', 0.05), + ('2-HIGH', 0.04), + ('3-MEDIUM', 0.03), + ('4-NOT SPECIFIED', 0.02)) AS PRIORITY_TAXES(PRIORITY_LVL, TAX_RATE) + ON ORDERS.o_orderpriority = PRIORITY_TAXES.PRIORITY_LVL ) SELECT CUSTOMER.c_name AS name, diff --git a/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql b/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql index bbef47879..b4e64d2f6 100644 --- a/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql @@ -1,31 +1,26 @@ -WITH "_S1" AS ( +WITH "_S3" AS ( SELECT - COLUMN1 AS KEY, - COLUMN3 AS LANGUAGE + CLASSES_2.KEY, + COUNT(*) AS N_ROWS FROM (VALUES (15112, 'Programming Fundamentals', 'Python'), (15122, 'Imperative Programming', 'C'), (15150, 'Functional Programming', 'SML'), (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES_3(KEY, CLASS_NAME, LANGUAGE) -), "_S3" AS ( - SELECT - COLUMN1 AS KEY, - COUNT(*) AS N_ROWS - FROM (VALUES + (15251, 'Theoretical CS', NULL)) AS CLASSES_2(KEY, CLASS_NAME, LANGUAGE) + JOIN (VALUES (15112, 'Programming Fundamentals', 'Python'), (15122, 'Imperative Programming', 'C'), (15150, 'Functional Programming', 'SML'), (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES_2(KEY, CLASS_NAME, LANGUAGE) - JOIN "_S1" "_S1" - ON COLUMN1 <> "_S1".KEY AND COLUMN3 = "_S1".LANGUAGE + (15251, 'Theoretical CS', NULL)) AS CLASSES_3(KEY, CLASS_NAME, LANGUAGE) + ON CLASSES_2.KEY <> CLASSES_3.KEY AND CLASSES_2.LANGUAGE = CLASSES_3.LANGUAGE GROUP BY - COLUMN1 + CLASSES_2.KEY ) SELECT - COLUMN2 AS class_name, - COLUMN3 AS language, + CLASSES.CLASS_NAME AS class_name, + CLASSES.LANGUAGE AS language, COALESCE("_S3".N_ROWS, 0) AS n_other_classes FROM (VALUES (15112, 'Programming Fundamentals', 'Python'), @@ -34,4 +29,4 @@ FROM (VALUES (15210, 'Parallel Algorithms', 'SML'), (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) LEFT JOIN "_S3" "_S3" - ON COLUMN1 = "_S3".KEY + ON CLASSES.KEY = "_S3".KEY diff --git a/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql b/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql index 2694a42ce..15098b5ca 100644 --- a/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql @@ -1,25 +1,18 @@ -WITH "_S1" AS ( - SELECT - COLUMN1 AS ORDER_ID, - COLUMN2 AS USER_ID, - COLUMN3 AS AMOUNT - FROM (VALUES - (101.0, 1.0, 250.0), - (102.0, 2.0, 150.5), - (103.0, 1.0, 300.0), - (104.0, 3.0, 450.75), - (105.0, 2.0, 200.0)) AS ORDERS(ORDER_ID, USER_ID, AMOUNT) -) SELECT - COLUMN1 AS id1, - COLUMN2 AS name1, - "_S1".ORDER_ID AS order_id, - "_S1".AMOUNT AS amount + USERS.ID_ AS id1, + USERS.NAME AS name1, + ORDERS.ORDER_ID AS order_id, + ORDERS.AMOUNT AS amount FROM (VALUES (1, 'John'), (2, 'Jane'), (3, 'Bob'), (4, 'Alice'), (5, 'Charlie')) AS USERS(ID_, NAME) -JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".USER_ID +JOIN (VALUES + (101.0, 1.0, 250.0), + (102.0, 2.0, 150.5), + (103.0, 1.0, 300.0), + (104.0, 3.0, 450.75), + (105.0, 2.0, 200.0)) AS ORDERS(ORDER_ID, USER_ID, AMOUNT) + ON ORDERS.USER_ID = USERS.ID_ diff --git a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql index 24ff057ff..c8150fb30 100644 --- a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql @@ -1,11 +1,11 @@ SELECT - COLUMN1 AS string_col, - COLUMN2 AS int_col, - COLUMN3 AS float_col, - COLUMN4 AS nullable_int_col, - COLUMN5 AS bool_col, - COLUMN6 AS null_col, - COLUMN7 AS datetime_col + ALLDATATYPES.STRING_COL AS string_col, + ALLDATATYPES.INT_COL AS int_col, + ALLDATATYPES.FLOAT_COL AS float_col, + ALLDATATYPES.NULLABLE_INT_COL AS nullable_int_col, + ALLDATATYPES.BOOL_COL AS bool_col, + ALLDATATYPES.NULL_COL AS null_col, + ALLDATATYPES.DATETIME_COL AS datetime_col FROM (VALUES ('red', 0, 1.5, 1.0, 1, NULL, CAST('2024-01-01 00:00:00' AS TIMESTAMP)), ('orange', 1, 2.0, NULL, 0, NULL, CAST('2024-01-02 00:00:00' AS TIMESTAMP)), diff --git a/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql index 87006fcb2..dff8e9f86 100644 --- a/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql @@ -1,10 +1,16 @@ -WITH "_S1" AS ( +WITH "_T" AS ( SELECT - COLUMN1 AS CLASS_KEY, - COLUMN2 AS TEACHER_ID, - COLUMN3 AS SEMESTER, - COLUMN4 AS RATING + CLASSES.CLASS_NAME, + TEACHING.SEMESTER, + TEACHING.TEACHER_ID, + ROW_NUMBER() OVER (PARTITION BY CLASSES.KEY ORDER BY TEACHING.RATING DESC) AS "_W" FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + JOIN (VALUES (15112, 1, '2020-09-01', 11.39), (15122, 2, '2020-09-01', 9.22), (15150, 9, '2020-09-01', 11.93), @@ -35,46 +41,27 @@ WITH "_S1" AS ( (15150, 4, '2023-02-01', 9.73), (15210, 5, '2023-02-01', 0.12), (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -), "_T" AS ( - SELECT - COLUMN2 AS CLASS_NAME, - "_S1".SEMESTER, - "_S1".TEACHER_ID, - ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".RATING DESC) AS "_W" - FROM (VALUES - (15112, 'Programming Fundamentals', 'Python'), - (15122, 'Imperative Programming', 'C'), - (15150, 'Functional Programming', 'SML'), - (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) - JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".CLASS_KEY -), "_S3" AS ( - SELECT - COLUMN1 AS TID, - COLUMN2 AS FIRST_NAME, - COLUMN3 AS LAST_NAME - FROM (VALUES - (1, 'Anil', 'Lee'), - (2, 'Mike', 'Lee'), - (3, 'Ian', 'Lee'), - (4, 'David', 'Smith'), - (5, 'Anil', 'Smith'), - (6, 'Mike', 'Smith'), - (7, 'Ian', 'Taylor'), - (8, 'David', 'Taylor'), - (9, 'Anil', 'Taylor'), - (10, 'Mike', 'Thomas'), - (11, 'Ian', 'Thomas'), - (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + ON CLASSES.KEY = TEACHING.CLASS_KEY ) SELECT "_T".CLASS_NAME AS class_name, "_T".SEMESTER AS last_semester, - "_S3".FIRST_NAME AS teacher_first_name, - "_S3".LAST_NAME AS teacher_last_name + TEACHERS.FIRST_NAME AS teacher_first_name, + TEACHERS.LAST_NAME AS teacher_last_name FROM "_T" "_T" -LEFT JOIN "_S3" "_S3" - ON "_S3".TID = "_T".TEACHER_ID +LEFT JOIN (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + ON TEACHERS.TID = "_T".TEACHER_ID WHERE "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql index 827741260..cd7c5e567 100644 --- a/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql @@ -1,7 +1,7 @@ SELECT - COLUMN1 AS py_float, - COLUMN2 AS np_float64, - COLUMN3 AS np_float32 + INFINTY.PY_FLOAT AS py_float, + INFINTY.NP_FLOAT64 AS np_float64, + INFINTY.NP_FLOAT32 AS np_float32 FROM (VALUES (1.5, -2.25, 0.0), (NULL, NULL, NULL), diff --git a/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql index 690dee3d8..d1cd23c7d 100644 --- a/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql @@ -1,9 +1,16 @@ -WITH "_S1" AS ( +WITH "_T" AS ( SELECT - COLUMN1 AS CLASS_KEY, - COLUMN2 AS TEACHER_ID, - COLUMN4 AS RATING + CLASSES.LANGUAGE, + TEACHING.RATING, + TEACHING.TEACHER_ID, + ROW_NUMBER() OVER (PARTITION BY CLASSES.LANGUAGE ORDER BY TEACHING.RATING DESC) AS "_W" FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + JOIN (VALUES (15112, 1, '2020-09-01', 11.39), (15122, 2, '2020-09-01', 9.22), (15150, 9, '2020-09-01', 11.93), @@ -34,48 +41,29 @@ WITH "_S1" AS ( (15150, 4, '2023-02-01', 9.73), (15210, 5, '2023-02-01', 0.12), (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -), "_T" AS ( - SELECT - COLUMN3 AS LANGUAGE, - "_S1".RATING, - "_S1".TEACHER_ID, - ROW_NUMBER() OVER (PARTITION BY COLUMN3 ORDER BY "_S1".RATING DESC) AS "_W" - FROM (VALUES - (15112, 'Programming Fundamentals', 'Python'), - (15122, 'Imperative Programming', 'C'), - (15150, 'Functional Programming', 'SML'), - (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) - JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".CLASS_KEY + ON CLASSES.KEY = TEACHING.CLASS_KEY WHERE - NOT COLUMN3 IS NULL -), "_S3" AS ( - SELECT - COLUMN1 AS TID, - COLUMN2 AS FIRST_NAME, - COLUMN3 AS LAST_NAME - FROM (VALUES - (1, 'Anil', 'Lee'), - (2, 'Mike', 'Lee'), - (3, 'Ian', 'Lee'), - (4, 'David', 'Smith'), - (5, 'Anil', 'Smith'), - (6, 'Mike', 'Smith'), - (7, 'Ian', 'Taylor'), - (8, 'David', 'Taylor'), - (9, 'Anil', 'Taylor'), - (10, 'Mike', 'Thomas'), - (11, 'Ian', 'Thomas'), - (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + NOT CLASSES.LANGUAGE IS NULL ) SELECT "_T".LANGUAGE AS language, "_T".RATING AS rating, - "_S3".FIRST_NAME AS first_name, - "_S3".LAST_NAME AS last_name + TEACHERS.FIRST_NAME AS first_name, + TEACHERS.LAST_NAME AS last_name FROM "_T" "_T" -LEFT JOIN "_S3" "_S3" - ON "_S3".TID = "_T".TEACHER_ID +LEFT JOIN (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + ON TEACHERS.TID = "_T".TEACHER_ID WHERE "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql b/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql index 050a09f92..2353d7392 100644 --- a/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql @@ -1,10 +1,10 @@ SELECT - COLUMN1 AS pyd_numbers, - COLUMN2 AS py_float, - COLUMN3 AS np_float64, - COLUMN4 AS np_float32, - COLUMN5 AS null_vs_nan, - COLUMN6 AS decimal_val + NUMBERS.PYD_NUMBERS AS pyd_numbers, + NUMBERS.PY_FLOAT AS py_float, + NUMBERS.NP_FLOAT64 AS np_float64, + NUMBERS.NP_FLOAT32 AS np_float32, + NUMBERS.NULL_VS_NAN AS null_vs_nan, + NUMBERS.DECIMAL_VAL AS decimal_val FROM (VALUES (10.0, 1.5, 1.5, 1.5, NULL, 1.50), (-3.0, 0.0, 0.0, 3.33333, NULL, 0.00), diff --git a/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql b/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql index 2a3437ef6..002e1d29c 100644 --- a/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql @@ -1,23 +1,17 @@ -WITH "_S1" AS ( - SELECT - COLUMN2 AS RULE_CATEGORY, - COLUMN3 AS DISCOUNT - FROM (VALUES - (1, 'A', 0.1), - (2, 'B', 0.15), - (3, 'C', 0.05)) AS PRICING_COLLECTION(RULE_ID, RULE_CATEGORY, DISCOUNT) -) SELECT - COLUMN2 AS product_category, - AVG(COLUMN3) AS avg_price, + PRODUCTS_COLLECTION.PRODUCT_CATEGORY AS product_category, + AVG(PRODUCTS_COLLECTION.PRICE) AS avg_price, COUNT(*) AS n_products, - MIN("_S1".DISCOUNT) AS min_discount + MIN(PRICING_COLLECTION.DISCOUNT) AS min_discount FROM (VALUES (1, 'A', 17.99), (2, 'B', 45.65), (3, 'A', 15.0), (4, 'B', 10.99)) AS PRODUCTS_COLLECTION(PRODUCT_ID, PRODUCT_CATEGORY, PRICE) -JOIN "_S1" "_S1" - ON COLUMN2 = "_S1".RULE_CATEGORY +JOIN (VALUES + (1, 'A', 0.1), + (2, 'B', 0.15), + (3, 'C', 0.05)) AS PRICING_COLLECTION(RULE_ID, RULE_CATEGORY, DISCOUNT) + ON PRICING_COLLECTION.RULE_CATEGORY = PRODUCTS_COLLECTION.PRODUCT_CATEGORY GROUP BY - COLUMN2 + PRODUCTS_COLLECTION.PRODUCT_CATEGORY diff --git a/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql b/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql index 7212c0271..1f22b9459 100644 --- a/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql @@ -1,7 +1,7 @@ SELECT - COLUMN1 AS normal_strings, - COLUMN2 AS empty_string, - COLUMN3 AS special_characters + STRINGS.NORMAL_STRINGS AS normal_strings, + STRINGS.EMPTY_STRING AS empty_string, + STRINGS.SPECIAL_CHARACTERS AS special_characters FROM (VALUES ('hello', '', '''simple quoted'''), ('world', 'not_empty', '"double quoted"'), diff --git a/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql b/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql index 2d0c8e09a..bc4dff024 100644 --- a/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql @@ -1,9 +1,16 @@ -WITH "_S1" AS ( +WITH "_T" AS ( SELECT - COLUMN1 AS CLASS_KEY, - COLUMN2 AS TEACHER_ID, - COLUMN3 AS SEMESTER + CLASSES.CLASS_NAME, + TEACHING.SEMESTER, + TEACHING.TEACHER_ID, + ROW_NUMBER() OVER (PARTITION BY CLASSES.KEY ORDER BY TEACHING.SEMESTER DESC) AS "_W" FROM (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + JOIN (VALUES (15112, 1, '2020-09-01', 11.39), (15122, 2, '2020-09-01', 9.22), (15150, 9, '2020-09-01', 11.93), @@ -34,46 +41,27 @@ WITH "_S1" AS ( (15150, 4, '2023-02-01', 9.73), (15210, 5, '2023-02-01', 0.12), (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -), "_T" AS ( - SELECT - COLUMN2 AS CLASS_NAME, - "_S1".SEMESTER, - "_S1".TEACHER_ID, - ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".SEMESTER DESC) AS "_W" - FROM (VALUES - (15112, 'Programming Fundamentals', 'Python'), - (15122, 'Imperative Programming', 'C'), - (15150, 'Functional Programming', 'SML'), - (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) - JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".CLASS_KEY -), "_S3" AS ( - SELECT - COLUMN1 AS TID, - COLUMN2 AS FIRST_NAME, - COLUMN3 AS LAST_NAME - FROM (VALUES - (1, 'Anil', 'Lee'), - (2, 'Mike', 'Lee'), - (3, 'Ian', 'Lee'), - (4, 'David', 'Smith'), - (5, 'Anil', 'Smith'), - (6, 'Mike', 'Smith'), - (7, 'Ian', 'Taylor'), - (8, 'David', 'Taylor'), - (9, 'Anil', 'Taylor'), - (10, 'Mike', 'Thomas'), - (11, 'Ian', 'Thomas'), - (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + ON CLASSES.KEY = TEACHING.CLASS_KEY ) SELECT "_T".CLASS_NAME AS class_name, "_T".SEMESTER AS last_semester, - "_S3".FIRST_NAME AS teacher_first_name, - "_S3".LAST_NAME AS teacher_last_name + TEACHERS.FIRST_NAME AS teacher_first_name, + TEACHERS.LAST_NAME AS teacher_last_name FROM "_T" "_T" -LEFT JOIN "_S3" "_S3" - ON "_S3".TID = "_T".TEACHER_ID +LEFT JOIN (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + ON TEACHERS.TID = "_T".TEACHER_ID WHERE "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql b/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql index 50f5cd37c..853bb3534 100644 --- a/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql @@ -1,9 +1,24 @@ -WITH "_S1" AS ( +WITH "_T" AS ( SELECT - COLUMN1 AS CLASS_KEY, - COLUMN2 AS TEACHER_ID, - COLUMN3 AS SEMESTER + TEACHING.CLASS_KEY, + TEACHERS.FIRST_NAME, + TEACHERS.LAST_NAME, + TEACHING.SEMESTER, + ROW_NUMBER() OVER (PARTITION BY TEACHERS.TID ORDER BY TEACHING.SEMESTER DESC) AS "_W" FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + JOIN (VALUES (15112, 1, '2020-09-01', 11.39), (15122, 2, '2020-09-01', 9.22), (15150, 9, '2020-09-01', 11.93), @@ -34,46 +49,20 @@ WITH "_S1" AS ( (15150, 4, '2023-02-01', 9.73), (15210, 5, '2023-02-01', 0.12), (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -), "_T" AS ( - SELECT - "_S1".CLASS_KEY, - COLUMN2 AS FIRST_NAME, - COLUMN3 AS LAST_NAME, - "_S1".SEMESTER, - ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".SEMESTER DESC) AS "_W" - FROM (VALUES - (1, 'Anil', 'Lee'), - (2, 'Mike', 'Lee'), - (3, 'Ian', 'Lee'), - (4, 'David', 'Smith'), - (5, 'Anil', 'Smith'), - (6, 'Mike', 'Smith'), - (7, 'Ian', 'Taylor'), - (8, 'David', 'Taylor'), - (9, 'Anil', 'Taylor'), - (10, 'Mike', 'Thomas'), - (11, 'Ian', 'Thomas'), - (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) - JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".TEACHER_ID -), "_S3" AS ( - SELECT - COLUMN1 AS KEY, - COLUMN2 AS CLASS_NAME - FROM (VALUES - (15112, 'Programming Fundamentals', 'Python'), - (15122, 'Imperative Programming', 'C'), - (15150, 'Functional Programming', 'SML'), - (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + ON TEACHERS.TID = TEACHING.TEACHER_ID ) SELECT "_T".FIRST_NAME AS first_name, "_T".LAST_NAME AS last_name, "_T".SEMESTER AS recent_semester, - "_S3".CLASS_NAME AS class_name + CLASSES.CLASS_NAME AS class_name FROM "_T" "_T" -LEFT JOIN "_S3" "_S3" - ON "_S3".KEY = "_T".CLASS_KEY +LEFT JOIN (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + ON CLASSES.KEY = "_T".CLASS_KEY WHERE "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql b/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql index 74dadfe56..019dc8055 100644 --- a/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql @@ -1,60 +1,6 @@ -WITH "_S1" AS ( - SELECT - COLUMN1 AS CLASS_KEY, - COLUMN2 AS TEACHER_ID - FROM (VALUES - (15112, 1, '2020-09-01', 11.39), - (15122, 2, '2020-09-01', 9.22), - (15150, 9, '2020-09-01', 11.93), - (15210, 4, '2020-09-01', 0.32), - (15251, 5, '2020-09-01', 3.19), - (15112, 6, '2021-02-01', 1.35), - (15122, 1, '2021-02-01', 11.58), - (15150, 8, '2021-02-01', 2.69), - (15210, 9, '2021-02-01', 3.48), - (15251, 10, '2021-02-01', 6.75), - (15112, 5, '2021-09-01', 5.31), - (15122, 12, '2021-09-01', 3.94), - (15150, 1, '2021-09-01', 7.45), - (15210, 2, '2021-09-01', 8.64), - (15251, 9, '2021-09-01', 0.31), - (15112, 4, '2022-02-01', 11.27), - (15122, 5, '2022-02-01', 10.3), - (15150, 6, '2022-02-01', 2.21), - (15210, 1, '2022-02-01', 3.8), - (15251, 8, '2022-02-01', 7.87), - (15112, 9, '2022-09-01', 7.23), - (15122, 10, '2022-09-01', 6.66), - (15150, 5, '2022-09-01', 10.97), - (15210, 12, '2022-09-01', 0.96), - (15251, 1, '2022-09-01', 5.43), - (15112, 2, '2023-02-01', 5.19), - (15122, 9, '2023-02-01', 5.02), - (15150, 4, '2023-02-01', 9.73), - (15210, 5, '2023-02-01', 0.12), - (15251, 6, '2023-02-01', 4.99)) AS TEACHING_2(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -), "_S3" AS ( - SELECT - COLUMN1 AS TID, - COLUMN2 AS FIRST_NAME, - COLUMN3 AS LAST_NAME - FROM (VALUES - (1, 'Anil', 'Lee'), - (2, 'Mike', 'Lee'), - (3, 'Ian', 'Lee'), - (4, 'David', 'Smith'), - (5, 'Anil', 'Smith'), - (6, 'Mike', 'Smith'), - (7, 'Ian', 'Taylor'), - (8, 'David', 'Taylor'), - (9, 'Anil', 'Taylor'), - (10, 'Mike', 'Thomas'), - (11, 'Ian', 'Thomas'), - (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) -) SELECT - "_S3".FIRST_NAME AS first_name, - "_S3".LAST_NAME AS last_name, + TEACHERS.FIRST_NAME AS first_name, + TEACHERS.LAST_NAME AS last_name, COUNT(*) AS n_teachers FROM (VALUES (15112, 1, '2020-09-01', 11.39), @@ -87,10 +33,53 @@ FROM (VALUES (15150, 4, '2023-02-01', 9.73), (15210, 5, '2023-02-01', 0.12), (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".CLASS_KEY AND COLUMN2 <> "_S1".TEACHER_ID -JOIN "_S3" "_S3" - ON COLUMN2 = "_S3".TID +JOIN (VALUES + (15112, 1, '2020-09-01', 11.39), + (15122, 2, '2020-09-01', 9.22), + (15150, 9, '2020-09-01', 11.93), + (15210, 4, '2020-09-01', 0.32), + (15251, 5, '2020-09-01', 3.19), + (15112, 6, '2021-02-01', 1.35), + (15122, 1, '2021-02-01', 11.58), + (15150, 8, '2021-02-01', 2.69), + (15210, 9, '2021-02-01', 3.48), + (15251, 10, '2021-02-01', 6.75), + (15112, 5, '2021-09-01', 5.31), + (15122, 12, '2021-09-01', 3.94), + (15150, 1, '2021-09-01', 7.45), + (15210, 2, '2021-09-01', 8.64), + (15251, 9, '2021-09-01', 0.31), + (15112, 4, '2022-02-01', 11.27), + (15122, 5, '2022-02-01', 10.3), + (15150, 6, '2022-02-01', 2.21), + (15210, 1, '2022-02-01', 3.8), + (15251, 8, '2022-02-01', 7.87), + (15112, 9, '2022-09-01', 7.23), + (15122, 10, '2022-09-01', 6.66), + (15150, 5, '2022-09-01', 10.97), + (15210, 12, '2022-09-01', 0.96), + (15251, 1, '2022-09-01', 5.43), + (15112, 2, '2023-02-01', 5.19), + (15122, 9, '2023-02-01', 5.02), + (15150, 4, '2023-02-01', 9.73), + (15210, 5, '2023-02-01', 0.12), + (15251, 6, '2023-02-01', 4.99)) AS TEACHING_2(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) + ON TEACHING.CLASS_KEY = TEACHING_2.CLASS_KEY + AND TEACHING.TEACHER_ID <> TEACHING_2.TEACHER_ID +JOIN (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + ON TEACHERS.TID = TEACHING.TEACHER_ID GROUP BY - "_S3".FIRST_NAME, - "_S3".LAST_NAME + TEACHERS.FIRST_NAME, + TEACHERS.LAST_NAME diff --git a/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql index e3023ff6b..c8e6322d8 100644 --- a/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql @@ -1,9 +1,24 @@ -WITH "_S1" AS ( +WITH "_T" AS ( SELECT - COLUMN1 AS CLASS_KEY, - COLUMN2 AS TEACHER_ID, - COLUMN4 AS RATING + TEACHING.CLASS_KEY, + TEACHERS.FIRST_NAME, + TEACHERS.LAST_NAME, + TEACHING.RATING, + ROW_NUMBER() OVER (PARTITION BY TEACHERS.TID ORDER BY TEACHING.RATING DESC) AS "_W" FROM (VALUES + (1, 'Anil', 'Lee'), + (2, 'Mike', 'Lee'), + (3, 'Ian', 'Lee'), + (4, 'David', 'Smith'), + (5, 'Anil', 'Smith'), + (6, 'Mike', 'Smith'), + (7, 'Ian', 'Taylor'), + (8, 'David', 'Taylor'), + (9, 'Anil', 'Taylor'), + (10, 'Mike', 'Thomas'), + (11, 'Ian', 'Thomas'), + (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) + JOIN (VALUES (15112, 1, '2020-09-01', 11.39), (15122, 2, '2020-09-01', 9.22), (15150, 9, '2020-09-01', 11.93), @@ -34,46 +49,20 @@ WITH "_S1" AS ( (15150, 4, '2023-02-01', 9.73), (15210, 5, '2023-02-01', 0.12), (15251, 6, '2023-02-01', 4.99)) AS TEACHING(CLASS_KEY, TEACHER_ID, SEMESTER, RATING) -), "_T" AS ( - SELECT - "_S1".CLASS_KEY, - COLUMN2 AS FIRST_NAME, - COLUMN3 AS LAST_NAME, - "_S1".RATING, - ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY "_S1".RATING DESC) AS "_W" - FROM (VALUES - (1, 'Anil', 'Lee'), - (2, 'Mike', 'Lee'), - (3, 'Ian', 'Lee'), - (4, 'David', 'Smith'), - (5, 'Anil', 'Smith'), - (6, 'Mike', 'Smith'), - (7, 'Ian', 'Taylor'), - (8, 'David', 'Taylor'), - (9, 'Anil', 'Taylor'), - (10, 'Mike', 'Thomas'), - (11, 'Ian', 'Thomas'), - (12, 'David', 'Thomas')) AS TEACHERS(TID, FIRST_NAME, LAST_NAME) - JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".TEACHER_ID -), "_S3" AS ( - SELECT - COLUMN1 AS KEY, - COLUMN2 AS CLASS_NAME - FROM (VALUES - (15112, 'Programming Fundamentals', 'Python'), - (15122, 'Imperative Programming', 'C'), - (15150, 'Functional Programming', 'SML'), - (15210, 'Parallel Algorithms', 'SML'), - (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + ON TEACHERS.TID = TEACHING.TEACHER_ID ) SELECT "_T".FIRST_NAME AS first_name, "_T".LAST_NAME AS last_name, "_T".RATING AS rating, - "_S3".CLASS_NAME AS class_name + CLASSES.CLASS_NAME AS class_name FROM "_T" "_T" -LEFT JOIN "_S3" "_S3" - ON "_S3".KEY = "_T".CLASS_KEY +LEFT JOIN (VALUES + (15112, 'Programming Fundamentals', 'Python'), + (15122, 'Imperative Programming', 'C'), + (15150, 'Functional Programming', 'SML'), + (15210, 'Parallel Algorithms', 'SML'), + (15251, 'Theoretical CS', NULL)) AS CLASSES(KEY, CLASS_NAME, LANGUAGE) + ON CLASSES.KEY = "_T".CLASS_KEY WHERE "_T"."_W" = 1 diff --git a/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql b/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql index 0573a6efc..f84af103a 100644 --- a/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql @@ -1,11 +1,11 @@ SELECT PART.p_name AS name, - COLUMN1 AS shipping_type, + DISCOUNTS.SHIPPING_TYPE AS shipping_type, LINEITEM.l_extendedprice AS extended_price, - LINEITEM.l_discount + COLUMN2 AS added_discount, + LINEITEM.l_discount + DISCOUNTS.ADDED_DISCOUNT AS added_discount, LINEITEM.l_extendedprice * ( 1 - ( - LINEITEM.l_discount + COLUMN2 + LINEITEM.l_discount + DISCOUNTS.ADDED_DISCOUNT ) ) AS final_price FROM (VALUES @@ -13,7 +13,7 @@ FROM (VALUES ('SHIP', 0.06), ('TRUCK', 0.05)) AS DISCOUNTS(SHIPPING_TYPE, ADDED_DISCOUNT) JOIN TPCH.LINEITEM LINEITEM - ON COLUMN1 = LINEITEM.l_shipmode + ON DISCOUNTS.SHIPPING_TYPE = LINEITEM.l_shipmode JOIN TPCH.PART PART ON LINEITEM.l_partkey = PART.p_partkey ORDER BY diff --git a/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql b/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql index 88fcbb2f9..cf50e68d9 100644 --- a/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql @@ -1,6 +1,6 @@ SELECT DISTINCT - COLUMN2 AS first_name, - COLUMN3 AS last_name + TEACHERS.FIRST_NAME AS first_name, + TEACHERS.LAST_NAME AS last_name FROM (VALUES (1, 'Anil', 'Lee'), (2, 'Mike', 'Lee'), diff --git a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql index 5b6a137cd..92abede51 100644 --- a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql @@ -1,5 +1,5 @@ SELECT - COLUMN1 AS clerk_id, + DATES.CLERK_ID AS clerk_id, COUNT(*) AS n_orders FROM (VALUES ( @@ -18,8 +18,8 @@ FROM (VALUES CAST('1995-12-01 00:00:00' AS TIMESTAMP) )) AS DATES(CLERK_ID, START_DATE, END_DATE) JOIN TPCH.ORDERS ORDERS - ON COLUMN1 = ORDERS.o_clerk - AND COLUMN2 <= CAST(ORDERS.o_orderdate AS DATE) - AND COLUMN3 >= CAST(ORDERS.o_orderdate AS DATE) + ON DATES.CLERK_ID = ORDERS.o_clerk + AND DATES.END_DATE >= CAST(ORDERS.o_orderdate AS DATE) + AND DATES.START_DATE <= CAST(ORDERS.o_orderdate AS DATE) GROUP BY - COLUMN1 + DATES.CLERK_ID diff --git a/tests/test_sql_refsols/dataframe_collection_where_oracle.sql b/tests/test_sql_refsols/dataframe_collection_where_oracle.sql index 5e6f6b8a6..cdcc58444 100644 --- a/tests/test_sql_refsols/dataframe_collection_where_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_where_oracle.sql @@ -30,9 +30,10 @@ WITH "_S1" AS ( ('EUROPE', 6400.5), ('MIDDLE EAST', 8999.99)) AS THRESHOLDS_COLLECTION(REGION_NAME, MIN_ACCOUNT_BALANCE) JOIN "_S1" "_S1" - ON COLUMN2 < "_S1".S_ACCTBAL + ON THRESHOLDS_COLLECTION.MIN_ACCOUNT_BALANCE < "_S1".S_ACCTBAL JOIN "_S5" "_S5" - ON COLUMN1 = "_S5".R_NAME AND "_S1".S_NATIONKEY = "_S5".N_NATIONKEY + ON THRESHOLDS_COLLECTION.REGION_NAME = "_S5".R_NAME + AND "_S1".S_NATIONKEY = "_S5".N_NATIONKEY ), "_S11" AS ( SELECT "_S8".N_NATIONKEY, @@ -51,9 +52,10 @@ WITH "_S1" AS ( ('EUROPE', 6400.5), ('MIDDLE EAST', 8999.99)) AS THRESHOLDS_COLLECTION_2(REGION_NAME, MIN_ACCOUNT_BALANCE) JOIN "_S1" "_S7" - ON COLUMN2 < "_S7".S_ACCTBAL + ON THRESHOLDS_COLLECTION_2.MIN_ACCOUNT_BALANCE < "_S7".S_ACCTBAL JOIN "_S11" "_S11" - ON COLUMN1 = "_S11".R_NAME AND "_S11".N_NATIONKEY = "_S7".S_NATIONKEY + ON THRESHOLDS_COLLECTION_2.REGION_NAME = "_S11".R_NAME + AND "_S11".N_NATIONKEY = "_S7".S_NATIONKEY GROUP BY "_S11".R_NAME ) diff --git a/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql b/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql index 6458bb312..a83a2a08a 100644 --- a/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_window_functions_oracle.sql @@ -4,9 +4,9 @@ WITH "_T" AS ( CUSTOMER.c_custkey AS C_CUSTKEY, CUSTOMER.c_mktsegment AS C_MKTSEGMENT, CUSTOMER.c_name AS C_NAME, - COLUMN2 AS MRK_SEGMENT, + CUSTOMERS_FILTERS.MRK_SEGMENT, NATION.n_name AS N_NAME, - COLUMN1 AS NATION_NAME, + CUSTOMERS_FILTERS.NATION_NAME, NTILE(1000) OVER (ORDER BY CUSTOMER.c_acctbal) AS "_W" FROM (VALUES ('UNITED STATES', 'BUILDING'), diff --git a/tests/test_sql_refsols/datetime_functions_oracle.sql b/tests/test_sql_refsols/datetime_functions_oracle.sql index d1b86796d..64315869c 100644 --- a/tests/test_sql_refsols/datetime_functions_oracle.sql +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -28,7 +28,7 @@ SELECT ( TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS') - CAST('1992-01-01' AS DATE) + ( MOD(( - TO_CHAR('1992-01-01', 'D') + -1 + TO_CHAR(CAST('1992-01-01' AS DATE), 'D') + -1 ), 7) ) - ( MOD( diff --git a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql index 0a056a4d5..44c18d2a0 100644 --- a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql @@ -7,8 +7,8 @@ WITH "_S1" AS ( TRUNC(CAST(payment_date AS DATE), 'MONTH') ), "_T0" AS ( SELECT - DATETIME("_S1".START_MONTH, COLUMN1 || ' months') AS DT, - SUM(CASE WHEN COLUMN1 > 0 THEN 0 ELSE COALESCE("_S1".SUM_PAYMENT_AMOUNT, 0) END) AS SUM_PAYMENT + DATETIME("_S1".START_MONTH, MONTHS.N || ' months') AS DT, + SUM(CASE WHEN MONTHS.N > 0 THEN 0 ELSE COALESCE("_S1".SUM_PAYMENT_AMOUNT, 0) END) AS SUM_PAYMENT FROM (VALUES (0), (1), @@ -25,9 +25,9 @@ WITH "_S1" AS ( JOIN "_S1" "_S1" ON ( TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(1, 'hour') - ) >= DATETIME("_S1".START_MONTH, COLUMN1 || ' months') + ) >= DATETIME("_S1".START_MONTH, MONTHS.N || ' months') GROUP BY - DATETIME("_S1".START_MONTH, COLUMN1 || ' months') + DATETIME("_S1".START_MONTH, MONTHS.N || ' months') ) SELECT DT AS dt, diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql index 574f6dcbb..2483079b0 100644 --- a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -19,11 +19,11 @@ WHERE ( CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(PAYMENTS_RECEIVED.payment_date AS DATE) + ( MOD(( - TO_CHAR(PAYMENTS_RECEIVED.payment_date, 'D') + 5 + TO_CHAR(CAST(PAYMENTS_RECEIVED.payment_date AS DATE), 'D') + 5 ), 7) ) - ( MOD(( - TO_CHAR('now', 'D') + 5 + TO_CHAR(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE), 'D') + 5 ), 7) ) ) / 7 @@ -32,11 +32,11 @@ WHERE ( CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(PAYMENTS_RECEIVED.payment_date AS DATE) + ( MOD(( - TO_CHAR(PAYMENTS_RECEIVED.payment_date, 'D') + 5 + TO_CHAR(CAST(PAYMENTS_RECEIVED.payment_date AS DATE), 'D') + 5 ), 7) ) - ( MOD(( - TO_CHAR('now', 'D') + 5 + TO_CHAR(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE), 'D') + 5 ), 7) ) ) / 7 diff --git a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql index 646e049f7..9cc04cf97 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql @@ -1,6 +1,6 @@ WITH "_S6" AS ( SELECT DISTINCT - COLUMN1 AS MONTH_START + MONTHS_RANGE.MONTH_START FROM (VALUES (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), @@ -11,7 +11,7 @@ WITH "_S6" AS ( CROSS JOIN MAIN.SALES SALES ), "_S7" AS ( SELECT - COLUMN1 AS MONTH_START, + MONTHS_RANGE_2.MONTH_START, COUNT(*) AS N_ROWS, SUM(SALES.sale_price) AS SUM_SALE_PRICE FROM (VALUES @@ -22,13 +22,13 @@ WITH "_S6" AS ( (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS MONTHS_RANGE_2(MONTH_START) JOIN MAIN.SALES SALES - ON TO_CHAR(COLUMN1, '%Y-%m') = TO_CHAR(SALES.sale_date, '%Y-%m') + ON TO_CHAR(MONTHS_RANGE_2.MONTH_START, '%Y-%m') = TO_CHAR(SALES.sale_date, '%Y-%m') JOIN MAIN.SALESPERSONS SALESPERSONS ON EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) <= 2023 AND EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) >= 2022 AND SALES.salesperson_id = SALESPERSONS."_id" GROUP BY - COLUMN1 + MONTHS_RANGE_2.MONTH_START ) SELECT TO_CHAR("_S6".MONTH_START, '%Y-%m-%d') AS month, diff --git a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql index 493cbd135..d98130421 100644 --- a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -1,13 +1,13 @@ WITH "_S0" AS ( SELECT - TRUNC(CAST(sale_date AS DATE), 'QUARTER') AS QUARTER, + TRUNC(CAST(CAST(sale_date AS DATE) AS DATE), 'Q') AS QUARTER, customer_id AS CUSTOMER_ID, SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE EXTRACT(YEAR FROM CAST(sale_date AS DATE)) = 2023 GROUP BY - TRUNC(CAST(sale_date AS DATE), 'QUARTER'), + TRUNC(CAST(CAST(sale_date AS DATE) AS DATE), 'Q'), customer_id ), "_T1" AS ( SELECT diff --git a/tests/test_sql_refsols/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql index 0a8bf4326..78afedfe7 100644 --- a/tests/test_sql_refsols/double_cross_oracle.sql +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -12,11 +12,11 @@ WITH "_T3" AS ( ( CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S0".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S0".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(ORDERS.o_orderdate, 'D') + -1 + TO_CHAR(CAST(ORDERS.o_orderdate AS DATE), 'D') + -1 ), 7) ) ) / 7 @@ -28,11 +28,11 @@ WITH "_T3" AS ( ( CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S0".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S0".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(ORDERS.o_orderdate, 'D') + -1 + TO_CHAR(CAST(ORDERS.o_orderdate AS DATE), 'D') + -1 ), 7) ) ) / 7 @@ -44,11 +44,11 @@ WITH "_T3" AS ( ( CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S0".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S0".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(ORDERS.o_orderdate, 'D') + -1 + TO_CHAR(CAST(ORDERS.o_orderdate AS DATE), 'D') + -1 ), 7) ) ) / 7 @@ -63,11 +63,11 @@ WITH "_T3" AS ( ( CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 ), 7) ) ) / 7 @@ -83,11 +83,11 @@ WITH "_T3" AS ( ( CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 ), 7) ) ) / 7 @@ -98,11 +98,11 @@ WITH "_T3" AS ( ( CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 ), 7) ) ) / 7 @@ -112,11 +112,11 @@ WITH "_T3" AS ( ( CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( MOD(( - TO_CHAR("_S3".MIN_O_ORDERDATE, 'D') + -1 + TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(LINEITEM.l_receiptdate, 'D') + -1 + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 ), 7) ) ) / 7 diff --git a/tests/test_sql_refsols/order_quarter_test_oracle.sql b/tests/test_sql_refsols/order_quarter_test_oracle.sql index 7a0d40b1e..b1f3f0b31 100644 --- a/tests/test_sql_refsols/order_quarter_test_oracle.sql +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -1,7 +1,7 @@ SELECT o_orderdate AS order_date, EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) AS quarter, - TRUNC(CAST(o_orderdate AS DATE), 'QUARTER') AS quarter_start, + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'Q') AS quarter_start, CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(3, 'MONTH') AS next_quarter, CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(3, 'MONTH') AS prev_quarter, CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(6, 'MONTH') AS two_quarters_ahead, diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql index 50e497865..62fc43935 100644 --- a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -15,7 +15,7 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T4" JOIN "_S1" "_S3" - ON "_S3".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S3".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S3".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON DEVICES.de_product_id = 800544 @@ -24,29 +24,29 @@ WITH "_T2" AS ( "_S3".CA_DT ), "_S22" AS ( SELECT - TRUNC(CAST("_S1".CA_DT AS DATE), 'QUARTER') AS QUARTER, + TRUNC(CAST(CAST("_S1".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER, SUM("_S7".N_ROWS) AS SUM_N_ROWS FROM "_T2" "_T2" JOIN "_S1" "_S1" - ON "_S1".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S1".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S1".CA_DT >= "_T2".PR_RELEASE LEFT JOIN "_S7" "_S7" ON "_S1".CA_DT = "_S7".CA_DT GROUP BY - TRUNC(CAST("_S1".CA_DT AS DATE), 'QUARTER') + TRUNC(CAST(CAST("_S1".CA_DT AS DATE) AS DATE), 'Q') ), "_S13" AS ( SELECT DISTINCT - TRUNC(CAST("_S11".CA_DT AS DATE), 'QUARTER') AS QUARTER + TRUNC(CAST(CAST("_S11".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER FROM "_T2" "_T10" JOIN "_S1" "_S11" - ON "_S11".CA_DT < TRUNC(CAST("_T10".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S11".CA_DT < TRUNC(CAST("_T10".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S11".CA_DT >= "_T10".PR_RELEASE ), "_S17" AS ( SELECT "_S15".CA_DT FROM "_T2" "_T11" JOIN "_S1" "_S15" - ON "_S15".CA_DT < TRUNC(CAST("_T11".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'QUARTER') + ON "_S15".CA_DT < TRUNC(CAST("_T11".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') AND "_S15".CA_DT >= "_T11".PR_RELEASE ), "_S23" AS ( SELECT @@ -57,7 +57,7 @@ WITH "_T2" AS ( ON COUNTRIES.co_name = 'CN' CROSS JOIN "_S13" "_S13" JOIN "_S17" "_S17" - ON "_S13".QUARTER = TRUNC(CAST("_S17".CA_DT AS DATE), 'QUARTER') + ON "_S13".QUARTER = TRUNC(CAST(CAST("_S17".CA_DT AS DATE) AS DATE), 'Q') JOIN MAIN.INCIDENTS INCIDENTS ON COUNTRIES.co_id = INCIDENTS.in_repair_country_id AND "_S17".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') diff --git a/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql index f5ebc2f30..677068528 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql @@ -1,6 +1,6 @@ SELECT - COLUMN1 AS idx, - COLUMN2 AS color + RAINBOW.IDX AS idx, + RAINBOW.COLOR AS color FROM (VALUES (0, 'red'), (1, 'orange'), diff --git a/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql index 2d0fac87b..5ef009803 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql @@ -1,6 +1,6 @@ SELECT - COLUMN1 AS signup_date, - COLUMN2 AS user_id + USERS.SIGNUP_DATE AS signup_date, + USERS.USER_ID AS user_id FROM (VALUES (CAST('2024-01-10 00:00:00' AS TIMESTAMP), 1), (CAST('2024-01-12 00:00:00' AS TIMESTAMP), 2), diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql index c501f02af..d17ed0d63 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql @@ -1,8 +1,8 @@ SELECT - COLUMN1 AS user_id, - COLUMN2 AS "`name""[", - COLUMN3 AS "space country", - COLUMN4 AS "CAST" + USERS.USER_ID AS user_id, + USERS."`name""[", + USERS."space country", + USERS."CAST" FROM (VALUES (1, 'Alice', 'US', 25), (2, 'Bob', 'CR', 30), diff --git a/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql index e03658053..746b2bde3 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql @@ -1,6 +1,6 @@ SELECT - COLUMN1 AS user_id, - COLUMN2 AS country + USERS.USER_ID AS user_id, + USERS.COUNTRY AS country FROM (VALUES (1, 'US'), (2, 'CR'), diff --git a/tests/test_sql_refsols/simple_range_1_oracle.sql b/tests/test_sql_refsols/simple_range_1_oracle.sql index e3dc5a95d..5665bd48b 100644 --- a/tests/test_sql_refsols/simple_range_1_oracle.sql +++ b/tests/test_sql_refsols/simple_range_1_oracle.sql @@ -1,5 +1,5 @@ SELECT - COLUMN1 AS value + SIMPLE_RANGE.VALUE AS value FROM (VALUES (0), (1), diff --git a/tests/test_sql_refsols/simple_range_2_oracle.sql b/tests/test_sql_refsols/simple_range_2_oracle.sql index c28da3cb0..42d0ff393 100644 --- a/tests/test_sql_refsols/simple_range_2_oracle.sql +++ b/tests/test_sql_refsols/simple_range_2_oracle.sql @@ -1,5 +1,5 @@ SELECT - COLUMN1 AS value + SIMPLE_RANGE.VALUE AS value FROM (VALUES (0), (1), diff --git a/tests/test_sql_refsols/simple_range_3_oracle.sql b/tests/test_sql_refsols/simple_range_3_oracle.sql index f4e33756e..fa0dccb2c 100644 --- a/tests/test_sql_refsols/simple_range_3_oracle.sql +++ b/tests/test_sql_refsols/simple_range_3_oracle.sql @@ -1,5 +1,5 @@ SELECT - COLUMN1 AS foo + T1.FOO AS foo FROM (VALUES (15), (16), diff --git a/tests/test_sql_refsols/simple_range_4_oracle.sql b/tests/test_sql_refsols/simple_range_4_oracle.sql index 9afff215a..12be18be2 100644 --- a/tests/test_sql_refsols/simple_range_4_oracle.sql +++ b/tests/test_sql_refsols/simple_range_4_oracle.sql @@ -1,5 +1,5 @@ SELECT - COLUMN1 AS N + T2.N FROM (VALUES (10), (9), diff --git a/tests/test_sql_refsols/simple_range_6_oracle.sql b/tests/test_sql_refsols/simple_range_6_oracle.sql index 0cd7de281..b41f17b81 100644 --- a/tests/test_sql_refsols/simple_range_6_oracle.sql +++ b/tests/test_sql_refsols/simple_range_6_oracle.sql @@ -1,5 +1,5 @@ SELECT - CAST(SUBSTR(CAST(COLUMN1 AS VARCHAR2(4000)), 1, 1) AS INT) AS first_digit, + CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS INT) AS first_digit, COUNT(*) AS n FROM (VALUES (0), @@ -42,4 +42,4 @@ FROM (VALUES (481), (494)) AS TBL(V) GROUP BY - CAST(SUBSTR(CAST(COLUMN1 AS VARCHAR2(4000)), 1, 1) AS INT) + CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS INT) diff --git a/tests/test_sql_refsols/simple_range_7_oracle.sql b/tests/test_sql_refsols/simple_range_7_oracle.sql index 486ddee65..c738d93f8 100644 --- a/tests/test_sql_refsols/simple_range_7_oracle.sql +++ b/tests/test_sql_refsols/simple_range_7_oracle.sql @@ -1,7 +1,7 @@ SELECT - COLUMN1 + COLUMN1 AS s, + D1.X + D2.Y AS s, COUNT(*) AS n, - AVG(CAST(COLUMN1 * COLUMN1 AS DOUBLE PRECISION)) AS a + AVG(CAST(D1.X * D2.Y AS DOUBLE PRECISION)) AS a FROM (VALUES (1), (2), @@ -17,4 +17,4 @@ CROSS JOIN (VALUES (5), (6)) AS D2(Y) GROUP BY - COLUMN1 + COLUMN1 + D1.X + D2.Y diff --git a/tests/test_sql_refsols/simple_range_8_oracle.sql b/tests/test_sql_refsols/simple_range_8_oracle.sql index b34b9dba2..8f6bf1c02 100644 --- a/tests/test_sql_refsols/simple_range_8_oracle.sql +++ b/tests/test_sql_refsols/simple_range_8_oracle.sql @@ -1,9 +1,9 @@ SELECT ( - COLUMN1 + COLUMN1 - ) + COLUMN1 AS s, + D1.X + D2.Y + ) + D3.Z AS s, COUNT(*) AS n, - AVG(COLUMN1 * COLUMN1 * COLUMN1) AS a + AVG(D1.X * D2.Y * D3.Z) AS a FROM (VALUES (1), (2), @@ -21,5 +21,5 @@ CROSS JOIN (VALUES (4)) AS D3(Z) GROUP BY ( - COLUMN1 + COLUMN1 - ) + COLUMN1 + D1.X + D2.Y + ) + D3.Z diff --git a/tests/test_sql_refsols/simple_range_9_oracle.sql b/tests/test_sql_refsols/simple_range_9_oracle.sql index 25b3f36de..ee28f1d4e 100644 --- a/tests/test_sql_refsols/simple_range_9_oracle.sql +++ b/tests/test_sql_refsols/simple_range_9_oracle.sql @@ -1,5 +1,5 @@ SELECT - COLUMN1 AS "name space" + "quoted-name"."name space" FROM (VALUES (0), (1), diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql index 5b0d7da63..a47cceb5c 100644 --- a/tests/test_sql_refsols/smoke_b_oracle.sql +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -69,7 +69,7 @@ SELECT ':' ) AS b, TRUNC(CAST(o_orderdate AS DATE), 'YEAR') + NUMTOYMINTERVAL(6, 'month') - NUMTODSINTERVAL(13, 'day') AS c, - TRUNC(CAST(o_orderdate AS DATE), 'QUARTER') + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(25, 'hour') AS d, + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'Q') + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(25, 'hour') AS d, TO_DATE('2025-01-01 12:35:00', 'YYYY-MM-DD HH24:MI:SS') AS e, TO_DATE('2025-07-22 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS f, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, @@ -92,11 +92,11 @@ SELECT ( CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) + ( MOD(( - TO_CHAR('1993-05-25 12:45:36', 'D') + -1 + TO_CHAR(CAST('1993-05-25 12:45:36' AS DATE), 'D') + -1 ), 7) ) - ( MOD(( - TO_CHAR(o_orderdate, 'D') + -1 + TO_CHAR(CAST(o_orderdate AS DATE), 'D') + -1 ), 7) ) ) / 7 diff --git a/tests/test_sql_refsols/user_range_collection_1_oracle.sql b/tests/test_sql_refsols/user_range_collection_1_oracle.sql index 236adf39d..b444e8e30 100644 --- a/tests/test_sql_refsols/user_range_collection_1_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_1_oracle.sql @@ -9,7 +9,7 @@ WITH "_S1" AS ( p_size ) SELECT - COLUMN1 AS part_size, + SIZES.PART_SIZE AS part_size, COALESCE("_S1".N_ROWS, 0) AS n_parts FROM (VALUES (1), @@ -33,4 +33,4 @@ FROM (VALUES (91), (96)) AS SIZES(PART_SIZE) LEFT JOIN "_S1" "_S1" - ON COLUMN1 = "_S1".P_SIZE + ON SIZES.PART_SIZE = "_S1".P_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_2_oracle.sql b/tests/test_sql_refsols/user_range_collection_2_oracle.sql index b5cf31be6..0502eec48 100644 --- a/tests/test_sql_refsols/user_range_collection_2_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -1,7 +1,28 @@ -WITH "_S1" AS ( +WITH "_S3" AS ( SELECT - COLUMN1 AS Y + A_2.X, + SUM( + CAST(B.Y AS VARCHAR2(4000)) LIKE ( + CONCAT('%', CAST(A_2.X AS VARCHAR2(4000))) + ) + ) AS SUM_EXPR, + SUM( + CAST(B.Y AS VARCHAR2(4000)) LIKE ( + CONCAT(CAST(A_2.X AS VARCHAR2(4000)), '%') + ) + ) AS SUM_EXPR_5 FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A_2(X) + JOIN (VALUES (0), (2), (4), @@ -503,38 +524,13 @@ WITH "_S1" AS ( (996), (998), (1000)) AS B(Y) -), "_S3" AS ( - SELECT - COLUMN1 AS X, - SUM( - CAST("_S1".Y AS VARCHAR2(4000)) LIKE ( - CONCAT('%', CAST(COLUMN1 AS VARCHAR2(4000))) - ) - ) AS SUM_EXPR, - SUM( - CAST("_S1".Y AS VARCHAR2(4000)) LIKE ( - CONCAT(CAST(COLUMN1 AS VARCHAR2(4000)), '%') - ) - ) AS SUM_EXPR_5 - FROM (VALUES - (0), - (1), - (2), - (3), - (4), - (5), - (6), - (7), - (8), - (9)) AS A_2(X) - JOIN "_S1" "_S1" - ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(COLUMN1 AS VARCHAR2(4000))) - OR CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(COLUMN1 AS VARCHAR2(4000)), '%') + ON CAST(B.Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(A_2.X AS VARCHAR2(4000))) + OR CAST(B.Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(A_2.X AS VARCHAR2(4000)), '%') GROUP BY - COLUMN1 + A_2.X ) SELECT - COLUMN1 AS x, + A.X AS x, COALESCE("_S3".SUM_EXPR_5, 0) AS n_prefix, COALESCE("_S3".SUM_EXPR, 0) AS n_suffix FROM (VALUES @@ -549,6 +545,6 @@ FROM (VALUES (8), (9)) AS A(X) LEFT JOIN "_S3" "_S3" - ON COLUMN1 = "_S3".X + ON A.X = "_S3".X ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_3_oracle.sql b/tests/test_sql_refsols/user_range_collection_3_oracle.sql index 8210a23cc..9664fe4eb 100644 --- a/tests/test_sql_refsols/user_range_collection_3_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -1,512 +1,19 @@ -WITH "_S1" AS ( +WITH "_S5" AS ( SELECT - COLUMN1 AS Y - FROM (VALUES - (0), - (2), - (4), - (6), - (8), - (10), - (12), - (14), - (16), - (18), - (20), - (22), - (24), - (26), - (28), - (30), - (32), - (34), - (36), - (38), - (40), - (42), - (44), - (46), - (48), - (50), - (52), - (54), - (56), - (58), - (60), - (62), - (64), - (66), - (68), - (70), - (72), - (74), - (76), - (78), - (80), - (82), - (84), - (86), - (88), - (90), - (92), - (94), - (96), - (98), - (100), - (102), - (104), - (106), - (108), - (110), - (112), - (114), - (116), - (118), - (120), - (122), - (124), - (126), - (128), - (130), - (132), - (134), - (136), - (138), - (140), - (142), - (144), - (146), - (148), - (150), - (152), - (154), - (156), - (158), - (160), - (162), - (164), - (166), - (168), - (170), - (172), - (174), - (176), - (178), - (180), - (182), - (184), - (186), - (188), - (190), - (192), - (194), - (196), - (198), - (200), - (202), - (204), - (206), - (208), - (210), - (212), - (214), - (216), - (218), - (220), - (222), - (224), - (226), - (228), - (230), - (232), - (234), - (236), - (238), - (240), - (242), - (244), - (246), - (248), - (250), - (252), - (254), - (256), - (258), - (260), - (262), - (264), - (266), - (268), - (270), - (272), - (274), - (276), - (278), - (280), - (282), - (284), - (286), - (288), - (290), - (292), - (294), - (296), - (298), - (300), - (302), - (304), - (306), - (308), - (310), - (312), - (314), - (316), - (318), - (320), - (322), - (324), - (326), - (328), - (330), - (332), - (334), - (336), - (338), - (340), - (342), - (344), - (346), - (348), - (350), - (352), - (354), - (356), - (358), - (360), - (362), - (364), - (366), - (368), - (370), - (372), - (374), - (376), - (378), - (380), - (382), - (384), - (386), - (388), - (390), - (392), - (394), - (396), - (398), - (400), - (402), - (404), - (406), - (408), - (410), - (412), - (414), - (416), - (418), - (420), - (422), - (424), - (426), - (428), - (430), - (432), - (434), - (436), - (438), - (440), - (442), - (444), - (446), - (448), - (450), - (452), - (454), - (456), - (458), - (460), - (462), - (464), - (466), - (468), - (470), - (472), - (474), - (476), - (478), - (480), - (482), - (484), - (486), - (488), - (490), - (492), - (494), - (496), - (498), - (500), - (502), - (504), - (506), - (508), - (510), - (512), - (514), - (516), - (518), - (520), - (522), - (524), - (526), - (528), - (530), - (532), - (534), - (536), - (538), - (540), - (542), - (544), - (546), - (548), - (550), - (552), - (554), - (556), - (558), - (560), - (562), - (564), - (566), - (568), - (570), - (572), - (574), - (576), - (578), - (580), - (582), - (584), - (586), - (588), - (590), - (592), - (594), - (596), - (598), - (600), - (602), - (604), - (606), - (608), - (610), - (612), - (614), - (616), - (618), - (620), - (622), - (624), - (626), - (628), - (630), - (632), - (634), - (636), - (638), - (640), - (642), - (644), - (646), - (648), - (650), - (652), - (654), - (656), - (658), - (660), - (662), - (664), - (666), - (668), - (670), - (672), - (674), - (676), - (678), - (680), - (682), - (684), - (686), - (688), - (690), - (692), - (694), - (696), - (698), - (700), - (702), - (704), - (706), - (708), - (710), - (712), - (714), - (716), - (718), - (720), - (722), - (724), - (726), - (728), - (730), - (732), - (734), - (736), - (738), - (740), - (742), - (744), - (746), - (748), - (750), - (752), - (754), - (756), - (758), - (760), - (762), - (764), - (766), - (768), - (770), - (772), - (774), - (776), - (778), - (780), - (782), - (784), - (786), - (788), - (790), - (792), - (794), - (796), - (798), - (800), - (802), - (804), - (806), - (808), - (810), - (812), - (814), - (816), - (818), - (820), - (822), - (824), - (826), - (828), - (830), - (832), - (834), - (836), - (838), - (840), - (842), - (844), - (846), - (848), - (850), - (852), - (854), - (856), - (858), - (860), - (862), - (864), - (866), - (868), - (870), - (872), - (874), - (876), - (878), - (880), - (882), - (884), - (886), - (888), - (890), - (892), - (894), - (896), - (898), - (900), - (902), - (904), - (906), - (908), - (910), - (912), - (914), - (916), - (918), - (920), - (922), - (924), - (926), - (928), - (930), - (932), - (934), - (936), - (938), - (940), - (942), - (944), - (946), - (948), - (950), - (952), - (954), - (956), - (958), - (960), - (962), - (964), - (966), - (968), - (970), - (972), - (974), - (976), - (978), - (980), - (982), - (984), - (986), - (988), - (990), - (992), - (994), - (996), - (998), - (1000)) AS B(Y) -), "_S3" AS ( - SELECT - COLUMN1 AS Y + A_2.X, + COUNT(*) AS N_ROWS FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A_2(X) + JOIN (VALUES (0), (2), (4), @@ -1008,28 +515,12 @@ WITH "_S1" AS ( (996), (998), (1000)) AS B_2(Y) -), "_S5" AS ( - SELECT - COLUMN1 AS X, - COUNT(*) AS N_ROWS - FROM (VALUES - (0), - (1), - (2), - (3), - (4), - (5), - (6), - (7), - (8), - (9)) AS A_2(X) - JOIN "_S3" "_S3" - ON CAST("_S3".Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(COLUMN1 AS VARCHAR2(4000))) + ON CAST(B_2.Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(A_2.X AS VARCHAR2(4000))) GROUP BY - COLUMN1 + A_2.X ) SELECT - COLUMN1 AS x, + A.X AS x, COUNT(*) AS n_prefix, ANY_VALUE("_S5".N_ROWS) AS n_suffix FROM (VALUES @@ -1043,11 +534,512 @@ FROM (VALUES (7), (8), (9)) AS A(X) -JOIN "_S1" "_S1" - ON CAST("_S1".Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(COLUMN1 AS VARCHAR2(4000)), '%') +JOIN (VALUES + (0), + (2), + (4), + (6), + (8), + (10), + (12), + (14), + (16), + (18), + (20), + (22), + (24), + (26), + (28), + (30), + (32), + (34), + (36), + (38), + (40), + (42), + (44), + (46), + (48), + (50), + (52), + (54), + (56), + (58), + (60), + (62), + (64), + (66), + (68), + (70), + (72), + (74), + (76), + (78), + (80), + (82), + (84), + (86), + (88), + (90), + (92), + (94), + (96), + (98), + (100), + (102), + (104), + (106), + (108), + (110), + (112), + (114), + (116), + (118), + (120), + (122), + (124), + (126), + (128), + (130), + (132), + (134), + (136), + (138), + (140), + (142), + (144), + (146), + (148), + (150), + (152), + (154), + (156), + (158), + (160), + (162), + (164), + (166), + (168), + (170), + (172), + (174), + (176), + (178), + (180), + (182), + (184), + (186), + (188), + (190), + (192), + (194), + (196), + (198), + (200), + (202), + (204), + (206), + (208), + (210), + (212), + (214), + (216), + (218), + (220), + (222), + (224), + (226), + (228), + (230), + (232), + (234), + (236), + (238), + (240), + (242), + (244), + (246), + (248), + (250), + (252), + (254), + (256), + (258), + (260), + (262), + (264), + (266), + (268), + (270), + (272), + (274), + (276), + (278), + (280), + (282), + (284), + (286), + (288), + (290), + (292), + (294), + (296), + (298), + (300), + (302), + (304), + (306), + (308), + (310), + (312), + (314), + (316), + (318), + (320), + (322), + (324), + (326), + (328), + (330), + (332), + (334), + (336), + (338), + (340), + (342), + (344), + (346), + (348), + (350), + (352), + (354), + (356), + (358), + (360), + (362), + (364), + (366), + (368), + (370), + (372), + (374), + (376), + (378), + (380), + (382), + (384), + (386), + (388), + (390), + (392), + (394), + (396), + (398), + (400), + (402), + (404), + (406), + (408), + (410), + (412), + (414), + (416), + (418), + (420), + (422), + (424), + (426), + (428), + (430), + (432), + (434), + (436), + (438), + (440), + (442), + (444), + (446), + (448), + (450), + (452), + (454), + (456), + (458), + (460), + (462), + (464), + (466), + (468), + (470), + (472), + (474), + (476), + (478), + (480), + (482), + (484), + (486), + (488), + (490), + (492), + (494), + (496), + (498), + (500), + (502), + (504), + (506), + (508), + (510), + (512), + (514), + (516), + (518), + (520), + (522), + (524), + (526), + (528), + (530), + (532), + (534), + (536), + (538), + (540), + (542), + (544), + (546), + (548), + (550), + (552), + (554), + (556), + (558), + (560), + (562), + (564), + (566), + (568), + (570), + (572), + (574), + (576), + (578), + (580), + (582), + (584), + (586), + (588), + (590), + (592), + (594), + (596), + (598), + (600), + (602), + (604), + (606), + (608), + (610), + (612), + (614), + (616), + (618), + (620), + (622), + (624), + (626), + (628), + (630), + (632), + (634), + (636), + (638), + (640), + (642), + (644), + (646), + (648), + (650), + (652), + (654), + (656), + (658), + (660), + (662), + (664), + (666), + (668), + (670), + (672), + (674), + (676), + (678), + (680), + (682), + (684), + (686), + (688), + (690), + (692), + (694), + (696), + (698), + (700), + (702), + (704), + (706), + (708), + (710), + (712), + (714), + (716), + (718), + (720), + (722), + (724), + (726), + (728), + (730), + (732), + (734), + (736), + (738), + (740), + (742), + (744), + (746), + (748), + (750), + (752), + (754), + (756), + (758), + (760), + (762), + (764), + (766), + (768), + (770), + (772), + (774), + (776), + (778), + (780), + (782), + (784), + (786), + (788), + (790), + (792), + (794), + (796), + (798), + (800), + (802), + (804), + (806), + (808), + (810), + (812), + (814), + (816), + (818), + (820), + (822), + (824), + (826), + (828), + (830), + (832), + (834), + (836), + (838), + (840), + (842), + (844), + (846), + (848), + (850), + (852), + (854), + (856), + (858), + (860), + (862), + (864), + (866), + (868), + (870), + (872), + (874), + (876), + (878), + (880), + (882), + (884), + (886), + (888), + (890), + (892), + (894), + (896), + (898), + (900), + (902), + (904), + (906), + (908), + (910), + (912), + (914), + (916), + (918), + (920), + (922), + (924), + (926), + (928), + (930), + (932), + (934), + (936), + (938), + (940), + (942), + (944), + (946), + (948), + (950), + (952), + (954), + (956), + (958), + (960), + (962), + (964), + (966), + (968), + (970), + (972), + (974), + (976), + (978), + (980), + (982), + (984), + (986), + (988), + (990), + (992), + (994), + (996), + (998), + (1000)) AS B(Y) + ON CAST(B.Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(A.X AS VARCHAR2(4000)), '%') JOIN "_S5" "_S5" - ON COLUMN1 = "_S5".X + ON A.X = "_S5".X GROUP BY - COLUMN1 + A.X ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_4_oracle.sql b/tests/test_sql_refsols/user_range_collection_4_oracle.sql index d8d33a848..797b0d4f5 100644 --- a/tests/test_sql_refsols/user_range_collection_4_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_4_oracle.sql @@ -2,8 +2,8 @@ WITH "_T" AS ( SELECT PART.p_name AS P_NAME, PART.p_retailprice AS P_RETAILPRICE, - COLUMN1 AS PART_SIZE, - ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY PART.p_retailprice) AS "_W" + SIZES.PART_SIZE, + ROW_NUMBER() OVER (PARTITION BY SIZES.PART_SIZE ORDER BY PART.p_retailprice) AS "_W" FROM (VALUES (1), (2), @@ -16,9 +16,9 @@ WITH "_T" AS ( (9), (10)) AS SIZES(PART_SIZE) JOIN TPCH.PART PART - ON COLUMN1 = PART.p_size - AND PART.p_container LIKE '%SM DRUM%' + ON PART.p_container LIKE '%SM DRUM%' AND PART.p_name LIKE '%azure%' + AND PART.p_size = SIZES.PART_SIZE AND PART.p_type LIKE '%PLATED%' ) SELECT diff --git a/tests/test_sql_refsols/user_range_collection_5_oracle.sql b/tests/test_sql_refsols/user_range_collection_5_oracle.sql index a9fc6099e..fb0facca4 100644 --- a/tests/test_sql_refsols/user_range_collection_5_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -1,6 +1,6 @@ WITH "_S3" AS ( SELECT - COLUMN1 AS PART_SIZE, + SIZES_2.PART_SIZE, COUNT(*) AS N_ROWS FROM (VALUES (1), @@ -16,16 +16,16 @@ WITH "_S3" AS ( (51), (56)) AS SIZES_2(PART_SIZE) JOIN TPCH.PART PART - ON COLUMN1 <= PART.p_size - AND PART.p_name LIKE '%almond%' + ON PART.p_name LIKE '%almond%' AND PART.p_size <= ( - COLUMN1 + 4 + SIZES_2.PART_SIZE + 4 ) + AND PART.p_size >= SIZES_2.PART_SIZE GROUP BY - COLUMN1 + SIZES_2.PART_SIZE ) SELECT - COLUMN1 AS part_size, + SIZES.PART_SIZE AS part_size, COALESCE("_S3".N_ROWS, 0) AS n_parts FROM (VALUES (1), @@ -41,4 +41,4 @@ FROM (VALUES (51), (56)) AS SIZES(PART_SIZE) LEFT JOIN "_S3" "_S3" - ON COLUMN1 = "_S3".PART_SIZE + ON SIZES.PART_SIZE = "_S3".PART_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_6_oracle.sql b/tests/test_sql_refsols/user_range_collection_6_oracle.sql index 223e7946d..8e2781f0b 100644 --- a/tests/test_sql_refsols/user_range_collection_6_oracle.sql +++ b/tests/test_sql_refsols/user_range_collection_6_oracle.sql @@ -13,7 +13,7 @@ WITH "_S5" AS ( EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) ) SELECT - COLUMN1 AS year, + YEARS.YEAR AS year, COALESCE("_S5".NDISTINCT_O_CUSTKEY, 0) AS n_orders FROM (VALUES (1990), @@ -28,6 +28,6 @@ FROM (VALUES (1999), (2000)) AS YEARS(YEAR) LEFT JOIN "_S5" "_S5" - ON COLUMN1 = "_S5".YEAR_O_ORDERDATE + ON YEARS.YEAR = "_S5".YEAR_O_ORDERDATE ORDER BY 1 NULLS FIRST From 2fb20ace0cf720c66ef61c51d873cd2e3ee6c96a Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 27 Feb 2026 09:01:37 -0600 Subject: [PATCH 20/48] week_offset fixed, df quoted name --- .../oracle_transform_bindings.py | 110 ++++++- tests/test_pipeline_oracle.py | 291 +++++++++++++++++- .../simple_dataframe_collection_3.txt | 4 +- .../defog_test_functions.py | 7 +- .../user_collections.py | 2 +- .../agg_simplification_1_oracle.sql | 2 +- ...rnative_quarter_cum_ir_analysis_oracle.sql | 6 +- .../casting_functions_oracle.sql | 2 +- .../country_x_year_analysis_oracle.sql | 8 +- .../country_x_year_combos_oracle.sql | 4 +- .../dataframe_collection_datatypes_oracle.sql | 20 +- .../dataframe_collection_inf_oracle.sql | 4 +- ...dataframe_collection_where_date_oracle.sql | 12 +- .../datetime_current_oracle.sql | 2 +- .../datetime_relative_oracle.sql | 2 +- .../datetime_sampler_oracle.sql | 41 ++- .../defog_broker_adv15_ansi.sql | 3 +- .../defog_broker_adv15_mysql.sql | 3 +- .../defog_broker_adv15_oracle.sql | 3 +- .../defog_broker_adv15_postgres.sql | 3 +- .../defog_broker_adv15_snowflake.sql | 3 +- .../defog_broker_adv16_oracle.sql | 4 +- .../defog_broker_adv7_oracle.sql | 4 +- .../defog_dealership_adv8_oracle.sql | 28 +- .../defog_dealership_adv9_ansi.sql | 3 +- .../defog_dealership_adv9_mysql.sql | 3 +- .../defog_dealership_adv9_oracle.sql | 3 +- .../defog_dealership_adv9_postgres.sql | 3 +- .../defog_dealership_adv9_snowflake.sql | 3 +- .../defog_dealership_basic10_oracle.sql | 4 +- .../defog_dermtreatment_adv7_oracle.sql | 4 +- .../defog_dermtreatment_adv8_oracle.sql | 4 +- .../defog_dermtreatment_adv9_oracle.sql | 8 +- .../defog_dermtreatment_basic1_oracle.sql | 2 +- .../defog_dermtreatment_gen2_oracle.sql | 2 +- .../defog_dermtreatment_gen5_oracle.sql | 2 +- .../defog_ewallet_adv13_oracle.sql | 4 +- .../defog_ewallet_adv9_oracle.sql | 4 +- .../defog_ewallet_gen4_oracle.sql | 4 +- .../defog_ewallet_gen5_oracle.sql | 4 +- .../part_reduced_size_oracle.sql | 6 +- .../quarter_cum_ir_analysis_oracle.sql | 8 +- .../simple_dataframe_collection_2_oracle.sql | 8 +- .../simple_dataframe_collection_3_ansi.sql | 4 +- .../simple_dataframe_collection_3_mysql.sql | 4 +- .../simple_dataframe_collection_3_oracle.sql | 4 +- ...simple_dataframe_collection_3_postgres.sql | 4 +- ...imple_dataframe_collection_3_snowflake.sql | 4 +- .../simple_dataframe_collection_3_sqlite.sql | 2 +- tests/test_sql_refsols/smoke_b_oracle.sql | 4 +- ...chnograph_monthly_incident_rate_oracle.sql | 4 +- tests/test_sql_refsols/week_offset_oracle.sql | 4 +- 52 files changed, 540 insertions(+), 141 deletions(-) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index b99645939..64728074b 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -5,12 +5,18 @@ __all__ = ["OracleTransformBindings"] +import math +from typing import Any + import sqlglot.expressions as sqlglot_expressions from sqlglot.expressions import Expression as SQLGlotExpression import pydough.pydough_operators as pydop from pydough.errors.error_types import PyDoughSQLException from pydough.types import PyDoughType +from pydough.types.boolean_type import BooleanType +from pydough.types.datetime_type import DatetimeType +from pydough.types.numeric_type import NumericType from .base_transform_bindings import BaseTransformBindings from .sqlglot_transform_utils import ( @@ -40,6 +46,24 @@ def dialect_dow_mapping(self) -> dict[str, int]: def values_alias_column(self) -> bool: return False + @property + def oracle_strftime_mapping(self) -> dict[str, str]: + """ + This mapping is used by `oracle_format` when converting a + format string supplied by the user (which typically uses Python + `strftime`-style specifiers) into a form that Oracle will + understand. Only a small subset of directives is currently + supported; additional tokens may be added as needed. + """ + return { + "%Y": "YYYY", + "%m": "MM", + "%d": "DD", + "%H": "HH24", + "%M": "MI", + "%S": "SS", + } + PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { pydop.ABS: "ABS", pydop.LARGEST: "GREATEST", @@ -617,12 +641,11 @@ def apply_datetime_offset( ], ) case DateTimeUnit.MONTH | DateTimeUnit.YEAR: - interval = sqlglot_expressions.Anonymous( - this="NUMTOYMINTERVAL", - expressions=[ - sqlglot_expressions.convert(amt), - sqlglot_expressions.Literal.string(unit.value), - ], + add_month = ( + original_amt if unit == DateTimeUnit.MONTH else original_amt * 12 + ) + return sqlglot_expressions.AddMonths( + this=base, expression=sqlglot_expressions.convert(add_month) ) case _: raise ValueError(f"Unsupported unit '{unit}' for datetime offset.") @@ -691,6 +714,30 @@ def convert_extract_datetime( ), ) + def oracle_format(self, fmt: str) -> str: + """ + Translate a Python-style `strftime` format string to Oracle. + + One-to-one conversion replacement of each key in the + mapping with its corresponding value. Unknown directives are left + untouched. + + Args: + - `fmt`: A format string containing Python `strftime` directives (e.g. + `"%Y-%m-%d %H:%M:%S"`). + + Returns + The resulting Oracle-compatible format (e.g. ``"YYYY-MM-DD + HH24:MI:SS"``). + + Example: + "%Y-%m-%d" becomes 'YYYY-MM-DD' + "%Y/%m/%d %H:%M" becomes 'YYYY/MM/DD HH24:MI' + """ + for k, v in self.oracle_strftime_mapping.items(): + fmt = fmt.replace(k, v) + return fmt + def convert_string( self, args: list[SQLGlotExpression], types: list[PyDoughType] ) -> SQLGlotExpression: @@ -718,4 +765,53 @@ def convert_string( raise PyDoughSQLException( f"STRING(X,Y) requires the second argument to be a string date format literal, but received {args[1]}" ) - return sqlglot_expressions.ToChar(this=args[0], format=args[1]) + return sqlglot_expressions.ToChar( + this=args[0], + format=sqlglot_expressions.Literal.string( + self.oracle_format(args[1].this) + ), + ) + + def generate_dataframe_item_dialect_expression( + self, item: Any, item_type: PyDoughType + ) -> SQLGlotExpression: + match item_type: + case DatetimeType(): + return sqlglot_expressions.Anonymous( + this="TO_TIMESTAMP", + expressions=[ + sqlglot_expressions.Literal.string(item), + sqlglot_expressions.Literal.string("YYYY-MM-DD HH24:MI:SS"), + ], + ) + case NumericType(): + if math.isinf(item): + infinity_val: SQLGlotExpression = sqlglot_expressions.Identifier( + this="BINARY_DOUBLE_INFINITY" + ) + if item >= 0: + return infinity_val + else: + return sqlglot_expressions.Neg(this=infinity_val) + + return sqlglot_expressions.Literal.number(item) + + case _: # UnknownType + return sqlglot_expressions.Literal.string(str(item)) + + def convert_integer( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + if isinstance(types[0], BooleanType): + # Oracle can't convert boolean to int, for this Case will be used + return sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=args[0], + true=sqlglot_expressions.Literal.number(1), + ) + ], + default=sqlglot_expressions.Literal.number(0), + ) + else: + return super().convert_integer(args, types) diff --git a/tests/test_pipeline_oracle.py b/tests/test_pipeline_oracle.py index 4a94d7c0d..21a6e5dad 100644 --- a/tests/test_pipeline_oracle.py +++ b/tests/test_pipeline_oracle.py @@ -17,6 +17,7 @@ from tests.test_pipeline_defog_custom import get_day_of_week, get_start_of_week from tests.test_pydough_functions.simple_pydough_functions import ( simple_week_sampler_tpch, + week_offset, ) from tests.test_pydough_functions.tpch_outputs import ( tpch_q16_output, @@ -59,6 +60,290 @@ def tpch_oracle_params_test_data(request) -> PyDoughPandasTest: return request.param +@pytest.fixture +def defog_custom_oracle_test_data( + defog_custom_pipeline_test_data: PyDoughPandasTest, # noqa: F811 +) -> PyDoughPandasTest: + """ + Modify reference solution data for some Defog queries. + Return an instance of PyDoughPandasTest containing the modified data. + """ + if defog_custom_pipeline_test_data.test_name == "week_offset": + return PyDoughPandasTest( + week_offset, + "Broker", + lambda: pd.DataFrame( + { + "date_time": [ + "2023-04-02 09:30:00", + "2023-04-02 10:15:00", + "2023-04-02 11:00:00", + "2023-04-02 11:45:00", + "2023-04-02 12:30:00", + "2023-04-02 13:15:00", + "2023-04-02 14:00:00", + "2023-04-02 14:45:00", + "2023-04-02 15:30:00", + "2023-04-02 16:15:00", + "2023-04-03 09:30:00", + "2023-04-03 10:15:00", + "2023-04-03 11:00:00", + "2023-04-03 11:45:00", + "2023-04-03 12:30:00", + "2023-04-03 13:15:00", + "2023-04-03 14:00:00", + "2023-04-03 14:45:00", + "2023-04-03 15:30:00", + "2023-04-03 16:15:00", + "2023-01-15 10:00:00", + "2023-01-16 10:30:00", + "2023-02-20 11:30:00", + "2023-03-25 14:45:00", + "2023-01-30 13:15:00", + "2023-02-28 16:00:00", + "2023-03-30 09:45:00", + ], + "week_adj1": [ + "2023-04-09 09:30:00", + "2023-04-09 10:15:00", + "2023-04-09 11:00:00", + "2023-04-09 11:45:00", + "2023-04-09 12:30:00", + "2023-04-09 13:15:00", + "2023-04-09 14:00:00", + "2023-04-09 14:45:00", + "2023-04-09 15:30:00", + "2023-04-09 16:15:00", + "2023-04-10 09:30:00", + "2023-04-10 10:15:00", + "2023-04-10 11:00:00", + "2023-04-10 11:45:00", + "2023-04-10 12:30:00", + "2023-04-10 13:15:00", + "2023-04-10 14:00:00", + "2023-04-10 14:45:00", + "2023-04-10 15:30:00", + "2023-04-10 16:15:00", + "2023-01-22 10:00:00", + "2023-01-23 10:30:00", + "2023-02-27 11:30:00", + "2023-04-01 14:45:00", + "2023-02-06 13:15:00", + "2023-03-07 16:00:00", + "2023-04-06 09:45:00", + ], + "week_adj2": [ + "2023-03-26 09:30:00", + "2023-03-26 10:15:00", + "2023-03-26 11:00:00", + "2023-03-26 11:45:00", + "2023-03-26 12:30:00", + "2023-03-26 13:15:00", + "2023-03-26 14:00:00", + "2023-03-26 14:45:00", + "2023-03-26 15:30:00", + "2023-03-26 16:15:00", + "2023-03-27 09:30:00", + "2023-03-27 10:15:00", + "2023-03-27 11:00:00", + "2023-03-27 11:45:00", + "2023-03-27 12:30:00", + "2023-03-27 13:15:00", + "2023-03-27 14:00:00", + "2023-03-27 14:45:00", + "2023-03-27 15:30:00", + "2023-03-27 16:15:00", + "2023-01-08 10:00:00", + "2023-01-09 10:30:00", + "2023-02-13 11:30:00", + "2023-03-18 14:45:00", + "2023-01-23 13:15:00", + "2023-02-21 16:00:00", + "2023-03-23 09:45:00", + ], + "week_adj3": [ + "2023-04-16 10:30:00", + "2023-04-16 11:15:00", + "2023-04-16 12:00:00", + "2023-04-16 12:45:00", + "2023-04-16 13:30:00", + "2023-04-16 14:15:00", + "2023-04-16 15:00:00", + "2023-04-16 15:45:00", + "2023-04-16 16:30:00", + "2023-04-16 17:15:00", + "2023-04-17 10:30:00", + "2023-04-17 11:15:00", + "2023-04-17 12:00:00", + "2023-04-17 12:45:00", + "2023-04-17 13:30:00", + "2023-04-17 14:15:00", + "2023-04-17 15:00:00", + "2023-04-17 15:45:00", + "2023-04-17 16:30:00", + "2023-04-17 17:15:00", + "2023-01-29 11:00:00", + "2023-01-30 11:30:00", + "2023-03-06 12:30:00", + "2023-04-08 15:45:00", + "2023-02-13 14:15:00", + "2023-03-14 17:00:00", + "2023-04-13 10:45:00", + ], + "week_adj4": [ + "2023-04-16 09:29:59", + "2023-04-16 10:14:59", + "2023-04-16 10:59:59", + "2023-04-16 11:44:59", + "2023-04-16 12:29:59", + "2023-04-16 13:14:59", + "2023-04-16 13:59:59", + "2023-04-16 14:44:59", + "2023-04-16 15:29:59", + "2023-04-16 16:14:59", + "2023-04-17 09:29:59", + "2023-04-17 10:14:59", + "2023-04-17 10:59:59", + "2023-04-17 11:44:59", + "2023-04-17 12:29:59", + "2023-04-17 13:14:59", + "2023-04-17 13:59:59", + "2023-04-17 14:44:59", + "2023-04-17 15:29:59", + "2023-04-17 16:14:59", + "2023-01-29 09:59:59", + "2023-01-30 10:29:59", + "2023-03-06 11:29:59", + "2023-04-08 14:44:59", + "2023-02-13 13:14:59", + "2023-03-14 15:59:59", + "2023-04-13 09:44:59", + ], + "week_adj5": [ + "2023-04-17 09:30:00", + "2023-04-17 10:15:00", + "2023-04-17 11:00:00", + "2023-04-17 11:45:00", + "2023-04-17 12:30:00", + "2023-04-17 13:15:00", + "2023-04-17 14:00:00", + "2023-04-17 14:45:00", + "2023-04-17 15:30:00", + "2023-04-17 16:15:00", + "2023-04-18 09:30:00", + "2023-04-18 10:15:00", + "2023-04-18 11:00:00", + "2023-04-18 11:45:00", + "2023-04-18 12:30:00", + "2023-04-18 13:15:00", + "2023-04-18 14:00:00", + "2023-04-18 14:45:00", + "2023-04-18 15:30:00", + "2023-04-18 16:15:00", + "2023-01-30 10:00:00", + "2023-01-31 10:30:00", + "2023-03-07 11:30:00", + "2023-04-09 14:45:00", + "2023-02-14 13:15:00", + "2023-03-15 16:00:00", + "2023-04-14 09:45:00", + ], + "week_adj6": [ + "2023-04-16 09:29:00", + "2023-04-16 10:14:00", + "2023-04-16 10:59:00", + "2023-04-16 11:44:00", + "2023-04-16 12:29:00", + "2023-04-16 13:14:00", + "2023-04-16 13:59:00", + "2023-04-16 14:44:00", + "2023-04-16 15:29:00", + "2023-04-16 16:14:00", + "2023-04-17 09:29:00", + "2023-04-17 10:14:00", + "2023-04-17 10:59:00", + "2023-04-17 11:44:00", + "2023-04-17 12:29:00", + "2023-04-17 13:14:00", + "2023-04-17 13:59:00", + "2023-04-17 14:44:00", + "2023-04-17 15:29:00", + "2023-04-17 16:14:00", + "2023-01-29 09:59:00", + "2023-01-30 10:29:00", + "2023-03-06 11:29:00", + "2023-04-08 14:44:00", + "2023-02-13 13:14:00", + "2023-03-14 15:59:00", + "2023-04-13 09:44:00", + ], + "week_adj7": [ + "2023-05-16 09:30:00", + "2023-05-16 10:15:00", + "2023-05-16 11:00:00", + "2023-05-16 11:45:00", + "2023-05-16 12:30:00", + "2023-05-16 13:15:00", + "2023-05-16 14:00:00", + "2023-05-16 14:45:00", + "2023-05-16 15:30:00", + "2023-05-16 16:15:00", + "2023-05-17 09:30:00", + "2023-05-17 10:15:00", + "2023-05-17 11:00:00", + "2023-05-17 11:45:00", + "2023-05-17 12:30:00", + "2023-05-17 13:15:00", + "2023-05-17 14:00:00", + "2023-05-17 14:45:00", + "2023-05-17 15:30:00", + "2023-05-17 16:15:00", + "2023-03-01 10:00:00", + "2023-03-02 10:30:00", + "2023-04-03 11:30:00", + "2023-05-09 14:45:00", + "2023-03-14 13:15:00", + "2023-04-14 16:00:00", # This changed + "2023-05-14 09:45:00", + ], + "week_adj8": [ + "2024-04-16 09:30:00", + "2024-04-16 10:15:00", + "2024-04-16 11:00:00", + "2024-04-16 11:45:00", + "2024-04-16 12:30:00", + "2024-04-16 13:15:00", + "2024-04-16 14:00:00", + "2024-04-16 14:45:00", + "2024-04-16 15:30:00", + "2024-04-16 16:15:00", + "2024-04-17 09:30:00", + "2024-04-17 10:15:00", + "2024-04-17 11:00:00", + "2024-04-17 11:45:00", + "2024-04-17 12:30:00", + "2024-04-17 13:15:00", + "2024-04-17 14:00:00", + "2024-04-17 14:45:00", + "2024-04-17 15:30:00", + "2024-04-17 16:15:00", + "2024-01-29 10:00:00", + "2024-01-30 10:30:00", + "2024-03-05 11:30:00", + "2024-04-08 14:45:00", + "2024-02-13 13:15:00", + "2024-03-14 16:00:00", # This changed + "2024-04-13 09:45:00", + ], + } + ), + "week_offset", + skip_sql=True, + ) + + return defog_custom_pipeline_test_data + + @pytest.mark.oracle @pytest.mark.execute def test_pipeline_e2e_oracle_tpch( @@ -219,7 +504,7 @@ def test_pipeline_e2e_oracle_tpch_custom( @pytest.mark.oracle @pytest.mark.execute def test_pipeline_e2e_oracle_defog_custom( - defog_custom_pipeline_test_data: PyDoughPandasTest, # noqa: F811 + defog_custom_oracle_test_data: PyDoughPandasTest, # noqa: F811 get_oracle_defog_graphs: graph_fetcher, defog_config: PyDoughConfigs, oracle_conn_db_context: Callable[[str], DatabaseContext], @@ -227,9 +512,9 @@ def test_pipeline_e2e_oracle_defog_custom( """ Test executing the defog analytical queries with Oracle database. """ - defog_custom_pipeline_test_data.run_e2e_test( + defog_custom_oracle_test_data.run_e2e_test( get_oracle_defog_graphs, - oracle_conn_db_context(defog_custom_pipeline_test_data.graph_name.lower()), + oracle_conn_db_context(defog_custom_oracle_test_data.graph_name.lower()), config=defog_config, coerce_types=True, ) diff --git a/tests/test_plan_refsols/simple_dataframe_collection_3.txt b/tests/test_plan_refsols/simple_dataframe_collection_3.txt index 42c974561..c4c6b6e5f 100644 --- a/tests/test_plan_refsols/simple_dataframe_collection_3.txt +++ b/tests/test_plan_refsols/simple_dataframe_collection_3.txt @@ -1,2 +1,2 @@ -ROOT(columns=[('user_id', user_id), ('"`name""["', "`name""["), ('"space country"', "space country"), ('"CAST"', "CAST")], orderings=[]) - GENERATED_TABLE(DataframeCollection(name='users', shape=(4, 4), columns=['user_id', '"`name""["', '"space country"', '"CAST"'])) +ROOT(columns=[('user_id', user_id), ('"`name\'["', "`name'["), ('"space country"', "space country"), ('"CAST"', "CAST")], orderings=[]) + GENERATED_TABLE(DataframeCollection(name='users', shape=(4, 4), columns=['user_id', '"`name\'["', '"space country"', '"CAST"'])) diff --git a/tests/test_pydough_functions/defog_test_functions.py b/tests/test_pydough_functions/defog_test_functions.py index 676b25821..e6e1e7e77 100644 --- a/tests/test_pydough_functions/defog_test_functions.py +++ b/tests/test_pydough_functions/defog_test_functions.py @@ -410,7 +410,10 @@ def impl_defog_broker_adv15(): n_active = SUM(customers.status == "active") n_custs = COUNT(customers) return ( - customers.WHERE((join_date >= "2022-01-01") & (join_date <= "2022-12-31")) + customers.WHERE( + (join_date >= DATETIME("2022-01-01")) + & (join_date <= DATETIME("2022-12-31")) + ) .PARTITION(name="countries", by=country) .CALCULATE( country, @@ -876,7 +879,7 @@ def impl_defog_dealership_adv9(): Sale Price in the first quarter of 2023. """ selected_sales = sales.WHERE( - (sale_date >= "2023-01-01") & (sale_date <= "2023-03-31") + (sale_date >= DATETIME("2023-01-01")) & (sale_date <= DATETIME("2023-03-31")) ) return Dealership.CALCULATE(ASP=AVG(selected_sales.sale_price)) diff --git a/tests/test_pydough_functions/user_collections.py b/tests/test_pydough_functions/user_collections.py index 8157d87ce..3298eb766 100644 --- a/tests/test_pydough_functions/user_collections.py +++ b/tests/test_pydough_functions/user_collections.py @@ -212,7 +212,7 @@ def simple_dataframe_collection_3(): df = pd.DataFrame( { "user_id": [1, 2, 3, 4], - '"`name""["': ["Alice", "Bob", "Charlie", "David"], + '"`name\'["': ["Alice", "Bob", "Charlie", "David"], '"space country"': ["US", "CR", "US", "MX"], '"CAST"': [25, 30, 22, 30], } diff --git a/tests/test_sql_refsols/agg_simplification_1_oracle.sql b/tests/test_sql_refsols/agg_simplification_1_oracle.sql index 550e70884..a61a7200e 100644 --- a/tests/test_sql_refsols/agg_simplification_1_oracle.sql +++ b/tests/test_sql_refsols/agg_simplification_1_oracle.sql @@ -183,7 +183,7 @@ SELECT 1 AS nd5, 1 AS nd6, 0 AS nd7, - CAST(NOT AUG_EXCHANGE IS NULL AS INT) AS nd8, + CASE WHEN NOT AUG_EXCHANGE IS NULL THEN 1 ELSE 0 END AS nd8, 1 AS av1, 2 AS av2, -1 AS av3, diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql index e3a9a96a3..5cad50b49 100644 --- a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -14,7 +14,7 @@ WITH "_S0" AS ( TRUNC(CAST(CAST("_S0".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER FROM "_S0" "_S0" JOIN "_T2" "_T2" - ON "_S0".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S0".CA_DT < TRUNC(ADD_MONTHS(CAST("_T2".PR_RELEASE AS DATE), 24), 'Q') AND "_S0".CA_DT >= "_T2".PR_RELEASE ), "_T5" AS ( SELECT @@ -36,7 +36,7 @@ WITH "_S0" AS ( COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID FROM "_S0" "_S2" JOIN "_T2" "_T4" - ON "_S2".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S2".CA_DT < TRUNC(ADD_MONTHS(CAST("_T4".PR_RELEASE AS DATE), 24), 'Q') AND "_S2".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.INCIDENTS INCIDENTS ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') @@ -52,7 +52,7 @@ WITH "_S0" AS ( COUNT(*) AS N_ROWS FROM "_S0" "_S14" JOIN "_T2" "_T8" - ON "_S14".CA_DT < TRUNC(CAST("_T8".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S14".CA_DT < TRUNC(ADD_MONTHS(CAST("_T8".PR_RELEASE AS DATE), 24), 'Q') AND "_S14".CA_DT >= "_T8".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') diff --git a/tests/test_sql_refsols/casting_functions_oracle.sql b/tests/test_sql_refsols/casting_functions_oracle.sql index 7cb6a8382..ef6fb19df 100644 --- a/tests/test_sql_refsols/casting_functions_oracle.sql +++ b/tests/test_sql_refsols/casting_functions_oracle.sql @@ -1,5 +1,5 @@ SELECT - TO_CHAR(o_orderdate, '%Y-%m-%d') AS cast_to_string, + TO_CHAR(o_orderdate, 'YYYY-MM-DD') AS cast_to_string, CAST(o_totalprice AS VARCHAR2(4000)) AS cast_to_string2, CAST(o_totalprice AS INT) AS cast_to_integer, CAST(o_shippriority AS DOUBLE PRECISION) AS cast_to_float diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql index e367f9353..f8dceeef7 100644 --- a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -23,9 +23,7 @@ WITH "_T1" AS ( FROM "_T1" "_T6" CROSS JOIN "_T4" "_T7" JOIN "_S3" "_S7" - ON "_S7".CA_DT < ( - CAST("_T7".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year') - ) + ON "_S7".CA_DT < ADD_MONTHS(CAST("_T7".PR_RELEASE AS DATE), 24) AND "_S7".CA_DT >= "_T7".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON "_S7".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') @@ -45,9 +43,7 @@ WITH "_T1" AS ( FROM "_T1" "_T3" CROSS JOIN "_T4" "_T4" JOIN "_S3" "_S3" - ON "_S3".CA_DT < ( - CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year') - ) + ON "_S3".CA_DT < ADD_MONTHS(CAST("_T4".PR_RELEASE AS DATE), 24) AND "_S3".CA_DT >= "_T4".PR_RELEASE LEFT JOIN "_S15" "_S15" ON "_S15".CA_DT = "_S3".CA_DT AND "_S15".CO_NAME = "_T3".CO_NAME diff --git a/tests/test_sql_refsols/country_x_year_combos_oracle.sql b/tests/test_sql_refsols/country_x_year_combos_oracle.sql index 135d25b33..017ac2cc0 100644 --- a/tests/test_sql_refsols/country_x_year_combos_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_combos_oracle.sql @@ -12,9 +12,7 @@ WITH "_T1" AS ( JOIN MAIN.PRODUCTS PRODUCTS ON PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.CALENDAR CALENDAR - ON CALENDAR.ca_dt < ( - CAST(PRODUCTS.pr_release AS DATE) + NUMTOYMINTERVAL(2, 'year') - ) + ON CALENDAR.ca_dt < ADD_MONTHS(CAST(PRODUCTS.pr_release AS DATE), 24) AND CALENDAR.ca_dt >= PRODUCTS.pr_release ) SELECT diff --git a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql index c8150fb30..cef83a2c8 100644 --- a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql @@ -7,6 +7,22 @@ SELECT ALLDATATYPES.NULL_COL AS null_col, ALLDATATYPES.DATETIME_COL AS datetime_col FROM (VALUES - ('red', 0, 1.5, 1.0, 1, NULL, CAST('2024-01-01 00:00:00' AS TIMESTAMP)), - ('orange', 1, 2.0, NULL, 0, NULL, CAST('2024-01-02 00:00:00' AS TIMESTAMP)), + ( + 'red', + 0, + 1.5, + 1.0, + 1, + NULL, + TO_TIMESTAMP('2024-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') + ), + ( + 'orange', + 1, + 2.0, + NULL, + 0, + NULL, + TO_TIMESTAMP('2024-01-02 00:00:00', 'YYYY-MM-DD HH24:MI:SS') + ), (NULL, 2, NULL, 7.0, 0, NULL, NULL)) AS ALLDATATYPES(STRING_COL, INT_COL, FLOAT_COL, NULLABLE_INT_COL, BOOL_COL, NULL_COL, DATETIME_COL) diff --git a/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql index cd7c5e567..c3609b090 100644 --- a/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql @@ -5,5 +5,5 @@ SELECT FROM (VALUES (1.5, -2.25, 0.0), (NULL, NULL, NULL), - ('Infinity', 'Infinity', 'Infinity'), - ('-Infinity', '-Infinity', '-Infinity')) AS INFINTY(PY_FLOAT, NP_FLOAT64, NP_FLOAT32) + (BINARY_DOUBLE_INFINITY, BINARY_DOUBLE_INFINITY, BINARY_DOUBLE_INFINITY), + (-BINARY_DOUBLE_INFINITY, -BINARY_DOUBLE_INFINITY, -BINARY_DOUBLE_INFINITY)) AS INFINTY(PY_FLOAT, NP_FLOAT64, NP_FLOAT32) diff --git a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql index 92abede51..8cda8283b 100644 --- a/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql @@ -4,18 +4,18 @@ SELECT FROM (VALUES ( 'Clerk#000000456', - CAST('1996-01-01 00:00:00' AS TIMESTAMP), - CAST('1996-02-01 00:00:00' AS TIMESTAMP) + TO_TIMESTAMP('1996-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_TIMESTAMP('1996-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ), ( 'Clerk#000000743', - CAST('1995-06-01 00:00:00' AS TIMESTAMP), - CAST('1995-07-01 00:00:00' AS TIMESTAMP) + TO_TIMESTAMP('1995-06-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_TIMESTAMP('1995-07-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ), ( 'Clerk#000000547', - CAST('1995-11-01 00:00:00' AS TIMESTAMP), - CAST('1995-12-01 00:00:00' AS TIMESTAMP) + TO_TIMESTAMP('1995-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), + TO_TIMESTAMP('1995-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') )) AS DATES(CLERK_ID, START_DATE, END_DATE) JOIN TPCH.ORDERS ORDERS ON DATES.CLERK_ID = ORDERS.o_clerk diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql index 9f5959909..4eafeecbc 100644 --- a/tests/test_sql_refsols/datetime_current_oracle.sql +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -1,5 +1,5 @@ SELECT - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTOYMINTERVAL(5, 'month') - NUMTODSINTERVAL(1, 'day') AS d1, + ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), 5) - NUMTODSINTERVAL(1, 'day') AS d1, TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(24, 'hour') AS d2, TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') + NUMTODSINTERVAL(12, 'hour') - NUMTODSINTERVAL(150, 'minute') + NUMTODSINTERVAL(2, 'second') AS d3 FROM (VALUES diff --git a/tests/test_sql_refsols/datetime_relative_oracle.sql b/tests/test_sql_refsols/datetime_relative_oracle.sql index 9be5cdcea..37c10147c 100644 --- a/tests/test_sql_refsols/datetime_relative_oracle.sql +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -10,7 +10,7 @@ WITH "_T0" AS ( SELECT TRUNC(CAST(O_ORDERDATE AS DATE), 'YEAR') AS d1, TRUNC(CAST(O_ORDERDATE AS DATE), 'MONTH') AS d2, - CAST(O_ORDERDATE AS DATE) - NUMTOYMINTERVAL(11, 'year') + NUMTOYMINTERVAL(9, 'month') - NUMTODSINTERVAL(7, 'day') + NUMTODSINTERVAL(5, 'hour') - NUMTODSINTERVAL(3, 'minute') + NUMTODSINTERVAL(1, 'second') AS d3, + ADD_MONTHS(ADD_MONTHS(CAST(O_ORDERDATE AS DATE), -132), 9) - NUMTODSINTERVAL(7, 'day') + NUMTODSINTERVAL(5, 'hour') - NUMTODSINTERVAL(3, 'minute') + NUMTODSINTERVAL(1, 'second') AS d3, TO_DATE('2025-07-04 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS d4, TO_DATE('2025-07-04 12:58:00', 'YYYY-MM-DD HH24:MI:SS') AS d5, TO_DATE('2025-07-26 02:45:25', 'YYYY-MM-DD HH24:MI:SS') AS d6 diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql index 4b76375cb..6aa41f47d 100644 --- a/tests/test_sql_refsols/datetime_sampler_oracle.sql +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -20,23 +20,29 @@ SELECT SYS_EXTRACT_UTC(SYSTIMESTAMP) AS "_expr18", CAST(o_orderdate AS DATE) AS "_expr19", TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) AS "_expr20", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTODSINTERVAL(8, 'minute') - NUMTOYMINTERVAL(141, 'month') AS "_expr21", + ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') + NUMTODSINTERVAL(8, 'minute'), -141) AS "_expr21", TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), SECOND), HOUR) AS "_expr22", TIMESTAMP_TRUNC( TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), HOUR), SECOND), HOUR ) AS "_expr23", - SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(96, 'hour') + NUMTOYMINTERVAL(15, 'year') AS "_expr24", - TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') - NUMTOYMINTERVAL(3, 'year'), MINUTE) + NUMTOYMINTERVAL(65, 'month') AS "_expr25", + ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(96, 'hour'), 180) AS "_expr24", + ADD_MONTHS( + TIMESTAMP_TRUNC(ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), -36), MINUTE), + 65 + ) AS "_expr25", TRUNC(CAST(o_orderdate AS DATE) - NUMTODSINTERVAL(56, 'hour'), 'YEAR') AS "_expr26", TIMESTAMP_TRUNC( TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(63, 'day'), MINUTE), SECOND ) AS "_expr27", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AS "_expr28", - TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(312, 'hour'), SECOND) + NUMTOYMINTERVAL(48, 'year') AS "_expr29", + ADD_MONTHS( + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(312, 'hour'), SECOND), + 576 + ) AS "_expr29", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(75, 'day'), 'DAY') + NUMTODSINTERVAL(600, 'minute') - NUMTODSINTERVAL(294, 'day') AS "_expr30", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTOYMINTERVAL(480, 'month') - NUMTOYMINTERVAL(45, 'year') AS "_expr31", + ADD_MONTHS(ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), 480), -540) AS "_expr31", TIMESTAMP_TRUNC( TRUNC( SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(270, 'minute') - NUMTODSINTERVAL(34, 'second'), @@ -45,7 +51,7 @@ SELECT SECOND ) AS "_expr32", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(213, 'second') AS "_expr33", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(13, 'minute') + NUMTOYMINTERVAL(28, 'year') + NUMTODSINTERVAL(344, 'second') AS "_expr34", + ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(13, 'minute'), 336) + NUMTODSINTERVAL(344, 'second') AS "_expr34", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') AS "_expr35", TO_DATE('2116-01-01 00:49:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr36", TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), 'DAY') AS "_expr37", @@ -56,14 +62,14 @@ SELECT CAST(o_orderdate AS DATE) + NUMTODSINTERVAL(82, 'second') + NUMTODSINTERVAL(415, 'second') - NUMTODSINTERVAL(160, 'second'), 'YEAR' ) AS "_expr41", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(192, 'month') AS "_expr42", + ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), 192) AS "_expr42", TIMESTAMP_TRUNC( TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), HOUR), MINUTE), HOUR ) + NUMTODSINTERVAL(486, 'minute') AS "_expr43", TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) - NUMTODSINTERVAL(50, 'hour') AS "_expr44", TIMESTAMP_TRUNC( - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day') + NUMTOYMINTERVAL(72, 'month') - NUMTOYMINTERVAL(92, 'month'), + ADD_MONTHS(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day'), 72), -92), HOUR ) AS "_expr45", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(285, 'second'), 'DAY') AS "_expr46", @@ -72,10 +78,13 @@ SELECT TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(1, 'hour'), 'MONTH' ) - NUMTODSINTERVAL(21, 'day') AS "_expr48", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(212, 'minute') + NUMTOYMINTERVAL(368, 'year') AS "_expr49", + ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(212, 'minute'), 4416) AS "_expr49", TO_DATE('2024-01-01', 'YYYY-MM-DD') AS "_expr50", TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr51", - TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(60, 'hour'), 'DAY'), MINUTE) + NUMTOYMINTERVAL(196, 'year') AS "_expr52", + ADD_MONTHS( + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(60, 'hour'), 'DAY'), MINUTE), + 2352 + ) AS "_expr52", TIMESTAMP_TRUNC( SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(40, 'hour') - NUMTODSINTERVAL(385, 'day'), MINUTE @@ -84,13 +93,19 @@ SELECT TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(405, 'day'), HOUR), MINUTE ) AS "_expr54", - TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), SECOND) + NUMTOYMINTERVAL(98, 'year') + NUMTOYMINTERVAL(96, 'month') AS "_expr55", + ADD_MONTHS( + ADD_MONTHS(TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), SECOND), 1176), + 96 + ) AS "_expr55", TRUNC( TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), MINUTE), SECOND), 'DAY' ) + NUMTODSINTERVAL(78, 'second') AS "_expr56", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(136, 'hour') + NUMTODSINTERVAL(104, 'minute') - NUMTOYMINTERVAL(104, 'month') + NUMTODSINTERVAL(312, 'day') AS "_expr57", - SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTOYMINTERVAL(45, 'month') - NUMTODSINTERVAL(135, 'second') AS "_expr58", + ADD_MONTHS( + SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(136, 'hour') + NUMTODSINTERVAL(104, 'minute'), + -104 + ) + NUMTODSINTERVAL(312, 'day') AS "_expr57", + ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), 45) - NUMTODSINTERVAL(135, 'second') AS "_expr58", EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr59", 2025 AS "_expr60", 1999 AS "_expr61", diff --git a/tests/test_sql_refsols/defog_broker_adv15_ansi.sql b/tests/test_sql_refsols/defog_broker_adv15_ansi.sql index 45af26175..eb43f63bd 100644 --- a/tests/test_sql_refsols/defog_broker_adv15_ansi.sql +++ b/tests/test_sql_refsols/defog_broker_adv15_ansi.sql @@ -5,6 +5,7 @@ SELECT ) AS ar FROM main.sbcustomer WHERE - sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' + sbcustjoindate <= CAST('2022-12-31' AS DATE) + AND sbcustjoindate >= CAST('2022-01-01' AS DATE) GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_broker_adv15_mysql.sql b/tests/test_sql_refsols/defog_broker_adv15_mysql.sql index a3b663b87..fa60719bd 100644 --- a/tests/test_sql_refsols/defog_broker_adv15_mysql.sql +++ b/tests/test_sql_refsols/defog_broker_adv15_mysql.sql @@ -5,6 +5,7 @@ SELECT ) AS ar FROM broker.sbCustomer WHERE - sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' + sbcustjoindate <= CAST('2022-12-31' AS DATE) + AND sbcustjoindate >= CAST('2022-01-01' AS DATE) GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_broker_adv15_oracle.sql b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql index 6dc913b6b..27e8a3575 100644 --- a/tests/test_sql_refsols/defog_broker_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql @@ -5,6 +5,7 @@ SELECT ) AS ar FROM MAIN.SBCUSTOMER WHERE - sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' + sbcustjoindate <= TO_DATE('2022-12-31', 'YYYY-MM-DD') + AND sbcustjoindate >= TO_DATE('2022-01-01', 'YYYY-MM-DD') GROUP BY sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_adv15_postgres.sql b/tests/test_sql_refsols/defog_broker_adv15_postgres.sql index 1efbf9c6c..85ddeee09 100644 --- a/tests/test_sql_refsols/defog_broker_adv15_postgres.sql +++ b/tests/test_sql_refsols/defog_broker_adv15_postgres.sql @@ -5,6 +5,7 @@ SELECT ) AS ar FROM main.sbcustomer WHERE - sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' + sbcustjoindate <= CAST('2022-12-31' AS DATE) + AND sbcustjoindate >= CAST('2022-01-01' AS DATE) GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_broker_adv15_snowflake.sql b/tests/test_sql_refsols/defog_broker_adv15_snowflake.sql index ea95536a3..9e53cb4d3 100644 --- a/tests/test_sql_refsols/defog_broker_adv15_snowflake.sql +++ b/tests/test_sql_refsols/defog_broker_adv15_snowflake.sql @@ -5,6 +5,7 @@ SELECT ) AS ar FROM broker.sbcustomer WHERE - sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' + sbcustjoindate <= CAST('2022-12-31' AS DATE) + AND sbcustjoindate >= CAST('2022-01-01' AS DATE) GROUP BY 1 diff --git a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql index 2ffb787a7..f2dbb53c9 100644 --- a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -5,9 +5,7 @@ WITH "_S1" AS ( SUM(sbtxamount) AS SUM_SBTXAMOUNT FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= ( - SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(1, 'month') - ) + sbtxdatetime >= ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1) AND sbtxtype = 'sell' GROUP BY sbtxtickerid diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql index 0dbda290c..489047f63 100644 --- a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -28,7 +28,7 @@ WITH "_S2" AS ( FROM MAIN.SBCUSTOMER WHERE sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'MONTH') + AND sbcustjoindate >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'MONTH') GROUP BY LTRIM( NVL2( @@ -94,7 +94,7 @@ WITH "_S2" AS ( AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid WHERE SBCUSTOMER.sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'MONTH') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'MONTH') GROUP BY LTRIM( NVL2( diff --git a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql index 9cc04cf97..ed0cae9f2 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql @@ -2,12 +2,12 @@ WITH "_S6" AS ( SELECT DISTINCT MONTHS_RANGE.MONTH_START FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS MONTHS_RANGE(MONTH_START) + (TO_TIMESTAMP('2025-08-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE(MONTH_START) CROSS JOIN MAIN.SALES SALES ), "_S7" AS ( SELECT @@ -15,14 +15,14 @@ WITH "_S6" AS ( COUNT(*) AS N_ROWS, SUM(SALES.sale_price) AS SUM_SALE_PRICE FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS MONTHS_RANGE_2(MONTH_START) + (TO_TIMESTAMP('2025-08-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE_2(MONTH_START) JOIN MAIN.SALES SALES - ON TO_CHAR(MONTHS_RANGE_2.MONTH_START, '%Y-%m') = TO_CHAR(SALES.sale_date, '%Y-%m') + ON TO_CHAR(MONTHS_RANGE_2.MONTH_START, 'YYYY-MM') = TO_CHAR(SALES.sale_date, 'YYYY-MM') JOIN MAIN.SALESPERSONS SALESPERSONS ON EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) <= 2023 AND EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) >= 2022 @@ -31,7 +31,7 @@ WITH "_S6" AS ( MONTHS_RANGE_2.MONTH_START ) SELECT - TO_CHAR("_S6".MONTH_START, '%Y-%m-%d') AS month, + TO_CHAR("_S6".MONTH_START, 'YYYY-MM-DD') AS month, COALESCE("_S7".N_ROWS, 0) AS PMSPS, COALESCE("_S7".SUM_SALE_PRICE, 0) AS PMSR FROM "_S6" "_S6" diff --git a/tests/test_sql_refsols/defog_dealership_adv9_ansi.sql b/tests/test_sql_refsols/defog_dealership_adv9_ansi.sql index a581d84e5..42bb49481 100644 --- a/tests/test_sql_refsols/defog_dealership_adv9_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_adv9_ansi.sql @@ -2,4 +2,5 @@ SELECT AVG(sale_price) AS ASP FROM main.sales WHERE - sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' + sale_date <= CAST('2023-03-31' AS DATE) + AND sale_date >= CAST('2023-01-01' AS DATE) diff --git a/tests/test_sql_refsols/defog_dealership_adv9_mysql.sql b/tests/test_sql_refsols/defog_dealership_adv9_mysql.sql index c696ac1b6..1c2a030af 100644 --- a/tests/test_sql_refsols/defog_dealership_adv9_mysql.sql +++ b/tests/test_sql_refsols/defog_dealership_adv9_mysql.sql @@ -2,4 +2,5 @@ SELECT AVG(sale_price) AS ASP FROM dealership.sales WHERE - sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' + sale_date <= CAST('2023-03-31' AS DATE) + AND sale_date >= CAST('2023-01-01' AS DATE) diff --git a/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql index ffee74ac5..27040b869 100644 --- a/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql @@ -2,4 +2,5 @@ SELECT AVG(sale_price) AS ASP FROM MAIN.SALES WHERE - sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' + sale_date <= TO_DATE('2023-03-31', 'YYYY-MM-DD') + AND sale_date >= TO_DATE('2023-01-01', 'YYYY-MM-DD') diff --git a/tests/test_sql_refsols/defog_dealership_adv9_postgres.sql b/tests/test_sql_refsols/defog_dealership_adv9_postgres.sql index fb43ea8ba..941cbdadf 100644 --- a/tests/test_sql_refsols/defog_dealership_adv9_postgres.sql +++ b/tests/test_sql_refsols/defog_dealership_adv9_postgres.sql @@ -2,4 +2,5 @@ SELECT AVG(CAST(sale_price AS DECIMAL)) AS ASP FROM main.sales WHERE - sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' + sale_date <= CAST('2023-03-31' AS DATE) + AND sale_date >= CAST('2023-01-01' AS DATE) diff --git a/tests/test_sql_refsols/defog_dealership_adv9_snowflake.sql b/tests/test_sql_refsols/defog_dealership_adv9_snowflake.sql index c696ac1b6..1c2a030af 100644 --- a/tests/test_sql_refsols/defog_dealership_adv9_snowflake.sql +++ b/tests/test_sql_refsols/defog_dealership_adv9_snowflake.sql @@ -2,4 +2,5 @@ SELECT AVG(sale_price) AS ASP FROM dealership.sales WHERE - sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' + sale_date <= CAST('2023-03-31' AS DATE) + AND sale_date >= CAST('2023-01-01' AS DATE) diff --git a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql index 7b1f68be0..2118a6099 100644 --- a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql @@ -5,9 +5,7 @@ WITH "_S1" AS ( SUM(sale_price) AS SUM_SALE_PRICE FROM MAIN.SALES WHERE - sale_date >= ( - SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(3, 'month') - ) + sale_date >= ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -3) GROUP BY salesperson_id ) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql index 0f96dca36..517536534 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql @@ -6,6 +6,4 @@ JOIN MAIN.PATIENTS PATIENTS AND PATIENTS.patient_id = TREATMENTS.patient_id WHERE TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND TREATMENTS.start_dt >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(6, 'month') - ) + AND TREATMENTS.start_dt >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -6) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql index a94cf5354..ad21117e3 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -5,9 +5,7 @@ WITH "_T0" AS ( COUNT(DISTINCT diag_id) AS NDISTINCT_DIAG_ID FROM MAIN.TREATMENTS WHERE - ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(12, 'month') - ) <= TRUNC(CAST(start_dt AS DATE), 'MONTH') + ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -12) <= TRUNC(CAST(start_dt AS DATE), 'MONTH') AND TRUNC(CAST(start_dt AS DATE), 'MONTH') < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') GROUP BY TRUNC(CAST(start_dt AS DATE), 'MONTH') diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql index eb69de4e5..181e04dcc 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -28,9 +28,7 @@ WITH "_S2" AS ( FROM MAIN.TREATMENTS WHERE start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND start_dt >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(3, 'month') - ) + AND start_dt >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -3) GROUP BY LTRIM( NVL2( @@ -88,9 +86,7 @@ WITH "_S2" AS ( ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'biologic' WHERE TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND TREATMENTS.start_dt >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(3, 'month') - ) + AND TREATMENTS.start_dt >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -3) GROUP BY LTRIM( NVL2( diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql index d397485fc..2aac034cf 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( SUM(tot_drug_amt) AS SUM_TOT_DRUG_AMT FROM MAIN.TREATMENTS WHERE - start_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'DAY') + start_dt >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DAY') GROUP BY doc_id ), "_T1" AS ( diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql index 914245f47..c43c42ec6 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql @@ -23,4 +23,4 @@ FROM MAIN.DOCTORS DOCTORS LEFT JOIN "_S1" "_S1" ON DOCTORS.doc_id = "_S1".DOC_ID WHERE - DOCTORS.year_reg = EXTRACT(YEAR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(2, 'year') AS DATE)) + DOCTORS.year_reg = EXTRACT(YEAR FROM CAST(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -24) AS DATE)) diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql index fb6cf1a7c..2e8be9f05 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql @@ -8,4 +8,4 @@ JOIN MAIN.DRUGS DRUGS ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT DRUGS.fda_appr_dt IS NULL WHERE NOT TREATMENTS.end_dt IS NULL - AND TREATMENTS.end_dt >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(6, 'month'), 'DAY') + AND TREATMENTS.end_dt >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql index 9049c3403..4eb15856c 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql @@ -2,5 +2,5 @@ SELECT COUNT(*) AS TUC FROM MAIN.USER_SESSIONS WHERE - session_end_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(1, 'month'), 'DAY') - OR session_start_ts >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTOYMINTERVAL(1, 'month'), 'DAY') + session_end_ts >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1), 'DAY') + OR session_start_ts >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql index 3802cf8a0..225ded5c7 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql @@ -4,9 +4,7 @@ SELECT FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - AND created_at >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') - NUMTOYMINTERVAL(2, 'month') - ) + AND created_at >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -2) AND sender_type = 0 GROUP BY TRUNC(CAST(created_at AS DATE), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql index 554fab250..920b63623 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql @@ -33,6 +33,4 @@ SELECT FROM "_S4" "_S4" JOIN "_T1" "_S5" ON "_S4".MID = "_S5".MERCHANT_ID - AND "_S5".START_DATE <= ( - CAST("_S4".ANYTHING_CREATED_AT AS DATE) + NUMTOYMINTERVAL(1, 'year') - ) + AND "_S5".START_DATE <= ADD_MONTHS(CAST("_S4".ANYTHING_CREATED_AT AS DATE), 12) diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql index bf62ab576..860d41dff 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -3,9 +3,7 @@ WITH "_u_0" AS ( NOTIFICATIONS.user_id AS "_u_1" FROM MAIN.NOTIFICATIONS NOTIFICATIONS JOIN MAIN.USERS USERS - ON NOTIFICATIONS.created_at <= ( - CAST(USERS.created_at AS DATE) + NUMTOYMINTERVAL(1, 'year') - ) + ON NOTIFICATIONS.created_at <= ADD_MONTHS(CAST(USERS.created_at AS DATE), 12) AND NOTIFICATIONS.created_at >= USERS.created_at AND NOTIFICATIONS.user_id = USERS.uid GROUP BY diff --git a/tests/test_sql_refsols/part_reduced_size_oracle.sql b/tests/test_sql_refsols/part_reduced_size_oracle.sql index 9584a7c35..d46b70223 100644 --- a/tests/test_sql_refsols/part_reduced_size_oracle.sql +++ b/tests/test_sql_refsols/part_reduced_size_oracle.sql @@ -20,9 +20,9 @@ SELECT '' ) AS message, LINEITEM.l_discount AS discount, - TO_CHAR(LINEITEM.l_receiptdate, '%d-%m-%Y') AS date_dmy, - TO_CHAR(LINEITEM.l_receiptdate, '%m/%d') AS date_md, - TO_CHAR(LINEITEM.l_receiptdate, '%H:%M%p') AS am_pm + TO_CHAR(LINEITEM.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, + TO_CHAR(LINEITEM.l_receiptdate, 'MM/DD') AS date_md, + TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MI%p') AS am_pm FROM "_S0" "_S0" JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_partkey = "_S0".P_PARTKEY diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql index 62fc43935..ec177ba9e 100644 --- a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -15,7 +15,7 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T4" JOIN "_S1" "_S3" - ON "_S3".CA_DT < TRUNC(CAST("_T4".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S3".CA_DT < TRUNC(ADD_MONTHS(CAST("_T4".PR_RELEASE AS DATE), 24), 'Q') AND "_S3".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON DEVICES.de_product_id = 800544 @@ -28,7 +28,7 @@ WITH "_T2" AS ( SUM("_S7".N_ROWS) AS SUM_N_ROWS FROM "_T2" "_T2" JOIN "_S1" "_S1" - ON "_S1".CA_DT < TRUNC(CAST("_T2".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S1".CA_DT < TRUNC(ADD_MONTHS(CAST("_T2".PR_RELEASE AS DATE), 24), 'Q') AND "_S1".CA_DT >= "_T2".PR_RELEASE LEFT JOIN "_S7" "_S7" ON "_S1".CA_DT = "_S7".CA_DT @@ -39,14 +39,14 @@ WITH "_T2" AS ( TRUNC(CAST(CAST("_S11".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER FROM "_T2" "_T10" JOIN "_S1" "_S11" - ON "_S11".CA_DT < TRUNC(CAST("_T10".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S11".CA_DT < TRUNC(ADD_MONTHS(CAST("_T10".PR_RELEASE AS DATE), 24), 'Q') AND "_S11".CA_DT >= "_T10".PR_RELEASE ), "_S17" AS ( SELECT "_S15".CA_DT FROM "_T2" "_T11" JOIN "_S1" "_S15" - ON "_S15".CA_DT < TRUNC(CAST("_T11".PR_RELEASE AS DATE) + NUMTOYMINTERVAL(2, 'year'), 'Q') + ON "_S15".CA_DT < TRUNC(ADD_MONTHS(CAST("_T11".PR_RELEASE AS DATE), 24), 'Q') AND "_S15".CA_DT >= "_T11".PR_RELEASE ), "_S23" AS ( SELECT diff --git a/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql index 5ef009803..921c1a653 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql @@ -2,7 +2,7 @@ SELECT USERS.SIGNUP_DATE AS signup_date, USERS.USER_ID AS user_id FROM (VALUES - (CAST('2024-01-10 00:00:00' AS TIMESTAMP), 1), - (CAST('2024-01-12 00:00:00' AS TIMESTAMP), 2), - (CAST('2024-02-01 00:00:00' AS TIMESTAMP), 3), - (CAST('2024-02-01 00:00:00' AS TIMESTAMP), 4)) AS USERS(SIGNUP_DATE, USER_ID) + (TO_TIMESTAMP('2024-01-10 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), 1), + (TO_TIMESTAMP('2024-01-12 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), 2), + (TO_TIMESTAMP('2024-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), 3), + (TO_TIMESTAMP('2024-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), 4)) AS USERS(SIGNUP_DATE, USER_ID) diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_ansi.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_ansi.sql index eabb54fcf..d2f11cb51 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_ansi.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_ansi.sql @@ -1,10 +1,10 @@ SELECT column1 AS user_id, - column2 AS "`name""[", + column2 AS "`name'[", column3 AS "space country", column4 AS "CAST" FROM (VALUES (1, 'Alice', 'US', 25), (2, 'Bob', 'CR', 30), (3, 'Charlie', 'US', 22), - (4, 'David', 'MX', 30)) AS users(user_id, "`name""[", "space country", "CAST") + (4, 'David', 'MX', 30)) AS users(user_id, "`name'[", "space country", "CAST") diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_mysql.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_mysql.sql index 5adf8ccf9..627be97d3 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_mysql.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_mysql.sql @@ -1,10 +1,10 @@ SELECT users.user_id, - users.```name"[`, + users.```name'[`, users.`space country`, users.`CAST` FROM (VALUES ROW(1, 'Alice', 'US', 25), ROW(2, 'Bob', 'CR', 30), ROW(3, 'Charlie', 'US', 22), - ROW(4, 'David', 'MX', 30)) AS users(user_id, ```name"[`, `space country`, `CAST`) + ROW(4, 'David', 'MX', 30)) AS users(user_id, ```name'[`, `space country`, `CAST`) diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql index d17ed0d63..9e681da2b 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql @@ -1,10 +1,10 @@ SELECT USERS.USER_ID AS user_id, - USERS."`name""[", + USERS."`name'[", USERS."space country", USERS."CAST" FROM (VALUES (1, 'Alice', 'US', 25), (2, 'Bob', 'CR', 30), (3, 'Charlie', 'US', 22), - (4, 'David', 'MX', 30)) AS USERS(USER_ID, "`name""[", "space country", "CAST") + (4, 'David', 'MX', 30)) AS USERS(USER_ID, "`name'[", "space country", "CAST") diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_postgres.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_postgres.sql index d258a4ab5..b1eafe483 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_postgres.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_postgres.sql @@ -1,10 +1,10 @@ SELECT users.user_id, - users."`name""[", + users."`name'[", users."space country", users."CAST" FROM (VALUES (1, 'Alice', 'US', 25), (2, 'Bob', 'CR', 30), (3, 'Charlie', 'US', 22), - (4, 'David', 'MX', 30)) AS users(user_id, "`name""[", "space country", "CAST") + (4, 'David', 'MX', 30)) AS users(user_id, "`name'[", "space country", "CAST") diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_snowflake.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_snowflake.sql index d258a4ab5..b1eafe483 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_snowflake.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_snowflake.sql @@ -1,10 +1,10 @@ SELECT users.user_id, - users."`name""[", + users."`name'[", users."space country", users."CAST" FROM (VALUES (1, 'Alice', 'US', 25), (2, 'Bob', 'CR', 30), (3, 'Charlie', 'US', 22), - (4, 'David', 'MX', 30)) AS users(user_id, "`name""[", "space country", "CAST") + (4, 'David', 'MX', 30)) AS users(user_id, "`name'[", "space country", "CAST") diff --git a/tests/test_sql_refsols/simple_dataframe_collection_3_sqlite.sql b/tests/test_sql_refsols/simple_dataframe_collection_3_sqlite.sql index fb3af1894..f00733178 100644 --- a/tests/test_sql_refsols/simple_dataframe_collection_3_sqlite.sql +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_sqlite.sql @@ -1,6 +1,6 @@ SELECT users.column1 AS user_id, - users.column2 AS "`name""[", + users.column2 AS "`name'[", users.column3 AS "space country", users.column4 AS "CAST" FROM (VALUES diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql index a47cceb5c..9e072b6cf 100644 --- a/tests/test_sql_refsols/smoke_b_oracle.sql +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -68,8 +68,8 @@ SELECT ), ':' ) AS b, - TRUNC(CAST(o_orderdate AS DATE), 'YEAR') + NUMTOYMINTERVAL(6, 'month') - NUMTODSINTERVAL(13, 'day') AS c, - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'Q') + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(25, 'hour') AS d, + ADD_MONTHS(TRUNC(CAST(o_orderdate AS DATE), 'YEAR'), 6) - NUMTODSINTERVAL(13, 'day') AS c, + ADD_MONTHS(TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'Q'), 12) + NUMTODSINTERVAL(25, 'hour') AS d, TO_DATE('2025-01-01 12:35:00', 'YYYY-MM-DD HH24:MI:SS') AS e, TO_DATE('2025-07-22 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS f, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql index a3b390900..1f3c0bd39 100644 --- a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -17,9 +17,7 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T4" JOIN MAIN.CALENDAR CALENDAR - ON CALENDAR.ca_dt >= ( - CAST("_T4".CA_DT AS DATE) - NUMTOYMINTERVAL(6, 'month') - ) + ON CALENDAR.ca_dt >= ADD_MONTHS(CAST("_T4".CA_DT AS DATE), -6) JOIN MAIN.DEVICES DEVICES ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') JOIN "_T5" "_T5" diff --git a/tests/test_sql_refsols/week_offset_oracle.sql b/tests/test_sql_refsols/week_offset_oracle.sql index 503f46793..388e7c187 100644 --- a/tests/test_sql_refsols/week_offset_oracle.sql +++ b/tests/test_sql_refsols/week_offset_oracle.sql @@ -6,8 +6,8 @@ SELECT CAST(sbtxdatetime AS DATE) - NUMTODSINTERVAL(1, 'second') + NUMTODSINTERVAL(14, 'DAY') AS week_adj4, CAST(sbtxdatetime AS DATE) + NUMTODSINTERVAL(1, 'day') + NUMTODSINTERVAL(14, 'DAY') AS week_adj5, CAST(sbtxdatetime AS DATE) - NUMTODSINTERVAL(1, 'minute') + NUMTODSINTERVAL(14, 'DAY') AS week_adj6, - CAST(sbtxdatetime AS DATE) + NUMTOYMINTERVAL(1, 'month') + NUMTODSINTERVAL(14, 'DAY') AS week_adj7, - CAST(sbtxdatetime AS DATE) + NUMTOYMINTERVAL(1, 'year') + NUMTODSINTERVAL(14, 'DAY') AS week_adj8 + ADD_MONTHS(CAST(sbtxdatetime AS DATE), 1) + NUMTODSINTERVAL(14, 'DAY') AS week_adj7, + ADD_MONTHS(CAST(sbtxdatetime AS DATE), 12) + NUMTODSINTERVAL(14, 'DAY') AS week_adj8 FROM MAIN.SBTRANSACTION WHERE EXTRACT(DAY FROM CAST(sbtxdatetime AS DATE)) > 1 From b6acba4a8db909f4f2f52ef2a95aeb4e8305b4f8 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 2 Mar 2026 12:48:21 -0600 Subject: [PATCH 21/48] get part implementation --- .../oracle_transform_bindings.py | 189 ++++++++++++++---- 1 file changed, 152 insertions(+), 37 deletions(-) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index 64728074b..a2cc80334 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -309,16 +309,46 @@ def convert_get_part( ) -> SQLGlotExpression: """ GETPART(str, delim, idx) -> - REGEXP_SUBSTR( - str, - '[^' || delim || ']+', - 1, - CASE - WHEN idx = 0 THEN 1 - WHEN idx > 0 THEN idx - ELSE (REGEXP_COUNT(str, delim) + 1) + idx + 1 - END - ) + CASE + WHEN delim IS NULL OR delim = '' THEN + CASE + WHEN idx = 1 THEN str + ELSE NULL + END + ELSE + REGEXP_SUBSTR( + str, + '(.*?)(' || REGEXP_REPLACE(delim, '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN + CASE + WHEN idx = 0 THEN 1 + WHEN idx > 0 THEN idx + ELSE + ( + ((LENGTH(str) - LENGTH(REPLACE(str, delim))) / LENGTH(delim)) + 1 + ) + idx + 1 + END + BETWEEN 1 AND + ( + ((LENGTH(str) - LENGTH(REPLACE(str, delim))) / LENGTH(delim)) + 1 + ) + THEN + CASE + WHEN idx > 0 + THEN idx + ELSE + ( + ((LENGTH(str) - LENGTH(REPLACE(str, delim))) / LENGTH(delim)) + 1 + ) + idx + 1 + END + ELSE NULL + END, + NULL, + 1 + ) + END """ assert len(args) == 3 @@ -326,52 +356,137 @@ def convert_get_part( string_expr, delimiter_expr, index_expr = args literal_0: SQLGlotExpression = sqlglot_expressions.Literal.number(0) literal_1: SQLGlotExpression = sqlglot_expressions.Literal.number(1) - regex_1: SQLGlotExpression = sqlglot_expressions.Literal.string("[^") - regex_2: SQLGlotExpression = sqlglot_expressions.Literal.string("]+") - case_expr: SQLGlotExpression = sqlglot_expressions.Case( + regexp_1: SQLGlotExpression = sqlglot_expressions.Literal.string("(.*?)(") + replace_chars: SQLGlotExpression = sqlglot_expressions.Literal.string( + "([][(){}.*+?^$|\\#-])" + ) + regexp_2: SQLGlotExpression = sqlglot_expressions.Literal.string("|$)") + + delim_regexp: SQLGlotExpression = sqlglot_expressions.DPipe( + this=regexp_1, + expression=sqlglot_expressions.DPipe( + this=sqlglot_expressions.RegexpReplace( + this=delimiter_expr, + expression=replace_chars, + replacement=sqlglot_expressions.Literal.string("\\\\\\1"), + ), + expression=regexp_2, + ), + ) + + # ((LENGTH(str) - LENGTH(REPLACE(str, delim))) / LENGTH(delim)) + 1 + parts: SQLGlotExpression = sqlglot_expressions.Add( + this=apply_parens( + sqlglot_expressions.Div( + this=apply_parens( + sqlglot_expressions.Sub( + this=sqlglot_expressions.Length(this=string_expr), + expression=sqlglot_expressions.Length( + this=sqlglot_expressions.Anonymous( + this="REPLACE", + expressions=[string_expr, delimiter_expr], + ) + ), + ) + ), + expression=sqlglot_expressions.Length(this=delimiter_expr), + ) + ), + expression=literal_1, + ) + + # (parts) + idx + 1 + occurrences: SQLGlotExpression = sqlglot_expressions.Add( + this=apply_parens(parts), + expression=sqlglot_expressions.Add( + this=apply_parens(index_expr), expression=literal_1 + ), + ) + + # CASE + # WHEN idx = 0 THEN 1 + # WHEN idx > 0 THEN idx + # ELSE + # ( + # ((LENGTH(str) - LENGTH(REPLACE(str, delim))) / LENGTH(delim)) + 1 + # ) + idx + 1 + # END + case_neg_idx: SQLGlotExpression = sqlglot_expressions.Case( ifs=[ sqlglot_expressions.If( this=sqlglot_expressions.EQ(this=index_expr, expression=literal_0), true=literal_1, ), sqlglot_expressions.If( - this=sqlglot_expressions.GT(this=index_expr, expression=literal_0), + this=sqlglot_expressions.GT( + this=apply_parens(index_expr), expression=literal_0 + ), true=index_expr, ), ], - default=sqlglot_expressions.Add( - this=sqlglot_expressions.Add( - this=sqlglot_expressions.Paren( - this=sqlglot_expressions.Add( - this=sqlglot_expressions.Anonymous( - this="REGEXP_COUNT", - expressions=[string_expr, delimiter_expr], - ), - expression=literal_1, - ) + default=occurrences, + ) + + case_occurrence: SQLGlotExpression = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.Between( + this=case_neg_idx, low=literal_1, high=parts ), - expression=index_expr, - ), - expression=literal_1, - ), + true=case_neg_idx, + ) + ], + default=sqlglot_expressions.Null(), ) - result: SQLGlotExpression = sqlglot_expressions.Anonymous( + regexp_substr: SQLGlotExpression = sqlglot_expressions.Anonymous( this="REGEXP_SUBSTR", expressions=[ string_expr, - sqlglot_expressions.DPipe( - this=sqlglot_expressions.DPipe( - this=regex_1, expression=delimiter_expr, safe=True - ), - expression=regex_2, - safe=True, - ), + delim_regexp, + literal_1, + case_occurrence, + sqlglot_expressions.Null(), literal_1, - case_expr, ], ) + # CASE + # WHEN delim IS NULL OR delim = '' THEN + # CASE + # WHEN idx = 1 THEN str + # ELSE NULL + # END + # ELSE + # REGEXP_SUBSTR() + # END + result: SQLGlotExpression = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.Or( + this=sqlglot_expressions.Is( + this=delimiter_expr, expression=sqlglot_expressions.Null() + ), + expression=sqlglot_expressions.EQ( + this=delimiter_expr, + expression=sqlglot_expressions.Literal.string(""), + ), + ), + true=sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.EQ( + this=index_expr, expression=literal_1 + ), + true=string_expr, + ) + ], + default=sqlglot_expressions.Null(), + ), + ) + ], + default=regexp_substr, + ) return result def convert_datediff( From 0b63c20b304e5b50bc898e8eb48f1a207c0c9a75 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 2 Mar 2026 13:46:22 -0600 Subject: [PATCH 22/48] STRCOUNT oracle implementation --- .../oracle_transform_bindings.py | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index a2cc80334..e181e7e47 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -115,6 +115,82 @@ def convert_default_to( """ return sqlglot_expressions.Coalesce(this=args[0], expressions=args[1:]) + def convert_str_count( + self, + args: list[SQLGlotExpression], + types: list[PyDoughType], + ) -> SQLGlotExpression: + """ + STRCOUNT(X, Y) => + CASE + WHEN LENGTH(X) IS NULL OR LENGTH(Y) IS NULL THEN 0 + ELSE + CAST((LENGTH(X) - NVL(LENGTH(REPLACE(X, Y, '')), 0)) / LENGTH(Y), AS INTEGER) + END + """ + assert len(args) == 2 + + string: SQLGlotExpression = args[0] + substring_count: SQLGlotExpression = args[1] + + # eliminate the substring of the string: REPLACE(X, Y, "") + string_replaced: SQLGlotExpression = self.convert_replace( + [string, substring_count], types + ) + + # The length of the first string given: LENGH(X) + len_string: SQLGlotExpression = sqlglot_expressions.Length(this=string) + + # The length of the replaced string: NVL(LENGH(REPLACE(X, Y, "")), 0) + # NVL(LENGTH(REPLACE('aaaa', 'aa', '')), 0) + len_string_replaced: SQLGlotExpression = sqlglot_expressions.Coalesce( + this=sqlglot_expressions.Length(this=string_replaced), + expressions=[sqlglot_expressions.Literal.number(0)], + is_nvl=True, + ) + + # The length of the Y string: LENGTH(Y) + len_substring_count: SQLGlotExpression = sqlglot_expressions.Length( + this=substring_count + ) + + # The length difference between string X and + # replaced string: REPLACE(X, Y, "") + difference: SQLGlotExpression = sqlglot_expressions.Sub( + this=len_string, expression=len_string_replaced + ) + + # Take in count if LENGH(Y) > 1 dividing the difference by Y's length: + # LENGTH(X) - LENGTH(REPLACE(X, Y, ''))) / LENGTH(Y) + quotient: SQLGlotExpression = sqlglot_expressions.Div( + this=apply_parens(difference), expression=len_substring_count + ) + + # Cast to Interger: + # CAST((LENGTH(X) - LENGTH(REPLACE(X, Y, ''))) / LENGTH(Y), AS INTEGER) + casted: SQLGlotExpression = sqlglot_expressions.Cast( + this=quotient, to=sqlglot_expressions.DataType.build("BIGINT") + ) + + # CASE when LENGTH(X) IS NULL OR LENGTH(Y) IS NULL THEN 0 else casted + answer: SQLGlotExpression = ( + sqlglot_expressions.Case() + .when( + sqlglot_expressions.Or( + this=sqlglot_expressions.Is( + this=len_string, + expression=sqlglot_expressions.Null(), + ), + expression=sqlglot_expressions.Is( + this=len_substring_count, expression=sqlglot_expressions.Null() + ), + ), + sqlglot_expressions.Literal.number(0), + ) + .else_(casted) + ) + return answer + def convert_slice( self, args: list[SQLGlotExpression], types: list[PyDoughType] ) -> SQLGlotExpression: From f0ea15f29bc977ee25e83e262a6b9d1e3424cf9f Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 4 Mar 2026 16:57:11 -0600 Subject: [PATCH 23/48] Strip, smallest, largest, variance, std, diff quarters, diff weeks, diff days, trunc week, trunc day, join_strings, extract quarters, cast int --- pydough/sqlglot/execute_relational.py | 9 + .../oracle_transform_bindings.py | 255 +++- tests/conftest.py | 88 +- .../test_plan_refsols/order_quarter_test.txt | 2 +- tests/test_plan_refsols/part_reduced_size.txt | 2 +- .../quarter_function_test.txt | 2 +- .../rank_nations_per_region_by_customers.txt | 12 +- tests/test_plan_refsols/smoke_b.txt | 2 +- .../simple_pydough_functions.py | 223 ++-- .../agg_simplification_2_oracle.sql | 2 +- .../aggregation_functions_oracle.sql | 6 +- ...rnative_quarter_cum_ir_analysis_oracle.sql | 4 +- .../avg_gap_prev_urgent_same_clerk_oracle.sql | 5 +- .../avg_order_diff_per_customer_oracle.sql | 5 +- .../casting_functions_oracle.sql | 2 +- .../country_x_year_analysis_oracle.sql | 2 +- .../cumulative_stock_analysis_oracle.sql | 4 +- tests/test_sql_refsols/datediff_oracle.sql | 2 +- .../datetime_current_oracle.sql | 2 +- .../datetime_functions_oracle.sql | 8 +- .../datetime_sampler_oracle.sql | 24 +- .../defog_broker_adv14_oracle.sql | 2 +- .../defog_broker_adv2_oracle.sql | 2 +- .../defog_broker_adv5_oracle.sql | 64 +- .../defog_broker_adv7_oracle.sql | 142 +-- .../defog_broker_adv8_oracle.sql | 14 +- .../defog_broker_adv9_oracle.sql | 28 +- .../defog_broker_basic1_oracle.sql | 2 +- .../defog_broker_gen1_oracle.sql | 2 +- .../defog_broker_gen2_oracle.sql | 2 +- .../defog_broker_gen4_oracle.sql | 2 +- .../defog_dealership_adv10_oracle.sql | 7 +- .../defog_dealership_adv14_oracle.sql | 2 +- .../defog_dealership_adv1_oracle.sql | 18 +- .../defog_dealership_adv2_oracle.sql | 2 +- .../defog_dealership_adv8_ansi.sql | 8 +- .../defog_dealership_adv8_mysql.sql | 8 +- .../defog_dealership_adv8_oracle.sql | 8 +- .../defog_dealership_adv8_postgres.sql | 8 +- .../defog_dealership_adv8_snowflake.sql | 8 +- .../defog_dealership_adv8_sqlite.sql | 8 +- .../defog_dealership_basic5_oracle.sql | 2 +- .../defog_dealership_gen1_oracle.sql | 2 +- .../defog_dealership_gen3_oracle.sql | 2 +- .../defog_dermtreatment_adv15_oracle.sql | 4 +- .../defog_dermtreatment_adv8_oracle.sql | 22 +- .../defog_dermtreatment_adv9_oracle.sql | 128 +- .../defog_dermtreatment_basic1_oracle.sql | 2 +- .../defog_dermtreatment_gen1_oracle.sql | 2 +- .../defog_dermtreatment_gen4_oracle.sql | 2 +- .../defog_dermtreatment_gen5_oracle.sql | 2 +- .../defog_ewallet_adv13_oracle.sql | 4 +- .../defog_ewallet_adv2_oracle.sql | 28 +- .../defog_ewallet_adv4_oracle.sql | 2 +- .../defog_ewallet_adv5_oracle.sql | 2 +- .../defog_ewallet_basic10_oracle.sql | 2 +- .../defog_ewallet_gen1_oracle.sql | 2 +- .../test_sql_refsols/double_cross_oracle.sql | 14 +- .../epoch_event_gap_per_era_oracle.sql | 5 +- .../extract_colors_oracle.sql | 114 +- .../function_sampler_oracle.sql | 5 +- .../get_part_multiple_oracle.sql | 1067 +++++++++++++++-- .../get_part_single_oracle.sql | 30 +- .../odate_and_rdate_avggap_oracle.sql | 5 +- .../order_quarter_test_ansi.sql | 4 +- .../order_quarter_test_mysql.sql | 8 +- .../order_quarter_test_oracle.sql | 20 +- .../order_quarter_test_postgres.sql | 8 +- .../order_quarter_test_snowflake.sql | 4 +- .../order_quarter_test_sqlite.sql | 36 +- .../orders_versus_first_orders_oracle.sql | 2 +- .../part_reduced_size_ansi.sql | 2 +- .../part_reduced_size_mysql.sql | 2 +- .../part_reduced_size_oracle.sql | 15 +- .../part_reduced_size_postgres.sql | 2 +- .../part_reduced_size_snowflake.sql | 2 +- .../part_reduced_size_sqlite.sql | 2 +- .../quarter_cum_ir_analysis_oracle.sql | 4 +- .../quarter_function_test_ansi.sql | 24 +- .../quarter_function_test_mysql.sql | 48 +- .../quarter_function_test_oracle.sql | 96 +- .../quarter_function_test_postgres.sql | 48 +- .../quarter_function_test_snowflake.sql | 24 +- .../quarter_function_test_sqlite.sql | 408 +++---- ...k_nations_per_region_by_customers_ansi.sql | 4 +- ..._nations_per_region_by_customers_mysql.sql | 4 +- ...nations_per_region_by_customers_oracle.sql | 4 +- ...tions_per_region_by_customers_postgres.sql | 4 +- ...ions_per_region_by_customers_snowflake.sql | 4 +- ...nations_per_region_by_customers_sqlite.sql | 4 +- .../simple_int_float_string_cast_oracle.sql | 10 +- .../simple_range_6_oracle.sql | 4 +- .../simple_smallest_or_largest_oracle.sql | 4 +- .../simple_var_std_oracle.sql | 16 +- .../simple_var_std_with_nulls_oracle.sql | 42 +- .../simplification_3_oracle.sql | 18 +- .../simplification_4_oracle.sql | 7 +- tests/test_sql_refsols/smoke_a_oracle.sql | 88 +- tests/test_sql_refsols/smoke_b_oracle.sql | 141 +-- tests/test_sql_refsols/smoke_b_sqlite.sql | 48 +- tests/test_sql_refsols/smoke_c_oracle.sql | 20 +- ...saction_week_sampler_friday_one_oracle.sql | 7 +- ...action_week_sampler_friday_zero_oracle.sql | 7 +- ...saction_week_sampler_monday_one_oracle.sql | 7 +- ...action_week_sampler_monday_zero_oracle.sql | 7 +- ...ction_week_sampler_saturday_one_oracle.sql | 7 +- ...tion_week_sampler_saturday_zero_oracle.sql | 7 +- ...saction_week_sampler_sunday_one_oracle.sql | 7 +- ...action_week_sampler_sunday_zero_oracle.sql | 7 +- ...ction_week_sampler_thursday_one_oracle.sql | 7 +- ...tion_week_sampler_thursday_zero_oracle.sql | 7 +- ...action_week_sampler_tuesday_one_oracle.sql | 7 +- ...ction_week_sampler_tuesday_zero_oracle.sql | 7 +- ...tion_week_sampler_wednesday_one_oracle.sql | 7 +- ...ion_week_sampler_wednesday_zero_oracle.sql | 7 +- .../string_format_specifiers_oracle.sql | 31 +- .../string_functions_oracle.sql | 17 +- ...technograph_hot_purchase_window_oracle.sql | 2 +- ...chnograph_monthly_incident_rate_oracle.sql | 26 +- ...ve_incident_rate_goldcopperstar_oracle.sql | 4 +- ...umulative_incident_rate_overall_oracle.sql | 4 +- .../time_threshold_reached_oracle.sql | 6 +- tests/testing_utilities.py | 13 + 123 files changed, 2562 insertions(+), 1266 deletions(-) diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index 2ccb961f3..1c3fb2f5b 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -15,6 +15,7 @@ from sqlglot.dialects import Postgres as PostgresDialect from sqlglot.dialects import Snowflake as SnowflakeDialect from sqlglot.dialects import SQLite as SQLiteDialect +from sqlglot.dialects.dialect import rename_func from sqlglot.dialects.mysql import MySQL from sqlglot.dialects.oracle import Oracle from sqlglot.errors import SqlglotError @@ -555,6 +556,12 @@ def change_sqlglot_dialect_configuration(dialect: DatabaseDialect) -> None: Oracle.Generator.TYPE_MAPPING[ sqlglot_expressions.DataType.Type.DATETIME ] = "DATE" + + # Fixes VAR_POP call. Without it sqlglot uses VARIANCE_POP which + # doesn't exist in Oracle + Oracle.Generator.TRANSFORMS[sqlglot_expressions.VariancePop] = rename_func( + "VAR_POP" + ) case _: pass @@ -568,6 +575,8 @@ def reset_sqlglot_dialect_configuration(dialect: DatabaseDialect) -> None: case DatabaseDialect.MYSQL: MySQL.Generator.VALUES_AS_TABLE = False MySQL.Generator.WRAP_DERIVED_VALUES = False + case DatabaseDialect.ORACLE: + del Oracle.Generator.TRANSFORMS[sqlglot_expressions.VariancePop] case _: pass diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py index e181e7e47..5ddf9de95 100644 --- a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -17,6 +17,7 @@ from pydough.types.boolean_type import BooleanType from pydough.types.datetime_type import DatetimeType from pydough.types.numeric_type import NumericType +from pydough.types.string_type import StringType from .base_transform_bindings import BaseTransformBindings from .sqlglot_transform_utils import ( @@ -59,17 +60,15 @@ def oracle_strftime_mapping(self) -> dict[str, str]: "%Y": "YYYY", "%m": "MM", "%d": "DD", - "%H": "HH24", + "%H": "HH24", # 24-hour clock + "%I": "HH12", # 12-hour clock (IMPORTANT for AM/PM) "%M": "MI", "%S": "SS", + "%p": "AM", # AM / PM marker } PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { pydop.ABS: "ABS", - pydop.LARGEST: "GREATEST", - pydop.SMALLEST: "LEAST", - pydop.STRIP: "TRIM", - pydop.FIND: "INSTR", pydop.PERCENTILE: "PERCENTILE_CONT", } @@ -115,6 +114,27 @@ def convert_default_to( """ return sqlglot_expressions.Coalesce(this=args[0], expressions=args[1:]) + def convert_strip( + self, + args: list[SQLGlotExpression], + types: list[PyDoughType], + ) -> SQLGlotExpression: + assert 1 <= len(args) <= 2 + to_strip: SQLGlotExpression = args[0] + strip_char_glot: SQLGlotExpression + if len(args) == 1: + strip_char_glot = sqlglot_expressions.Literal.string("\n\t ") + else: + strip_char_glot = args[1] + + return sqlglot_expressions.Trim( + this=sqlglot_expressions.Trim( + this=to_strip, expression=strip_char_glot, position="LEADING" + ), + expression=strip_char_glot, + position="TRAILING", + ) + def convert_str_count( self, args: list[SQLGlotExpression], @@ -380,6 +400,68 @@ def convert_slice( ) return result + def convert_smallest_or_largest( + self, args: list[SQLGlotExpression], types: list[PyDoughType], largest: bool + ) -> SQLGlotExpression: + assert len(args) > 1 + + func_name: str = "GREATEST" if largest else "LEAST" + + if isinstance(types[0], StringType): + args = [ + sqlglot_expressions.Coalesce( + this=arg if arg.this != "" else sqlglot_expressions.Null(), + expressions=[ + sqlglot_expressions.Chr( + expressions=[sqlglot_expressions.Literal.number(0)] + ) + ], + is_nvl=True, + ) + for arg in args + ] + + return sqlglot_expressions.Anonymous(this=func_name, expressions=args) + + def convert_variance( + self, args: list[SQLGlotExpression], types: list[PyDoughType], type: str + ) -> SQLGlotExpression: + arg = args[0] + if type == "population": + return sqlglot_expressions.VariancePop(this=arg) + elif type == "sample": + return sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.LT( + this=sqlglot_expressions.Count(this=arg), + expression=sqlglot_expressions.Literal.number(2), + ), + true=sqlglot_expressions.Null(), + ) + ], + default=sqlglot_expressions.Variance(this=arg), + ) + + def convert_std( + self, args: list[SQLGlotExpression], types: list[PyDoughType], type: str + ) -> SQLGlotExpression: + if type == "population": + return sqlglot_expressions.StddevPop(this=args[0]) + elif type == "sample": + return sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.LT( + this=sqlglot_expressions.Count(this=args[0]), + expression=sqlglot_expressions.Literal.number(2), + ), + true=sqlglot_expressions.Null(), + ) + ], + default=sqlglot_expressions.Stddev(this=args[0]), + ) + def convert_get_part( self, args: list[SQLGlotExpression], types: list[PyDoughType] ) -> SQLGlotExpression: @@ -605,13 +687,36 @@ def convert_datediff( return year_diff case DateTimeUnit.QUARTER: # (EXTRACT(YEAR FROM date2) - EXTRACT(YEAR FROM date1)) * 4 + - # (EXTRACT(QUATER FROM date2) - EXTRACT(QUARTER FROM date1)) + # (FLOOR((EXTRACT(MONTH FROM date2) - 1) / 3) - + # FLOOR((EXTRACT(MONTH FROM date1) - 1) / 3)) quarter_diff: SQLGlotExpression = sqlglot_expressions.Sub( - this=sqlglot_expressions.Extract( - this=sqlglot_expressions.Var(this="QUARTER"), expression=date2 + this=sqlglot_expressions.Floor( + this=sqlglot_expressions.Div( + this=apply_parens( + sqlglot_expressions.Sub( + this=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="MONTH"), + expression=date2, + ), + expression=sqlglot_expressions.Literal.number(1), + ) + ), + expression=sqlglot_expressions.Literal.number(3), + ) ), - expression=sqlglot_expressions.Extract( - this=sqlglot_expressions.Var(this="QUARTER"), expression=date1 + expression=sqlglot_expressions.Floor( + this=sqlglot_expressions.Div( + this=apply_parens( + sqlglot_expressions.Sub( + this=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="MONTH"), + expression=date1, + ), + expression=sqlglot_expressions.Literal.number(1), + ) + ), + expression=sqlglot_expressions.Literal.number(3), + ) ), ) @@ -648,7 +753,12 @@ def convert_datediff( # dow2 = DAYOFWEEK(date2) # result = FLOOR((raw_delta + dow1 - dow2) / 7) raw_delta: SQLGlotExpression = sqlglot_expressions.Sub( - this=date2, expression=date1 + this=sqlglot_expressions.DateTrunc( + this=date2, unit=sqlglot_expressions.Literal.string("DD") + ), + expression=sqlglot_expressions.DateTrunc( + this=date1, unit=sqlglot_expressions.Literal.string("DD") + ), ) dow1: SQLGlotExpression = self.convert_dayofweek([date1], [types[1]]) @@ -671,8 +781,15 @@ def convert_datediff( ) case DateTimeUnit.DAY: - # date2 - date1 - return sqlglot_expressions.Sub(this=date2, expression=date1) + # TRUNC(date2, 'HH24') - TRUNC(date1, 'HH24') + return sqlglot_expressions.Sub( + this=sqlglot_expressions.DateTrunc( + this=date2, unit=sqlglot_expressions.Literal.string("DD") + ), + expression=sqlglot_expressions.DateTrunc( + this=date1, unit=sqlglot_expressions.Literal.string("DD") + ), + ) case DateTimeUnit.HOUR: # (TRUNC(date2, 'HH24') - TRUNC(date1, 'HH24')) * 24 @@ -764,11 +881,12 @@ def apply_datetime_truncation( ) -> SQLGlotExpression: match unit: case DateTimeUnit.QUARTER: + # TRUNC(o_orderdate, 'Q') return sqlglot_expressions.Anonymous( this="TRUNC", expressions=[ self.make_datetime_arg(base), - sqlglot_expressions.Literal.string("Q"), + sqlglot_expressions.Var(this="Q"), ], ) case DateTimeUnit.HOUR | DateTimeUnit.MINUTE | DateTimeUnit.SECOND: @@ -777,9 +895,19 @@ def apply_datetime_truncation( unit=sqlglot_expressions.Var(this=unit.value.lower()), ) case DateTimeUnit.WEEK: + # DOW = DAYOFWEEK(X) + # Y = subtract DOW days from X + # RESULT = DATETIME(Y, "start of day") + dow = self.days_from_start_of_week(base) + minus_dow: SQLGlotExpression = sqlglot_expressions.Sub( + this=base, + expression=dow, + ) + return self.apply_datetime_truncation(minus_dow, DateTimeUnit.DAY) + case DateTimeUnit.DAY: return sqlglot_expressions.DateTrunc( this=self.make_datetime_arg(base), - unit=sqlglot_expressions.Var(this="IW"), + unit=sqlglot_expressions.Literal.string("DD"), ) case _: return sqlglot_expressions.DateTrunc( @@ -852,35 +980,34 @@ def apply_datetime_offset( def convert_join_strings( self, args: list[SQLGlotExpression], types: list[PyDoughType] ) -> SQLGlotExpression: - # args[0] is the delimiter, args[1:] are the strings to join - delim: SQLGlotExpression = args[0] - string_args: list[SQLGlotExpression] = args[1:] - - # Build a chain of NVL2(arg, delim || arg, NULL) expressions - concatenated: SQLGlotExpression | None = None - for arg in string_args: - # Create: NVL2(arg, delim || arg, NULL) - delim_and_arg = sqlglot_expressions.DPipe( - this=delim, - expression=arg, - safe=True, - ) - nvl2_expr = sqlglot_expressions.Anonymous( - this="NVL2", - expressions=[arg, delim_and_arg, sqlglot_expressions.Null()], - ) + if len(args) == 1: + return sqlglot_expressions.Literal.string("") + elif len(args) == 2: + # Return the first string + return args[1] - if concatenated is None: - concatenated = nvl2_expr - else: - concatenated = sqlglot_expressions.DPipe( - this=concatenated, expression=nvl2_expr, safe=True - ) + delim_expr = args[0] - # Wrap in LTRIM to remove the very first separator - result: SQLGlotExpression = sqlglot_expressions.Anonymous( - this="LTRIM", expressions=[concatenated, delim] + # Start with first argument + result: SQLGlotExpression = sqlglot_expressions.Coalesce( + this=args[1], + expressions=[sqlglot_expressions.Literal.string("")], + is_nvl=True, ) + + for arg in args[2:]: + result = sqlglot_expressions.DPipe( + this=result, + expression=sqlglot_expressions.DPipe( + this=delim_expr, + expression=sqlglot_expressions.Coalesce( + this=arg, + expressions=[sqlglot_expressions.Literal.string("")], + is_nvl=True, + ), + ), + ) + return result def convert_extract_datetime( @@ -897,13 +1024,34 @@ def convert_extract_datetime( else "TIMESTAMP" ) - return sqlglot_expressions.Extract( - this=sqlglot_expressions.Var(this=unit.value.upper()), - expression=sqlglot_expressions.Cast( - this=self.make_datetime_arg(args[0]), - to=sqlglot_expressions.DataType(this=cast_type), - ), - ) + match unit: + case DateTimeUnit.QUARTER: + # TRUNC((EXTRACT(MONTH FROM o_orderdate) - 1) / 3) + 1 + return sqlglot_expressions.Add( + this=sqlglot_expressions.Floor( + this=sqlglot_expressions.Div( + this=apply_parens( + sqlglot_expressions.Sub( + this=sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this="MONTH"), + expression=self.make_datetime_arg(args[0]), + ), + expression=sqlglot_expressions.Literal.number(1), + ) + ), + expression=sqlglot_expressions.Literal.number(3), + ) + ), + expression=sqlglot_expressions.Literal.number(1), + ) + case _: + return sqlglot_expressions.Extract( + this=sqlglot_expressions.Var(this=unit.value.upper()), + expression=sqlglot_expressions.Cast( + this=self.make_datetime_arg(args[0]), + to=sqlglot_expressions.DataType(this=cast_type), + ), + ) def oracle_format(self, fmt: str) -> str: """ @@ -1005,4 +1153,13 @@ def convert_integer( default=sqlglot_expressions.Literal.number(0), ) else: - return super().convert_integer(args, types) + return sqlglot_expressions.Anonymous( + this="TRUNC", + expressions=[ + sqlglot_expressions.Cast( + this=args[0], + to=sqlglot_expressions.DataType.build("DOUBLE PRECISION"), + ), + sqlglot_expressions.Literal.number(0), + ], + ) diff --git a/tests/conftest.py b/tests/conftest.py index db84234d2..b8d637cfc 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -37,6 +37,7 @@ from pydough.metadata.graphs import GraphMetadata from pydough.qdag import AstNodeBuilder from tests.test_pydough_functions.simple_pydough_functions import ( + simple_int_float_string_cast, string_format_specifiers_mysql, string_format_specifiers_oracle, string_format_specifiers_postgres, @@ -1884,14 +1885,14 @@ def sqlite_pagerank_db_contexts() -> dict[str, DatabaseContext]: " f=DATETIME('2025-01-01 12:35:13', 'start of hour', '+2 quarters', '+3 weeks')," " g=DATETIME('2025-01-01 12:35:13', 'start of day')," " h=JOIN_STRINGS(';', HOUR('2025-01-01 12:35:13'), MINUTE(DATETIME('2025-01-01 12:35:13', '+45 minutes')), SECOND(DATETIME('2025-01-01 12:35:13', '-7 seconds')))," - " i=DATEDIFF('years', '1993-05-25 12:45:36', order_date)," - " j=DATEDIFF('quarters', '1993-05-25 12:45:36', order_date)," - " k=DATEDIFF('months', '1993-05-25 12:45:36', order_date)," - " l=DATEDIFF('weeks', '1993-05-25 12:45:36', order_date)," - " m=DATEDIFF('days', '1993-05-25 12:45:36', order_date)," - " n=DATEDIFF('hours', '1993-05-25 12:45:36', order_date)," - " o=DATEDIFF('minutes', '1993-05-25 12:45:36', order_date)," - " p=DATEDIFF('seconds', '1993-05-25 12:45:36', order_date)," + " i=DATEDIFF('years', DATETIME('1993-05-25 12:45:36'), order_date)," + " j=DATEDIFF('quarters', DATETIME('1993-05-25 12:45:36'), order_date)," + " k=DATEDIFF('months', DATETIME('1993-05-25 12:45:36'), order_date)," + " l=DATEDIFF('weeks', DATETIME('1993-05-25 12:45:36'), order_date)," + " m=DATEDIFF('days', DATETIME('1993-05-25 12:45:36'), order_date)," + " n=DATEDIFF('hours', DATETIME('1993-05-25 12:45:36'), order_date)," + " o=DATEDIFF('minutes', DATETIME('1993-05-25 12:45:36'), order_date)," + " p=DATEDIFF('seconds', DATETIME('1993-05-25 12:45:36'), order_date)," " q=DATETIME(order_date, 'start of week')," ").TOP_K(5, by=key.ASC())", "TPCH", @@ -2472,21 +2473,31 @@ def tpch_custom_test_data_dialect_replacements( "TPCH", lambda: pd.DataFrame( { + # ===== YEAR ===== "d1": ["2023"], # YYYY "d2": ["23"], # YY - "d3": ["07"], # MM - "d4": ["Jul"], # Mon - "d5": ["July"], # MMMM - "d6": ["15"], # DD - "d7": ["Sat"], # DY - "d8": ["Saturday"], # DYDY - "d9": ["14"], # HH24 - "d10": ["02"], # HH12 - "d11": ["30"], # MI - "d12": ["45"], # SS - "d13": ["PM"], # AM / PM - "d14": [".000000000"], # .FF - "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) + "d3": ["23"], # RR (2023 β†’ 23) + # ===== MONTH ===== + "d4": ["07"], # MM + "d5": ["JUL"], # MON + "d6": ["JULY "], # MONTH (space-padded) + "d7": ["3"], # Q (July β†’ Q3) + # ===== DAY ===== + "d8": ["15"], # DD + "d9": ["196"], # DDD (day of year) + "d10": ["7"], # D (Saturday, NLS_TERRITORY dependent) + "d11": ["SAT"], # DY + "d12": ["SATURDAY "], # DAY (space-padded) + # ===== WEEK ===== + "d13": ["3"], # W (week of month) + "d14": ["28"], # WW (week of year) + "d15": ["28"], # IW (ISO week) + # ===== TIME ===== + "d16": ["14"], # HH24 + "d17": ["02"], # HH12 + "d18": ["30"], # MI + "d19": ["45"], # SS + "d20": ["P.M."], # AM } ), "string_format_specifiers", @@ -2494,6 +2505,41 @@ def tpch_custom_test_data_dialect_replacements( case _: pytest.skip("Skipping test: Unsupported dialect for test replacement") + if test.test_name == "simple_int_float_string_cast": + if dialect == DatabaseDialect.ORACLE: + # Oracle needs different answer + return PyDoughPandasTest( + simple_int_float_string_cast, + "TPCH", + lambda: pd.DataFrame( + { + "i1": [1], + "i2": [2], + "i3": [3], + "i4": [4], + "i5": [-5], + "i6": [-6], + "f1": [1.0], + "f2": [2.2], + "f3": [3.0], + "f4": [4.3], + "f5": [-5.888], + "f6": [-6.0], + "f7": [0.0], + "s1": ["1"], + "s2": ["2.2"], + "s3": ["3"], + "s4": ["4.3"], + "s5": ["-5.888"], + "s6": ["-6.1"], + "s7": [".1"], + "s8": ["0.0"], + "s9": ["abc def"], + } + ), + "simple_int_float_string_cast", + ) + return test diff --git a/tests/test_plan_refsols/order_quarter_test.txt b/tests/test_plan_refsols/order_quarter_test.txt index d03ce7a7e..aaad6e385 100644 --- a/tests/test_plan_refsols/order_quarter_test.txt +++ b/tests/test_plan_refsols/order_quarter_test.txt @@ -1,3 +1,3 @@ -ROOT(columns=[('order_date', o_orderdate), ('quarter', QUARTER(o_orderdate)), ('quarter_start', DATETIME(o_orderdate, 'start of quarter':string)), ('next_quarter', DATETIME(o_orderdate, '+1 quarter':string)), ('prev_quarter', DATETIME(o_orderdate, '-1 quarter':string)), ('two_quarters_ahead', DATETIME(o_orderdate, '+2 quarters':string)), ('two_quarters_behind', DATETIME(o_orderdate, '-2 quarters':string)), ('quarters_since_1995', DATEDIFF('quarter':string, '1995-01-01':string, o_orderdate)), ('quarters_until_2000', DATEDIFF('quarter':string, o_orderdate, '2000-01-01':string)), ('same_quarter_prev_year', DATETIME(o_orderdate, '-4 quarters':string)), ('same_quarter_next_year', DATETIME(o_orderdate, '+4 quarters':string))], orderings=[(o_orderdate):asc_first], limit=1:numeric) +ROOT(columns=[('order_date', o_orderdate), ('quarter', QUARTER(o_orderdate)), ('quarter_start', DATETIME(o_orderdate, 'start of quarter':string)), ('next_quarter', DATETIME(o_orderdate, '+1 quarter':string)), ('prev_quarter', DATETIME(o_orderdate, '-1 quarter':string)), ('two_quarters_ahead', DATETIME(o_orderdate, '+2 quarters':string)), ('two_quarters_behind', DATETIME(o_orderdate, '-2 quarters':string)), ('quarters_since_1995', DATEDIFF('quarter':string, datetime.date(1995, 1, 1):datetime, o_orderdate)), ('quarters_until_2000', DATEDIFF('quarter':string, o_orderdate, datetime.date(2000, 1, 1):datetime)), ('same_quarter_prev_year', DATETIME(o_orderdate, '-4 quarters':string)), ('same_quarter_next_year', DATETIME(o_orderdate, '+4 quarters':string))], orderings=[(o_orderdate):asc_first], limit=1:numeric) FILTER(condition=YEAR(o_orderdate) == 1995:numeric, columns={'o_orderdate': o_orderdate}) SCAN(table=tpch.ORDERS, columns={'o_orderdate': o_orderdate}) diff --git a/tests/test_plan_refsols/part_reduced_size.txt b/tests/test_plan_refsols/part_reduced_size.txt index 1a45bbd9f..935c021e0 100644 --- a/tests/test_plan_refsols/part_reduced_size.txt +++ b/tests/test_plan_refsols/part_reduced_size.txt @@ -1,4 +1,4 @@ -ROOT(columns=[('reduced_size', FLOAT((p_size / 2.5:numeric))), ('retail_price_int', INTEGER(p_retailprice)), ('message', JOIN_STRINGS('':string, 'old size: ':string, STRING(p_size))), ('discount', l_discount), ('date_dmy', STRING(l_receiptdate, '%d-%m-%Y':string)), ('date_md', STRING(l_receiptdate, '%m/%d':string)), ('am_pm', STRING(l_receiptdate, '%H:%M%p':string))], orderings=[(l_discount):desc_last, (STRING(l_receiptdate, '%d-%m-%Y':string)):asc_first], limit=5:numeric) +ROOT(columns=[('reduced_size', FLOAT((p_size / 2.5:numeric))), ('retail_price_int', INTEGER(p_retailprice)), ('message', JOIN_STRINGS(' ':string, 'old size:':string, STRING(p_size))), ('discount', l_discount), ('date_dmy', STRING(l_receiptdate, '%d-%m-%Y':string)), ('date_md', STRING(l_receiptdate, '%m/%d':string)), ('am_pm', STRING(l_receiptdate, '%H:%M%p':string))], orderings=[(l_discount):desc_last, (STRING(l_receiptdate, '%d-%m-%Y':string)):asc_first], limit=5:numeric) JOIN(condition=t0.p_partkey == t1.l_partkey, type=INNER, cardinality=PLURAL_FILTER, reverse_cardinality=SINGULAR_FILTER, columns={'l_discount': t1.l_discount, 'l_receiptdate': t1.l_receiptdate, 'p_retailprice': t0.p_retailprice, 'p_size': t0.p_size}) LIMIT(limit=2:numeric, columns={'p_partkey': p_partkey, 'p_retailprice': p_retailprice, 'p_size': p_size}, orderings=[(INTEGER(p_retailprice)):asc_first]) SCAN(table=tpch.PART, columns={'p_partkey': p_partkey, 'p_retailprice': p_retailprice, 'p_size': p_size}) diff --git a/tests/test_plan_refsols/quarter_function_test.txt b/tests/test_plan_refsols/quarter_function_test.txt index 36b26e4a3..7a75a4079 100644 --- a/tests/test_plan_refsols/quarter_function_test.txt +++ b/tests/test_plan_refsols/quarter_function_test.txt @@ -1,2 +1,2 @@ -ROOT(columns=[('_expr0', 1:numeric), ('_expr1', 1:numeric), ('_expr2', 1:numeric), ('_expr3', 2:numeric), ('_expr4', 2:numeric), ('_expr5', 2:numeric), ('_expr6', 3:numeric), ('_expr7', 3:numeric), ('_expr8', 3:numeric), ('_expr9', 4:numeric), ('_expr10', 4:numeric), ('_expr11', 4:numeric), ('_expr12', 1:numeric), ('q1_jan', datetime.date(2023, 1, 1):datetime), ('q1_feb', datetime.date(2023, 1, 1):datetime), ('q1_mar', datetime.date(2023, 1, 1):datetime), ('q2_apr', datetime.date(2023, 4, 1):datetime), ('q2_may', datetime.date(2023, 4, 1):datetime), ('q2_jun', datetime.date(2023, 4, 1):datetime), ('q3_jul', datetime.date(2023, 7, 1):datetime), ('q3_aug', datetime.date(2023, 7, 1):datetime), ('q3_sep', datetime.date(2023, 7, 1):datetime), ('q4_oct', datetime.date(2023, 10, 1):datetime), ('q4_nov', datetime.date(2023, 10, 1):datetime), ('q4_dec', datetime.date(2023, 10, 1):datetime), ('ts_q1', datetime.date(2024, 1, 1):datetime), ('alias1', datetime.date(2023, 4, 1):datetime), ('alias2', datetime.date(2023, 7, 1):datetime), ('alias3', datetime.date(2023, 10, 1):datetime), ('alias4', datetime.date(2023, 1, 1):datetime), ('chain1', Timestamp('2023-04-02 02:00:00'):datetime), ('chain2', datetime.date(2023, 7, 1):datetime), ('chain3', datetime.date(2023, 10, 1):datetime), ('plus_1q', Timestamp('2023-04-15 12:30:45'):datetime), ('plus_2q', Timestamp('2023-07-15 12:30:45'):datetime), ('plus_3q', datetime.date(2023, 10, 15):datetime), ('minus_1q', Timestamp('2022-10-15 12:30:45'):datetime), ('minus_2q', Timestamp('2022-07-15 12:30:45'):datetime), ('minus_3q', datetime.date(2022, 4, 15):datetime), ('syntax1', datetime.date(2023, 8, 15):datetime), ('syntax2', datetime.date(2024, 2, 15):datetime), ('syntax3', datetime.date(2024, 8, 15):datetime), ('syntax4', datetime.date(2022, 8, 15):datetime), ('q_diff1', DATEDIFF('quarter':string, '2023-01-15':string, '2023-04-15':string)), ('q_diff2', DATEDIFF('quarter':string, '2023-01-15':string, '2023-07-15':string)), ('q_diff3', DATEDIFF('quarter':string, '2023-01-15':string, '2023-10-15':string)), ('q_diff4', DATEDIFF('quarter':string, '2023-01-15':string, '2023-12-31':string)), ('q_diff5', DATEDIFF('quarter':string, '2023-01-15':string, '2024-01-15':string)), ('q_diff6', DATEDIFF('quarter':string, '2023-01-15':string, '2024-04-15':string)), ('q_diff7', DATEDIFF('quarter':string, '2022-10-15':string, '2024-04-15':string)), ('q_diff8', DATEDIFF('quarter':string, '2020-01-01':string, '2025-01-01':string)), ('q_diff9', DATEDIFF('quarter':string, '2023-04-15':string, '2023-01-15':string)), ('q_diff10', DATEDIFF('quarter':string, '2024-01-15':string, '2023-01-15':string)), ('q_diff11', DATEDIFF('quarter':string, '2023-03-31':string, '2023-04-01':string)), ('q_diff12', DATEDIFF('quarter':string, '2023-12-31':string, '2024-01-01':string))], orderings=[]) +ROOT(columns=[('_expr0', 1:numeric), ('_expr1', 1:numeric), ('_expr2', 1:numeric), ('_expr3', 2:numeric), ('_expr4', 2:numeric), ('_expr5', 2:numeric), ('_expr6', 3:numeric), ('_expr7', 3:numeric), ('_expr8', 3:numeric), ('_expr9', 4:numeric), ('_expr10', 4:numeric), ('_expr11', 4:numeric), ('_expr12', 1:numeric), ('q1_jan', datetime.date(2023, 1, 1):datetime), ('q1_feb', datetime.date(2023, 1, 1):datetime), ('q1_mar', datetime.date(2023, 1, 1):datetime), ('q2_apr', datetime.date(2023, 4, 1):datetime), ('q2_may', datetime.date(2023, 4, 1):datetime), ('q2_jun', datetime.date(2023, 4, 1):datetime), ('q3_jul', datetime.date(2023, 7, 1):datetime), ('q3_aug', datetime.date(2023, 7, 1):datetime), ('q3_sep', datetime.date(2023, 7, 1):datetime), ('q4_oct', datetime.date(2023, 10, 1):datetime), ('q4_nov', datetime.date(2023, 10, 1):datetime), ('q4_dec', datetime.date(2023, 10, 1):datetime), ('ts_q1', datetime.date(2024, 1, 1):datetime), ('alias1', datetime.date(2023, 4, 1):datetime), ('alias2', datetime.date(2023, 7, 1):datetime), ('alias3', datetime.date(2023, 10, 1):datetime), ('alias4', datetime.date(2023, 1, 1):datetime), ('chain1', Timestamp('2023-04-02 02:00:00'):datetime), ('chain2', datetime.date(2023, 7, 1):datetime), ('chain3', datetime.date(2023, 10, 1):datetime), ('plus_1q', Timestamp('2023-04-15 12:30:45'):datetime), ('plus_2q', Timestamp('2023-07-15 12:30:45'):datetime), ('plus_3q', datetime.date(2023, 10, 15):datetime), ('minus_1q', Timestamp('2022-10-15 12:30:45'):datetime), ('minus_2q', Timestamp('2022-07-15 12:30:45'):datetime), ('minus_3q', datetime.date(2022, 4, 15):datetime), ('syntax1', datetime.date(2023, 8, 15):datetime), ('syntax2', datetime.date(2024, 2, 15):datetime), ('syntax3', datetime.date(2024, 8, 15):datetime), ('syntax4', datetime.date(2022, 8, 15):datetime), ('q_diff1', DATEDIFF('quarter':string, datetime.date(2023, 1, 15):datetime, datetime.date(2023, 4, 15):datetime)), ('q_diff2', DATEDIFF('quarter':string, datetime.date(2023, 1, 15):datetime, datetime.date(2023, 7, 15):datetime)), ('q_diff3', DATEDIFF('quarter':string, datetime.date(2023, 1, 15):datetime, datetime.date(2023, 10, 15):datetime)), ('q_diff4', DATEDIFF('quarter':string, datetime.date(2023, 1, 15):datetime, datetime.date(2023, 12, 31):datetime)), ('q_diff5', DATEDIFF('quarter':string, datetime.date(2023, 1, 15):datetime, datetime.date(2024, 1, 15):datetime)), ('q_diff6', DATEDIFF('quarter':string, datetime.date(2023, 1, 15):datetime, datetime.date(2024, 4, 15):datetime)), ('q_diff7', DATEDIFF('quarter':string, datetime.date(2022, 10, 15):datetime, datetime.date(2024, 4, 15):datetime)), ('q_diff8', DATEDIFF('quarter':string, datetime.date(2020, 1, 1):datetime, datetime.date(2025, 1, 1):datetime)), ('q_diff9', DATEDIFF('quarter':string, datetime.date(2023, 4, 15):datetime, datetime.date(2023, 1, 15):datetime)), ('q_diff10', DATEDIFF('quarter':string, datetime.date(2024, 1, 15):datetime, datetime.date(2023, 1, 15):datetime)), ('q_diff11', DATEDIFF('quarter':string, datetime.date(2023, 3, 31):datetime, datetime.date(2023, 4, 1):datetime)), ('q_diff12', DATEDIFF('quarter':string, datetime.date(2023, 12, 31):datetime, datetime.date(2024, 1, 1):datetime))], orderings=[]) EMPTYSINGLETON() diff --git a/tests/test_plan_refsols/rank_nations_per_region_by_customers.txt b/tests/test_plan_refsols/rank_nations_per_region_by_customers.txt index 652ab3dfe..7f4cfa395 100644 --- a/tests/test_plan_refsols/rank_nations_per_region_by_customers.txt +++ b/tests/test_plan_refsols/rank_nations_per_region_by_customers.txt @@ -1,7 +1,5 @@ -ROOT(columns=[('nation_name', n_name), ('rank', RANKING(args=[], partition=[n_regionkey], order=[(n_rows):desc_first, (r_name):asc_last]))], orderings=[(RANKING(args=[], partition=[n_regionkey], order=[(n_rows):desc_first, (r_name):asc_last])):asc_first], limit=5:numeric) - JOIN(condition=t0.n_regionkey == t1.r_regionkey, type=INNER, cardinality=SINGULAR_ACCESS, reverse_cardinality=PLURAL_ACCESS, columns={'n_name': t0.n_name, 'n_regionkey': t0.n_regionkey, 'n_rows': t0.n_rows, 'r_name': t1.r_name}) - JOIN(condition=t0.n_nationkey == t1.c_nationkey, type=INNER, cardinality=SINGULAR_ACCESS, reverse_cardinality=SINGULAR_ACCESS, columns={'n_name': t0.n_name, 'n_regionkey': t0.n_regionkey, 'n_rows': t1.n_rows}) - SCAN(table=tpch.NATION, columns={'n_name': n_name, 'n_nationkey': n_nationkey, 'n_regionkey': n_regionkey}) - AGGREGATE(keys={'c_nationkey': c_nationkey}, aggregations={'n_rows': COUNT()}) - SCAN(table=tpch.CUSTOMER, columns={'c_nationkey': c_nationkey}) - SCAN(table=tpch.REGION, columns={'r_name': r_name, 'r_regionkey': r_regionkey}) +ROOT(columns=[('nation_name', n_name), ('rank', RANKING(args=[], partition=[n_regionkey], order=[(n_rows):desc_first, (n_name):asc_last]))], orderings=[(RANKING(args=[], partition=[n_regionkey], order=[(n_rows):desc_first, (n_name):asc_last])):asc_first], limit=5:numeric) + JOIN(condition=t0.n_nationkey == t1.c_nationkey, type=INNER, cardinality=SINGULAR_ACCESS, reverse_cardinality=SINGULAR_ACCESS, columns={'n_name': t0.n_name, 'n_regionkey': t0.n_regionkey, 'n_rows': t1.n_rows}) + SCAN(table=tpch.NATION, columns={'n_name': n_name, 'n_nationkey': n_nationkey, 'n_regionkey': n_regionkey}) + AGGREGATE(keys={'c_nationkey': c_nationkey}, aggregations={'n_rows': COUNT()}) + SCAN(table=tpch.CUSTOMER, columns={'c_nationkey': c_nationkey}) diff --git a/tests/test_plan_refsols/smoke_b.txt b/tests/test_plan_refsols/smoke_b.txt index 5d56b5cc0..b40a9eb9e 100644 --- a/tests/test_plan_refsols/smoke_b.txt +++ b/tests/test_plan_refsols/smoke_b.txt @@ -1,3 +1,3 @@ -ROOT(columns=[('key', o_orderkey), ('a', JOIN_STRINGS('_':string, YEAR(o_orderdate), QUARTER(o_orderdate), MONTH(o_orderdate), DAY(o_orderdate))), ('b', JOIN_STRINGS(':':string, DAYNAME(o_orderdate), DAYOFWEEK(o_orderdate))), ('c', DATETIME(o_orderdate, 'start of year':string, '+6 months':string, '-13 days':string)), ('d', DATETIME(o_orderdate, 'start of quarter':string, '+1 year':string, '+25 hours':string)), ('e', Timestamp('2025-01-01 12:35:00'):datetime), ('f', Timestamp('2025-07-22 12:00:00'):datetime), ('g', datetime.date(2025, 1, 1):datetime), ('h', JOIN_STRINGS(';':string, 12:numeric, 20:numeric, 6:numeric)), ('i', DATEDIFF('years':string, '1993-05-25 12:45:36':string, o_orderdate)), ('j', DATEDIFF('quarters':string, '1993-05-25 12:45:36':string, o_orderdate)), ('k', DATEDIFF('months':string, '1993-05-25 12:45:36':string, o_orderdate)), ('l', DATEDIFF('weeks':string, '1993-05-25 12:45:36':string, o_orderdate)), ('m', DATEDIFF('days':string, '1993-05-25 12:45:36':string, o_orderdate)), ('n', DATEDIFF('hours':string, '1993-05-25 12:45:36':string, o_orderdate)), ('o', DATEDIFF('minutes':string, '1993-05-25 12:45:36':string, o_orderdate)), ('p', DATEDIFF('seconds':string, '1993-05-25 12:45:36':string, o_orderdate)), ('q', DATETIME(o_orderdate, 'start of week':string))], orderings=[(o_orderkey):asc_first], limit=5:numeric) +ROOT(columns=[('key', o_orderkey), ('a', JOIN_STRINGS('_':string, YEAR(o_orderdate), QUARTER(o_orderdate), MONTH(o_orderdate), DAY(o_orderdate))), ('b', JOIN_STRINGS(':':string, DAYNAME(o_orderdate), DAYOFWEEK(o_orderdate))), ('c', DATETIME(o_orderdate, 'start of year':string, '+6 months':string, '-13 days':string)), ('d', DATETIME(o_orderdate, 'start of quarter':string, '+1 year':string, '+25 hours':string)), ('e', Timestamp('2025-01-01 12:35:00'):datetime), ('f', Timestamp('2025-07-22 12:00:00'):datetime), ('g', datetime.date(2025, 1, 1):datetime), ('h', JOIN_STRINGS(';':string, 12:numeric, 20:numeric, 6:numeric)), ('i', DATEDIFF('years':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('j', DATEDIFF('quarters':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('k', DATEDIFF('months':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('l', DATEDIFF('weeks':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('m', DATEDIFF('days':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('n', DATEDIFF('hours':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('o', DATEDIFF('minutes':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('p', DATEDIFF('seconds':string, Timestamp('1993-05-25 12:45:36'):datetime, o_orderdate)), ('q', DATETIME(o_orderdate, 'start of week':string))], orderings=[(o_orderkey):asc_first], limit=5:numeric) FILTER(condition=CONTAINS(o_comment, 'fo':string) & ENDSWITH(o_clerk, '5':string) & STARTSWITH(o_orderpriority, '3':string), columns={'o_orderdate': o_orderdate, 'o_orderkey': o_orderkey}) SCAN(table=tpch.ORDERS, columns={'o_clerk': o_clerk, 'o_comment': o_comment, 'o_orderdate': o_orderdate, 'o_orderkey': o_orderkey, 'o_orderpriority': o_orderpriority}) diff --git a/tests/test_pydough_functions/simple_pydough_functions.py b/tests/test_pydough_functions/simple_pydough_functions.py index cdd3a0eaf..bbee3e14e 100644 --- a/tests/test_pydough_functions/simple_pydough_functions.py +++ b/tests/test_pydough_functions/simple_pydough_functions.py @@ -238,7 +238,7 @@ def rank_nations_by_region(): def rank_nations_per_region_by_customers(): return regions.nations.CALCULATE( nation_name=name, - rank=RANKING(by=(COUNT(customers).DESC(), region.name), per="regions"), + rank=RANKING(by=(COUNT(customers).DESC(), name), per="regions"), ).TOP_K(5, by=rank.ASC()) @@ -2478,80 +2478,130 @@ def singular7(): def quarter_function_test(): return TPCH.CALCULATE( - QUARTER("2023-01-15"), # Q1 - QUARTER("2023-02-28"), # Q1 - QUARTER("2023-03-31"), # Q1 - QUARTER("2023-04-01"), # Q2 - QUARTER("2023-05-15"), # Q2 - QUARTER("2023-06-30"), # Q2 - QUARTER("2023-07-01"), # Q3 - QUARTER("2023-08-15"), # Q3 - QUARTER("2023-09-30"), # Q3 - QUARTER("2023-10-01"), # Q4 - QUARTER("2023-11-15"), # Q4 - QUARTER("2023-12-31"), # Q4 + QUARTER(DATETIME("2023-01-15")), # Q1 + QUARTER(DATETIME("2023-02-28")), # Q1 + QUARTER(DATETIME("2023-03-31")), # Q1 + QUARTER(DATETIME("2023-04-01")), # Q2 + QUARTER(DATETIME("2023-05-15")), # Q2 + QUARTER(DATETIME("2023-06-30")), # Q2 + QUARTER(DATETIME("2023-07-01")), # Q3 + QUARTER(DATETIME("2023-08-15")), # Q3 + QUARTER(DATETIME("2023-09-30")), # Q3 + QUARTER(DATETIME("2023-10-01")), # Q4 + QUARTER(DATETIME("2023-11-15")), # Q4 + QUARTER(DATETIME("2023-12-31")), # Q4 QUARTER(pd.Timestamp("2024-02-29 12:30:45")), # Q1 (leap year) # Testing start of quarter for different months q1_jan=DATETIME( - "2023-01-15 12:30:45", "start of quarter" + DATETIME("2023-01-15 12:30:45"), "start of quarter" ), # Should be 2023-01-01 q1_feb=DATETIME( - "2023-02-28 12:30:45", "start of quarter" + DATETIME("2023-02-28 12:30:45"), "start of quarter" ), # Should be 2023-01-01 - q1_mar=DATETIME("2023-03-31", "start of quarter"), # Should be 2023-01-01 - q2_apr=DATETIME("2023-04-01", "start of quarter"), # Should be 2023-04-01 + q1_mar=DATETIME( + DATETIME("2023-03-31"), "start of quarter" + ), # Should be 2023-01-01 + q2_apr=DATETIME( + DATETIME("2023-04-01"), "start of quarter" + ), # Should be 2023-04-01 q2_may=DATETIME( - "2023-05-15 12:30:45", "start of quarter" + DATETIME("2023-05-15 12:30:45"), "start of quarter" ), # Should be 2023-04-01 q2_jun=DATETIME( - "2023-06-30 12:30:45", "start of quarter" + DATETIME("2023-06-30 12:30:45"), "start of quarter" ), # Should be 2023-04-01 q3_jul=DATETIME( - "2023-07-01 12:30:45", "start of quarter" + DATETIME("2023-07-01 12:30:45"), "start of quarter" + ), # Should be 2023-07-01 + q3_aug=DATETIME( + DATETIME("2023-08-15"), "start of quarter" ), # Should be 2023-07-01 - q3_aug=DATETIME("2023-08-15", "start of quarter"), # Should be 2023-07-01 - q3_sep=DATETIME("2023-09-30", "start of quarter"), # Should be 2023-07-01 - q4_oct=DATETIME("2023-10-01", "start of quarter"), # Should be 2023-10-01 - q4_nov=DATETIME("2023-11-15", "start of quarter"), # Should be 2023-10-01 - q4_dec=DATETIME("2023-12-31", "start of quarter"), # Should be 2023-10-01 + q3_sep=DATETIME( + DATETIME("2023-09-30"), "start of quarter" + ), # Should be 2023-07-01 + q4_oct=DATETIME( + DATETIME("2023-10-01"), "start of quarter" + ), # Should be 2023-10-01 + q4_nov=DATETIME( + DATETIME("2023-11-15"), "start of quarter" + ), # Should be 2023-10-01 + q4_dec=DATETIME( + DATETIME("2023-12-31"), "start of quarter" + ), # Should be 2023-10-01 # Testing with different aliases for 'start of quarter' ts_q1=DATETIME(pd.Timestamp("2024-02-29 12:30:45"), "start of quarter"), - alias1=DATETIME("2023-05-15", "START OF QUARTER"), - alias2=DATETIME("2023-08-15", "Start Of Quarter"), - alias3=DATETIME("2023-11-15", "\n Start Of\tQuarter\n\n"), - alias4=DATETIME("2023-02-15", "\tSTART\tOF\tquarter\t"), + alias1=DATETIME(DATETIME("2023-05-15"), "START OF QUARTER"), + alias2=DATETIME(DATETIME("2023-08-15"), "Start Of Quarter"), + alias3=DATETIME(DATETIME("2023-11-15"), "\n Start Of\tQuarter\n\n"), + alias4=DATETIME(DATETIME("2023-02-15"), "\tSTART\tOF\tquarter\t"), # Testing chained operations - chain1=DATETIME("2023-05-15", "start of quarter", "+1 day", "+2 hours"), - chain2=DATETIME("2023-08-15", "start of quarter", "start of day"), + chain1=DATETIME( + DATETIME("2023-05-15"), "start of quarter", "+1 day", "+2 hours" + ), + chain2=DATETIME(DATETIME("2023-08-15"), "start of quarter", "start of day"), # Oct 1 from previous quarter - chain3=DATETIME("2023-11-15", "-1 month", "start of quarter"), - plus_1q=DATETIME("2023-01-15 12:30:45", "+1 quarter"), # Should be 2023-04-15 - plus_2q=DATETIME("2023-01-15 12:30:45", "+2 quarters"), # Should be 2023-07-15 - plus_3q=DATETIME("2023-01-15", "+3 quarters"), # Should be 2023-10-15 - minus_1q=DATETIME("2023-01-15 12:30:45", "-1 quarter"), # Should be 2022-10-15 - minus_2q=DATETIME("2023-01-15 12:30:45", "-2 quarters"), # Should be 2022-07-15 - minus_3q=DATETIME("2023-01-15", "-3 quarters"), # Should be 2022-04-15 + chain3=DATETIME(DATETIME("2023-11-15"), "-1 month", "start of quarter"), + plus_1q=DATETIME( + DATETIME("2023-01-15 12:30:45"), "+1 quarter" + ), # Should be 2023-04-15 + plus_2q=DATETIME( + DATETIME("2023-01-15 12:30:45"), "+2 quarters" + ), # Should be 2023-07-15 + plus_3q=DATETIME(DATETIME("2023-01-15"), "+3 quarters"), # Should be 2023-10-15 + minus_1q=DATETIME( + DATETIME("2023-01-15 12:30:45"), "-1 quarter" + ), # Should be 2022-10-15 + minus_2q=DATETIME( + DATETIME("2023-01-15 12:30:45"), "-2 quarters" + ), # Should be 2022-07-15 + minus_3q=DATETIME( + DATETIME("2023-01-15"), "-3 quarters" + ), # Should be 2022-04-15 # Testing with different syntax for quarter offsets - syntax1=DATETIME("2023-05-15", " +1 QUARTER "), - syntax2=DATETIME("2023-08-15", "+2 Q"), - syntax3=DATETIME("2023-11-15", " \n +\t3 \nQuarters \n\r "), - syntax4=DATETIME("2023-02-15", "\t-\t2\tq\t"), + syntax1=DATETIME(DATETIME("2023-05-15"), " +1 QUARTER "), + syntax2=DATETIME(DATETIME("2023-08-15"), "+2 Q"), + syntax3=DATETIME(DATETIME("2023-11-15"), " \n +\t3 \nQuarters \n\r "), + syntax4=DATETIME(DATETIME("2023-02-15"), "\t-\t2\tq\t"), # Basic quarter differences within the same year - q_diff1=DATEDIFF("quarter", "2023-01-15", "2023-04-15"), # 1 quarter - q_diff2=DATEDIFF("quarter", "2023-01-15", "2023-07-15"), # 2 quarters - q_diff3=DATEDIFF("quarter", "2023-01-15", "2023-10-15"), # 3 quarters - q_diff4=DATEDIFF("quarter", "2023-01-15", "2023-12-31"), # 3 quarters + q_diff1=DATEDIFF( + "quarter", DATETIME("2023-01-15"), DATETIME("2023-04-15") + ), # 1 quarter + q_diff2=DATEDIFF( + "quarter", DATETIME("2023-01-15"), DATETIME("2023-07-15") + ), # 2 quarters + q_diff3=DATEDIFF( + "quarter", DATETIME("2023-01-15"), DATETIME("2023-10-15") + ), # 3 quarters + q_diff4=DATEDIFF( + "quarter", DATETIME("2023-01-15"), DATETIME("2023-12-31") + ), # 3 quarters # Quarter differences across year boundaries - q_diff5=DATEDIFF("quarter", "2023-01-15", "2024-01-15"), # 4 quarters - q_diff6=DATEDIFF("quarter", "2023-01-15", "2024-04-15"), # 5 quarters - q_diff7=DATEDIFF("quarter", "2022-10-15", "2024-04-15"), # 6 quarters - q_diff8=DATEDIFF("quarter", "2020-01-01", "2025-01-01"), # 20 quarters + q_diff5=DATEDIFF( + "quarter", DATETIME("2023-01-15"), DATETIME("2024-01-15") + ), # 4 quarters + q_diff6=DATEDIFF( + "quarter", DATETIME("2023-01-15"), DATETIME("2024-04-15") + ), # 5 quarters + q_diff7=DATEDIFF( + "quarter", DATETIME("2022-10-15"), DATETIME("2024-04-15") + ), # 6 quarters + q_diff8=DATEDIFF( + "quarter", DATETIME("2020-01-01"), DATETIME("2025-01-01") + ), # 20 quarters # Negative quarter differences (earlier end date) - q_diff9=DATEDIFF("quarter", "2023-04-15", "2023-01-15"), # -1 quarter - q_diff10=DATEDIFF("quarter", "2024-01-15", "2023-01-15"), # -4 quarters + q_diff9=DATEDIFF( + "quarter", DATETIME("2023-04-15"), DATETIME("2023-01-15") + ), # -1 quarter + q_diff10=DATEDIFF( + "quarter", DATETIME("2024-01-15"), DATETIME("2023-01-15") + ), # -4 quarters # Testing with partial quarters (should still count as crossing a quarter boundary) - q_diff11=DATEDIFF("quarter", "2023-03-31", "2023-04-01"), # 1 quarter - q_diff12=DATEDIFF("quarter", "2023-12-31", "2024-01-01"), # 1 quarter + q_diff11=DATEDIFF( + "quarter", DATETIME("2023-03-31"), DATETIME("2023-04-01") + ), # 1 quarter + q_diff12=DATEDIFF( + "quarter", DATETIME("2023-12-31"), DATETIME("2024-01-01") + ), # 1 quarter # QUARTER(order_date), ) @@ -2568,8 +2618,8 @@ def order_quarter_test(): prev_quarter=DATETIME(order_date, "-1 quarter"), two_quarters_ahead=DATETIME(order_date, "+2 quarters"), two_quarters_behind=DATETIME(order_date, "-2 quarters"), - quarters_since_1995=DATEDIFF("quarter", "1995-01-01", order_date), - quarters_until_2000=DATEDIFF("quarter", order_date, "2000-01-01"), + quarters_since_1995=DATEDIFF("quarter", DATETIME("1995-01-01"), order_date), + quarters_until_2000=DATEDIFF("quarter", order_date, DATETIME("2000-01-01")), same_quarter_prev_year=DATETIME(order_date, "-4 quarters"), same_quarter_next_year=DATETIME(order_date, "+4 quarters"), ) @@ -2910,40 +2960,35 @@ def string_format_specifiers_snowflake(): def string_format_specifiers_oracle(): # String format specifiers for date/time with a static datetime - # Works for Oracle + # Works for Oracle TO_CHAR # Using a specific date: 2023-07-15 14:30:45 static_date = pd.Timestamp("2023-07-15 14:30:45") return TPCH.CALCULATE( - # four-digit year - d1=STRING(static_date, "YYYY"), - # last two digits of the year - d2=STRING(static_date, "YY"), - # two-digit month (01–12) - d3=STRING(static_date, "MM"), - # abbreviated month name - d4=STRING(static_date, "Mon"), - # full month name - d5=STRING(static_date, "MMMM"), - # two-digit day of month (01–31) - d6=STRING(static_date, "DD"), - # abbreviated day of week - d7=STRING(static_date, "DY"), - # full day of week - d8=STRING(static_date, "DYDY"), - # hour in 24-hour format (00–23) - d9=STRING(static_date, "HH24"), - # hour in 12-hour format (01–12) - d10=STRING(static_date, "HH12"), - # minute (00–59) - d11=STRING(static_date, "MI"), - # second (00–59) - d12=STRING(static_date, "SS"), - # meridian indicator - d13=STRING(static_date, "PM"), - # fractional seconds (up to 9 digits) - d14=STRING(static_date, ".FF"), - # timezone hour and minute - d15=STRING(static_date, "TZH:TZM"), + # ===== YEAR ===== + d1=STRING(static_date, "YYYY"), # four-digit year + d2=STRING(static_date, "YY"), # last two digits of year + d3=STRING(static_date, "RR"), # 2-digit year with century logic + # ===== MONTH ===== + d4=STRING(static_date, "MM"), # month number (01–12) + d5=STRING(static_date, "MON"), # abbreviated month name + d6=STRING(static_date, "MONTH"), # full month name (space-padded) + d7=STRING(static_date, "Q"), # quarter (1–4) + # ===== DAY ===== + d8=STRING(static_date, "DD"), # day of month (01–31) + d9=STRING(static_date, "DDD"), # day of year (001–366) + d10=STRING(static_date, "D"), # day of week (1–7, NLS dependent) + d11=STRING(static_date, "DY"), # abbreviated day name + d12=STRING(static_date, "DAY"), # full day name (space-padded) + # ===== WEEK ===== + d13=STRING(static_date, "W"), # week of month (1–5) + d14=STRING(static_date, "WW"), # week of year (1–53) + d15=STRING(static_date, "IW"), # ISO week number (01–53) + # ===== TIME ===== + d16=STRING(static_date, "HH24"), # hour (00–23) + d17=STRING(static_date, "HH12"), # hour (01–12) + d18=STRING(static_date, "MI"), # minute (00–59) + d19=STRING(static_date, "SS"), # second (00–59) + d20=STRING(static_date, "AM"), # meridian indicator (AM/PM) ) @@ -2957,8 +3002,8 @@ def part_reduced_size(): reduced_size=FLOAT(size / 2.5), retail_price_int=INTEGER(retail_price), message=JOIN_STRINGS( - "", - "old size: ", + " ", + "old size:", STRING(size), ), ) diff --git a/tests/test_sql_refsols/agg_simplification_2_oracle.sql b/tests/test_sql_refsols/agg_simplification_2_oracle.sql index b569bb108..5cd93957d 100644 --- a/tests/test_sql_refsols/agg_simplification_2_oracle.sql +++ b/tests/test_sql_refsols/agg_simplification_2_oracle.sql @@ -3,7 +3,7 @@ SELECT COUNT(DISTINCT sbcustcity) AS a1, COUNT(*) AS a2, COUNT(CASE WHEN LOWER(sbcustname) LIKE 'j%' THEN sbcustname ELSE NULL END) AS a3, - COALESCE(SUM(CAST(sbcustpostalcode AS INT)), 0) AS a4, + COALESCE(SUM(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0')), 0) AS a4, MIN(sbcustphone) AS a5, MAX(sbcustphone) AS a6, ANY_VALUE(LOWER(sbcuststate)) AS a7, diff --git a/tests/test_sql_refsols/aggregation_functions_oracle.sql b/tests/test_sql_refsols/aggregation_functions_oracle.sql index 940847f0a..721ff25d9 100644 --- a/tests/test_sql_refsols/aggregation_functions_oracle.sql +++ b/tests/test_sql_refsols/aggregation_functions_oracle.sql @@ -42,9 +42,9 @@ WITH "_S1" AS ( MIN(C_ACCTBAL) AS MIN_C_ACCTBAL, COUNT(DISTINCT C_ACCTBAL) AS NDISTINCT_C_ACCTBAL, STDDEV_POP(C_ACCTBAL) AS POPULATION_STD_C_ACCTBAL, - VARIANCE_POP(C_ACCTBAL) AS POPULATION_VAR_C_ACCTBAL, - STDDEV(C_ACCTBAL) AS SAMPLE_STD_C_ACCTBAL, - VARIANCE(C_ACCTBAL) AS SAMPLE_VAR_C_ACCTBAL, + VAR_POP(C_ACCTBAL) AS POPULATION_VAR_C_ACCTBAL, + CASE WHEN COUNT(C_ACCTBAL) < 2 THEN NULL ELSE STDDEV(C_ACCTBAL) END AS SAMPLE_STD_C_ACCTBAL, + CASE WHEN COUNT(C_ACCTBAL) < 2 THEN NULL ELSE VARIANCE(C_ACCTBAL) END AS SAMPLE_VAR_C_ACCTBAL, SUM(C_ACCTBAL) AS SUM_C_ACCTBAL, SUM(N_ROWS) AS SUM_N_ROWS FROM "_T2" diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql index 5cad50b49..1431d2cb2 100644 --- a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -39,7 +39,7 @@ WITH "_S0" AS ( ON "_S2".CA_DT < TRUNC(ADD_MONTHS(CAST("_T4".PR_RELEASE AS DATE), 24), 'Q') AND "_S2".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.INCIDENTS INCIDENTS - ON "_S2".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') + ON "_S2".CA_DT = TRUNC(CAST(CAST(INCIDENTS.in_error_report_ts AS DATE) AS DATE), 'DD') JOIN "_S9" "_S9" ON INCIDENTS.in_repair_country_id = "_S9".CO_ID JOIN MAIN.DEVICES DEVICES @@ -55,7 +55,7 @@ WITH "_S0" AS ( ON "_S14".CA_DT < TRUNC(ADD_MONTHS(CAST("_T8".PR_RELEASE AS DATE), 24), 'Q') AND "_S14".CA_DT >= "_T8".PR_RELEASE JOIN MAIN.DEVICES DEVICES - ON "_S14".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + ON "_S14".CA_DT = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') JOIN "_T5" "_T9" ON DEVICES.de_product_id = "_T9".PR_ID GROUP BY diff --git a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql index 467e6615c..5be1dfd75 100644 --- a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql +++ b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql @@ -1,6 +1,9 @@ WITH "_T0" AS ( SELECT - CAST(o_orderdate AS DATE) - CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_clerk ORDER BY o_orderdate) AS DATE) AS DELTA + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'DD') - TRUNC( + CAST(CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_clerk ORDER BY o_orderdate) AS DATE) AS DATE), + 'DD' + ) AS DELTA FROM TPCH.ORDERS WHERE o_orderpriority = '1-URGENT' diff --git a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql index 3c854bdb4..1a48285bf 100644 --- a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql +++ b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql @@ -2,7 +2,10 @@ WITH "_T1" AS ( SELECT CUSTOMER.c_name AS C_NAME, ORDERS.o_custkey AS O_CUSTKEY, - CAST(ORDERS.o_orderdate AS DATE) - CAST(LAG(ORDERS.o_orderdate, 1) OVER (PARTITION BY ORDERS.o_custkey ORDER BY ORDERS.o_orderdate) AS DATE) AS DAY_DIFF + TRUNC(CAST(CAST(ORDERS.o_orderdate AS DATE) AS DATE), 'DD') - TRUNC( + CAST(CAST(LAG(ORDERS.o_orderdate, 1) OVER (PARTITION BY ORDERS.o_custkey ORDER BY ORDERS.o_orderdate) AS DATE) AS DATE), + 'DD' + ) AS DAY_DIFF FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'JAPAN' diff --git a/tests/test_sql_refsols/casting_functions_oracle.sql b/tests/test_sql_refsols/casting_functions_oracle.sql index ef6fb19df..19579e241 100644 --- a/tests/test_sql_refsols/casting_functions_oracle.sql +++ b/tests/test_sql_refsols/casting_functions_oracle.sql @@ -1,6 +1,6 @@ SELECT TO_CHAR(o_orderdate, 'YYYY-MM-DD') AS cast_to_string, CAST(o_totalprice AS VARCHAR2(4000)) AS cast_to_string2, - CAST(o_totalprice AS INT) AS cast_to_integer, + TRUNC(CAST(o_totalprice AS DOUBLE PRECISION), '0') AS cast_to_integer, CAST(o_shippriority AS DOUBLE PRECISION) AS cast_to_float FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql index f8dceeef7..68b3ec7da 100644 --- a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -26,7 +26,7 @@ WITH "_T1" AS ( ON "_S7".CA_DT < ADD_MONTHS(CAST("_T7".PR_RELEASE AS DATE), 24) AND "_S7".CA_DT >= "_T7".PR_RELEASE JOIN MAIN.DEVICES DEVICES - ON "_S7".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + ON "_S7".CA_DT = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') JOIN MAIN.PRODUCTS PRODUCTS ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'AmethystCopper-I' JOIN MAIN.COUNTRIES COUNTRIES diff --git a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql index b9d4c4dcb..9a0b54849 100644 --- a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql +++ b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql @@ -1,9 +1,9 @@ SELECT SBTRANSACTION.sbtxdatetime AS date_time, - COUNT(*) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS txn_within_day, + COUNT(*) OVER (PARTITION BY TRUNC(CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) AS DATE), 'DD') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS txn_within_day, COUNT( CASE WHEN SBTRANSACTION.sbtxtype = 'buy' THEN SBTRANSACTION.sbtxtype ELSE NULL END - ) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_buys_within_day, + ) OVER (PARTITION BY TRUNC(CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) AS DATE), 'DD') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_buys_within_day, ROUND( ( 100.0 * SUM(SBTICKER.sbtickersymbol IN ('AAPL', 'AMZN')) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) diff --git a/tests/test_sql_refsols/datediff_oracle.sql b/tests/test_sql_refsols/datediff_oracle.sql index 8fa6c61dd..79d35830e 100644 --- a/tests/test_sql_refsols/datediff_oracle.sql +++ b/tests/test_sql_refsols/datediff_oracle.sql @@ -8,7 +8,7 @@ SELECT ) * 12 + ( EXTRACT(MONTH FROM TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATE)) ) AS months_diff, - TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') - CAST(sbtxdatetime AS DATE) AS days_diff, + TRUNC(CAST(TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'DD') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'DD') AS days_diff, ( TRUNC(CAST(TO_DATE('2025-05-02 11:00:00', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'HH24') - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'HH24') ) * 24 AS hours_diff, diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql index 4eafeecbc..00c1805e5 100644 --- a/tests/test_sql_refsols/datetime_current_oracle.sql +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -1,6 +1,6 @@ SELECT ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), 5) - NUMTODSINTERVAL(1, 'day') AS d1, TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(24, 'hour') AS d2, - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') + NUMTODSINTERVAL(12, 'hour') - NUMTODSINTERVAL(150, 'minute') + NUMTODSINTERVAL(2, 'second') AS d3 + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DD') + NUMTODSINTERVAL(12, 'hour') - NUMTODSINTERVAL(150, 'minute') + NUMTODSINTERVAL(2, 'second') AS d3 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/datetime_functions_oracle.sql b/tests/test_sql_refsols/datetime_functions_oracle.sql index 64315869c..39311f28d 100644 --- a/tests/test_sql_refsols/datetime_functions_oracle.sql +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -1,6 +1,6 @@ SELECT SYS_EXTRACT_UTC(SYSTIMESTAMP) AS ts_now_1, - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') AS ts_now_2, + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DD') AS ts_now_2, TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AS ts_now_3, SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(1, 'hour') AS ts_now_4, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS ts_now_5, @@ -16,8 +16,8 @@ SELECT 23 AS hour_str, 59 AS minute_str, 59 AS second_ts, - CAST('1992-01-01' AS DATE) - CAST(o_orderdate AS DATE) AS dd_col_str, - CAST(o_orderdate AS DATE) - CAST('1992-01-01' AS DATE) AS dd_str_col, + TRUNC(CAST(CAST('1992-01-01' AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'DD') AS dd_col_str, + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST('1992-01-01' AS DATE) AS DATE), 'DD') AS dd_str_col, ( EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1995-10-10 00:00:00', 'YYYY-MM-DD HH24:MI:SS')) ) * 12 + ( @@ -26,7 +26,7 @@ SELECT EXTRACT(YEAR FROM TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) AS dd_col_dt, FLOOR( ( - TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS') - CAST('1992-01-01' AS DATE) + ( + TRUNC(CAST(TO_DATE('1992-01-01 12:30:45', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'DD') - TRUNC(CAST(CAST('1992-01-01' AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST('1992-01-01' AS DATE), 'D') + -1 ), 7) diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql index 6aa41f47d..c07bd63e0 100644 --- a/tests/test_sql_refsols/datetime_sampler_oracle.sql +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -41,21 +41,21 @@ SELECT TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(312, 'hour'), SECOND), 576 ) AS "_expr29", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(75, 'day'), 'DAY') + NUMTODSINTERVAL(600, 'minute') - NUMTODSINTERVAL(294, 'day') AS "_expr30", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(75, 'day'), 'DD') + NUMTODSINTERVAL(600, 'minute') - NUMTODSINTERVAL(294, 'day') AS "_expr30", ADD_MONTHS(ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), 480), -540) AS "_expr31", TIMESTAMP_TRUNC( TRUNC( SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(270, 'minute') - NUMTODSINTERVAL(34, 'second'), - 'DAY' + 'DD' ), SECOND ) AS "_expr32", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(213, 'second') AS "_expr33", ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(13, 'minute'), 336) + NUMTODSINTERVAL(344, 'second') AS "_expr34", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') AS "_expr35", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DD') AS "_expr35", TO_DATE('2116-01-01 00:49:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr36", - TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), 'DAY') AS "_expr37", - TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY'), 'YEAR') AS "_expr38", + TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR'), 'DD') AS "_expr37", + TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DD'), 'YEAR') AS "_expr38", TO_DATE('2025-07-01 00:22:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr39", TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'YEAR') AS "_expr40", TRUNC( @@ -72,7 +72,7 @@ SELECT ADD_MONTHS(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day'), 72), -92), HOUR ) AS "_expr45", - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(285, 'second'), 'DAY') AS "_expr46", + TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(285, 'second'), 'DD') AS "_expr46", TO_DATE('1999-05-15', 'YYYY-MM-DD') AS "_expr47", TRUNC( TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + NUMTODSINTERVAL(1, 'hour'), @@ -82,7 +82,7 @@ SELECT TO_DATE('2024-01-01', 'YYYY-MM-DD') AS "_expr50", TO_DATE('1999-03-14', 'YYYY-MM-DD') AS "_expr51", ADD_MONTHS( - TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(60, 'hour'), 'DAY'), MINUTE), + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(60, 'hour'), 'DD'), MINUTE), 2352 ) AS "_expr52", TIMESTAMP_TRUNC( @@ -99,7 +99,7 @@ SELECT ) AS "_expr55", TRUNC( TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), MINUTE), SECOND), - 'DAY' + 'DD' ) + NUMTODSINTERVAL(78, 'second') AS "_expr56", ADD_MONTHS( SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(136, 'hour') + NUMTODSINTERVAL(104, 'minute'), @@ -136,8 +136,8 @@ SELECT ) * 12 + ( EXTRACT(MONTH FROM TO_DATE('2022-11-24', 'YYYY-MM-DD')) - EXTRACT(MONTH FROM TO_DATE('2006-05-01 12:00:00', 'YYYY-MM-DD HH24:MI:SS')) ) AS "_expr80", - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS "_expr81", - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST('1999-03-14' AS DATE) AS "_expr82", + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') AS "_expr81", + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST('1999-03-14' AS DATE) AS DATE), 'DD') AS "_expr82", ( TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'HH24') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'HH24') ) * 24 AS "_expr83", @@ -168,8 +168,8 @@ SELECT ) * 12 + ( EXTRACT(MONTH FROM CAST('2018-02-14 12:41:06' AS DATE)) - EXTRACT(MONTH FROM TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS')) ) AS "_expr92", - CAST(o_orderdate AS DATE) - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS "_expr93", - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS') AS "_expr94", + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') AS "_expr93", + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(TO_DATE('2019-07-04 11:30:00', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'DD') AS "_expr94", ( TRUNC(CAST(CAST('1999-03-14' AS DATE) AS DATE), 'HH24') - TRUNC(CAST(TO_DATE('2022-11-24', 'YYYY-MM-DD') AS DATE), 'HH24') ) * 24 AS "_expr95", diff --git a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql index 3f31b2044..3a15fbd40 100644 --- a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql @@ -6,7 +6,7 @@ WITH "_S1" AS ( FROM MAIN.SBDAILYPRICE WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sbdpdate AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(sbdpdate AS DATE) AS DATE), 'DD') ) <= 7 GROUP BY sbdptickerid diff --git a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql index ada0fafd1..fc718c212 100644 --- a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql @@ -4,7 +4,7 @@ WITH "_S1" AS ( COUNT(*) AS N_ROWS FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(10, 'day'), 'DAY') + sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(10, 'day'), 'DD') AND sbtxtype = 'buy' GROUP BY sbtxtickerid diff --git a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql index 6ab536d5f..520322238 100644 --- a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql @@ -1,28 +1,14 @@ WITH "_S0" AS ( SELECT - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( + 2 * -1 + )) + END, + '' ) AS MONTH, sbdptickerid AS SBDPTICKERID, COUNT(sbdpclose) AS COUNT_SBDPCLOSE, @@ -31,29 +17,15 @@ WITH "_S0" AS ( SUM(sbdpclose) AS SUM_SBDPCLOSE FROM MAIN.SBDAILYPRICE GROUP BY - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(sbdpdate AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATE))), ( + 2 * -1 + )) + END, + '' ), sbdptickerid ), "_T0" AS ( diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql index 489047f63..702fe0f43 100644 --- a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -1,28 +1,14 @@ WITH "_S2" AS ( SELECT - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( + 2 * -1 + )) + END, + '' ) AS MONTH, COUNT(*) AS N_ROWS FROM MAIN.SBCUSTOMER @@ -30,61 +16,30 @@ WITH "_S2" AS ( sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND sbcustjoindate >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'MONTH') GROUP BY - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATE))), ( + 2 * -1 + )) + END, + '' ) ), "_S3" AS ( SELECT - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), - ( - 2 * -1 - ) - ) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), - ( - 2 * -1 - ) + NVL(EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), + ( + 2 * -1 ) - END, - NULL - ), - '-' + ) + END, + '' ) AS MONTH, AVG(SBTRANSACTION.sbtxamount) AS AVG_SBTXAMOUNT FROM MAIN.SBCUSTOMER SBCUSTOMER @@ -96,35 +51,18 @@ WITH "_S2" AS ( SBCUSTOMER.sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND SBCUSTOMER.sbcustjoindate >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'MONTH') GROUP BY - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), - ( - 2 * -1 - ) - ) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) - ELSE SUBSTR( - CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), - ( - 2 * -1 - ) + NVL(EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATE))), + ( + 2 * -1 ) - END, - NULL - ), - '-' + ) + END, + '' ) ) SELECT diff --git a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql index 078f1d66c..df89f9c3f 100644 --- a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql @@ -6,7 +6,17 @@ JOIN MAIN.SBCUSTOMER SBCUSTOMER ON LOWER(SBCUSTOMER.sbcustcountry) = 'usa' AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid WHERE - SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') + SBTRANSACTION.sbtxdatetime < TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) AND SBTRANSACTION.sbtxdatetime >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') - NUMTODSINTERVAL(7, 'DAY') + TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) - NUMTODSINTERVAL(7, 'DAY') ) diff --git a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql index 9c6d3f03b..61543341f 100644 --- a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql @@ -1,5 +1,10 @@ SELECT - TRUNC(CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) AS DATE), 'IW') AS week, + TRUNC( + CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) AS week, COUNT(*) AS num_transactions, COALESCE( SUM(( @@ -14,9 +19,24 @@ JOIN MAIN.SBTICKER SBTICKER ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid AND SBTICKER.sbtickertype = 'stock' WHERE - SBTRANSACTION.sbtxdatetime < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') + SBTRANSACTION.sbtxdatetime < TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) AND SBTRANSACTION.sbtxdatetime >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') - NUMTODSINTERVAL(56, 'DAY') + TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) - NUMTODSINTERVAL(56, 'DAY') ) GROUP BY - TRUNC(CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) AS DATE), 'IW') + TRUNC( + CAST(CAST(SBTRANSACTION.sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) diff --git a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql index ca833cfcf..cfbf91605 100644 --- a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( SUM(sbtxamount) AS SUM_SBTXAMOUNT FROM MAIN.SBTRANSACTION WHERE - sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(30, 'day'), 'DAY') + sbtxdatetime >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(30, 'day'), 'DD') GROUP BY sbtxcustid ) diff --git a/tests/test_sql_refsols/defog_broker_gen1_oracle.sql b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql index 2de3ccc0b..6d5cbd5a6 100644 --- a/tests/test_sql_refsols/defog_broker_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql @@ -6,5 +6,5 @@ JOIN MAIN.SBTICKER SBTICKER AND SBTICKER.sbtickersymbol = 'VTI' WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(SBDAILYPRICE.sbdpdate AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(SBDAILYPRICE.sbdpdate AS DATE) AS DATE), 'DD') ) <= 7 diff --git a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql index 64f24683a..1d1b396a6 100644 --- a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql @@ -3,4 +3,4 @@ SELECT FROM MAIN.SBTRANSACTION SBTRANSACTION JOIN MAIN.SBCUSTOMER SBCUSTOMER ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid - AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(70, 'day'), 'DAY') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(70, 'day'), 'DD') diff --git a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql index c107b294e..8b1fb08fe 100644 --- a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql @@ -4,7 +4,7 @@ WITH "_S1" AS ( COUNT(*) AS N_ROWS FROM MAIN.SBTRANSACTION WHERE - TRUNC(CAST(sbtxdatetime AS DATE), 'DAY') = TO_DATE('2023-04-01', 'YYYY-MM-DD') + TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'DD') = TO_DATE('2023-04-01', 'YYYY-MM-DD') AND sbtxtype = 'sell' GROUP BY sbtxcustid diff --git a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql index c57110582..566612f27 100644 --- a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql @@ -7,7 +7,12 @@ WITH "_S1" AS ( sale_id ) SELECT - ROUND(AVG(CAST("_S1".MAX_PAYMENT_DATE AS DATE) - CAST(SALES.sale_date AS DATE)), 2) AS avg_days_to_payment + ROUND( + AVG( + TRUNC(CAST(CAST("_S1".MAX_PAYMENT_DATE AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(SALES.sale_date AS DATE) AS DATE), 'DD') + ), + 2 + ) AS avg_days_to_payment FROM MAIN.SALES SALES LEFT JOIN "_S1" "_S1" ON SALES."_id" = "_S1".SALE_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql index dc90bc6d2..9630ed94d 100644 --- a/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql @@ -3,5 +3,5 @@ SELECT FROM MAIN.SALES WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sale_date AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(sale_date AS DATE) AS DATE), 'DD') ) <= 7 diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql index 2483079b0..80c7273d0 100644 --- a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -1,5 +1,10 @@ SELECT - TRUNC(CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) AS DATE), 'IW') AS payment_week, + TRUNC( + CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) - MOD(( + TO_CHAR(CAST(PAYMENTS_RECEIVED.payment_date AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) AS payment_week, COUNT(*) AS total_payments, COALESCE( SUM( @@ -17,7 +22,7 @@ JOIN MAIN.SALES SALES WHERE FLOOR( ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(PAYMENTS_RECEIVED.payment_date AS DATE) + ( + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST(PAYMENTS_RECEIVED.payment_date AS DATE), 'D') + 5 ), 7) @@ -30,7 +35,7 @@ WHERE ) <= 8 AND FLOOR( ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(PAYMENTS_RECEIVED.payment_date AS DATE) + ( + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST(PAYMENTS_RECEIVED.payment_date AS DATE), 'D') + 5 ), 7) @@ -42,4 +47,9 @@ WHERE ) / 7 ) >= 1 GROUP BY - TRUNC(CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) AS DATE), 'IW') + TRUNC( + CAST(CAST(PAYMENTS_RECEIVED.payment_date AS DATE) - MOD(( + TO_CHAR(CAST(PAYMENTS_RECEIVED.payment_date AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) diff --git a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql index a81c23992..c9ee54ad4 100644 --- a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( FROM MAIN.SALES WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sale_date AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(sale_date AS DATE) AS DATE), 'DD') ) <= 30 GROUP BY salesperson_id diff --git a/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql b/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql index c999c6f8d..d0cc4d855 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql @@ -2,12 +2,12 @@ WITH _s6 AS ( SELECT DISTINCT column1 AS month_start FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) + (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) CROSS JOIN main.sales AS sales ), _s7 AS ( SELECT @@ -15,12 +15,12 @@ WITH _s6 AS ( COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) + (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) JOIN main.sales AS sales ON TIME_TO_STR(column1, '%Y-%m') = TIME_TO_STR(sales.sale_date, '%Y-%m') JOIN main.salespersons AS salespersons diff --git a/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql b/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql index d0c3c8ba9..977228a2d 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql @@ -2,12 +2,12 @@ WITH _s6 AS ( SELECT DISTINCT months_range.month_start FROM (VALUES - ROW(CAST('2025-08-01 00:00:00' AS DATETIME)), ROW(CAST('2025-09-01 00:00:00' AS DATETIME)), ROW(CAST('2025-10-01 00:00:00' AS DATETIME)), ROW(CAST('2025-11-01 00:00:00' AS DATETIME)), ROW(CAST('2025-12-01 00:00:00' AS DATETIME)), - ROW(CAST('2026-01-01 00:00:00' AS DATETIME))) AS months_range(month_start) + ROW(CAST('2026-01-01 00:00:00' AS DATETIME)), + ROW(CAST('2026-02-01 00:00:00' AS DATETIME))) AS months_range(month_start) CROSS JOIN dealership.sales AS sales ), _s7 AS ( SELECT @@ -15,12 +15,12 @@ WITH _s6 AS ( COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price FROM (VALUES - ROW(CAST('2025-08-01 00:00:00' AS DATETIME)), ROW(CAST('2025-09-01 00:00:00' AS DATETIME)), ROW(CAST('2025-10-01 00:00:00' AS DATETIME)), ROW(CAST('2025-11-01 00:00:00' AS DATETIME)), ROW(CAST('2025-12-01 00:00:00' AS DATETIME)), - ROW(CAST('2026-01-01 00:00:00' AS DATETIME))) AS months_range_2(month_start) + ROW(CAST('2026-01-01 00:00:00' AS DATETIME)), + ROW(CAST('2026-02-01 00:00:00' AS DATETIME))) AS months_range_2(month_start) JOIN dealership.sales AS sales ON DATE_FORMAT(months_range_2.month_start, '%Y-%m') = DATE_FORMAT(sales.sale_date, '%Y-%m') JOIN dealership.salespersons AS salespersons diff --git a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql index ed0cae9f2..e39e68a6e 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql @@ -2,12 +2,12 @@ WITH "_S6" AS ( SELECT DISTINCT MONTHS_RANGE.MONTH_START FROM (VALUES - (TO_TIMESTAMP('2025-08-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE(MONTH_START) + (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2026-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE(MONTH_START) CROSS JOIN MAIN.SALES SALES ), "_S7" AS ( SELECT @@ -15,12 +15,12 @@ WITH "_S6" AS ( COUNT(*) AS N_ROWS, SUM(SALES.sale_price) AS SUM_SALE_PRICE FROM (VALUES - (TO_TIMESTAMP('2025-08-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE_2(MONTH_START) + (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2026-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE_2(MONTH_START) JOIN MAIN.SALES SALES ON TO_CHAR(MONTHS_RANGE_2.MONTH_START, 'YYYY-MM') = TO_CHAR(SALES.sale_date, 'YYYY-MM') JOIN MAIN.SALESPERSONS SALESPERSONS diff --git a/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql b/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql index c57f2fdfe..d55a5166e 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql @@ -2,12 +2,12 @@ WITH _s6 AS ( SELECT DISTINCT months_range.month_start FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) + (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) CROSS JOIN main.sales AS sales ), _s7 AS ( SELECT @@ -15,12 +15,12 @@ WITH _s6 AS ( COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) + (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) JOIN main.sales AS sales ON TO_CHAR(months_range_2.month_start, 'YYYY-MM') = TO_CHAR(sales.sale_date, 'YYYY-MM') JOIN main.salespersons AS salespersons diff --git a/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql b/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql index d4530823b..ff703c098 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql @@ -2,12 +2,12 @@ WITH _s6 AS ( SELECT DISTINCT months_range.month_start FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) + (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) CROSS JOIN dealership.sales AS sales ), _s7 AS ( SELECT @@ -15,12 +15,12 @@ WITH _s6 AS ( COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price FROM (VALUES - (CAST('2025-08-01 00:00:00' AS TIMESTAMP)), (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) + (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), + (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) JOIN dealership.sales AS sales ON TO_CHAR(CAST(sales.sale_date AS TIMESTAMP), 'yyyy-mm') = TO_CHAR(months_range_2.month_start, 'yyyy-mm') JOIN dealership.salespersons AS salespersons diff --git a/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql b/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql index c1ae7f789..58190d834 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql @@ -2,12 +2,12 @@ WITH _s6 AS ( SELECT DISTINCT months_range.column1 AS month_start FROM (VALUES - ('2025-08-01 00:00:00'), ('2025-09-01 00:00:00'), ('2025-10-01 00:00:00'), ('2025-11-01 00:00:00'), ('2025-12-01 00:00:00'), - ('2026-01-01 00:00:00')) AS months_range + ('2026-01-01 00:00:00'), + ('2026-02-01 00:00:00')) AS months_range CROSS JOIN main.sales AS sales ), _s7 AS ( SELECT @@ -15,12 +15,12 @@ WITH _s6 AS ( COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price FROM (VALUES - ('2025-08-01 00:00:00'), ('2025-09-01 00:00:00'), ('2025-10-01 00:00:00'), ('2025-11-01 00:00:00'), ('2025-12-01 00:00:00'), - ('2026-01-01 00:00:00')) AS months_range_2 + ('2026-01-01 00:00:00'), + ('2026-02-01 00:00:00')) AS months_range_2 JOIN main.sales AS sales ON STRFTIME('%Y-%m', months_range_2.column1) = STRFTIME('%Y-%m', sales.sale_date) JOIN main.salespersons AS salespersons diff --git a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql index 861ab780b..b21122f4e 100644 --- a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql @@ -6,7 +6,7 @@ WITH "_S1" AS ( FROM MAIN.SALES WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(sale_date AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(sale_date AS DATE) AS DATE), 'DD') ) <= 30 GROUP BY salesperson_id diff --git a/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql index 22338ac07..cabb783ea 100644 --- a/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql @@ -2,7 +2,7 @@ SELECT first_name, last_name, phone, - CAST(termination_date AS DATE) - CAST(hire_date AS DATE) AS days_employed + TRUNC(CAST(CAST(termination_date AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(hire_date AS DATE) AS DATE), 'DD') AS days_employed FROM MAIN.SALESPERSONS WHERE NOT termination_date IS NULL diff --git a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql index b803f23c8..1e118cc68 100644 --- a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql @@ -6,7 +6,7 @@ FROM MAIN.PAYMENTS_RECEIVED WHERE FLOOR( ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(payment_date AS DATE) + ( + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(payment_date AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST(payment_date AS DATE), 'D') + 5 ), 7) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql index d3b436690..4ea39b25b 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -12,9 +12,9 @@ WITH "_u_0" AS ( AVG( tot_drug_amt / CASE WHEN ( - CAST(end_dt AS DATE) - CAST(start_dt AS DATE) + TRUNC(CAST(CAST(end_dt AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(start_dt AS DATE) AS DATE), 'DD') ) <> 0 - THEN CAST(end_dt AS DATE) - CAST(start_dt AS DATE) + THEN TRUNC(CAST(CAST(end_dt AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(start_dt AS DATE) AS DATE), 'DD') ELSE NULL END ) AS AVG_DDD diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql index ad21117e3..143da8c87 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -11,21 +11,13 @@ WITH "_T0" AS ( TRUNC(CAST(start_dt AS DATE), 'MONTH') ) SELECT - LTRIM( - NVL2(EXTRACT(YEAR FROM START_MONTH), '-' || EXTRACT(YEAR FROM START_MONTH), NULL) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM START_MONTH), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) + END, + '' ) AS start_month, NDISTINCT_DIAG_ID AS PMPD, N_ROWS AS PMTC diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql index 181e04dcc..c03025e5f 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -1,28 +1,14 @@ WITH "_S2" AS ( SELECT - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(start_dt AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(start_dt AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(start_dt AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( + 2 * -1 + )) + END, + '' ) AS TREATMENT_MONTH, COUNT(DISTINCT patient_id) AS NDISTINCT_PATIENT_ID FROM MAIN.TREATMENTS @@ -30,55 +16,27 @@ WITH "_S2" AS ( start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND start_dt >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -3) GROUP BY - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(start_dt AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(start_dt AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(start_dt AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATE))), ( + 2 * -1 + )) + END, + '' ) ), "_S3" AS ( SELECT - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( + 2 * -1 + )) + END, + '' ) AS TREATMENT_MONTH, COUNT(DISTINCT TREATMENTS.patient_id) AS NDISTINCT_PATIENT_ID FROM MAIN.TREATMENTS TREATMENTS @@ -88,29 +46,15 @@ WITH "_S2" AS ( TREATMENTS.start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') AND TREATMENTS.start_dt >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -3) GROUP BY - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), - '-' || EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), - NULL - ) || NVL2( - CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( - 2 * -1 - )) - END, - '-' || CASE - WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 - THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) - ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( - 2 * -1 - )) - END, - NULL - ), - '-' + NVL(EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATE)), '') || '-' || NVL( + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATE))), ( + 2 * -1 + )) + END, + '' ) ) SELECT diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql index 2aac034cf..6ee8534ea 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -5,7 +5,7 @@ WITH "_S1" AS ( SUM(tot_drug_amt) AS SUM_TOT_DRUG_AMT FROM MAIN.TREATMENTS WHERE - start_dt >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DAY') + start_dt >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DD') GROUP BY doc_id ), "_T1" AS ( diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql index a04bfd931..804754c54 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql @@ -6,6 +6,6 @@ SELECT FROM MAIN.ADVERSE_EVENTS ADVERSE_EVENTS JOIN MAIN.TREATMENTS TREATMENTS ON ( - CAST(ADVERSE_EVENTS.reported_dt AS DATE) - CAST(TREATMENTS.start_dt AS DATE) + TRUNC(CAST(CAST(ADVERSE_EVENTS.reported_dt AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(TREATMENTS.start_dt AS DATE) AS DATE), 'DD') ) <= 10 AND ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql index 6e39e66e4..c63b88eda 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql @@ -9,7 +9,7 @@ JOIN MAIN.CONCOMITANT_MEDS CONCOMITANT_MEDS ON CONCOMITANT_MEDS.treatment_id = TREATMENTS.treatment_id JOIN MAIN.TREATMENTS TREATMENTS_2 ON ( - CAST(CONCOMITANT_MEDS.start_dt AS DATE) - CAST(TREATMENTS_2.start_dt AS DATE) + TRUNC(CAST(CAST(CONCOMITANT_MEDS.start_dt AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(TREATMENTS_2.start_dt AS DATE) AS DATE), 'DD') ) <= 14 AND CONCOMITANT_MEDS.treatment_id = TREATMENTS_2.treatment_id AND TREATMENTS_2.is_placebo diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql index 2e8be9f05..6707dc193 100644 --- a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql +++ b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql @@ -8,4 +8,4 @@ JOIN MAIN.DRUGS DRUGS ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT DRUGS.fda_appr_dt IS NULL WHERE NOT TREATMENTS.end_dt IS NULL - AND TREATMENTS.end_dt >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DAY') + AND TREATMENTS.end_dt >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DD') diff --git a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql index 4eb15856c..1e8417ea8 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql @@ -2,5 +2,5 @@ SELECT COUNT(*) AS TUC FROM MAIN.USER_SESSIONS WHERE - session_end_ts >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1), 'DAY') - OR session_start_ts >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1), 'DAY') + session_end_ts >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1), 'DD') + OR session_start_ts >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1), 'DD') diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql index 1d1788de3..dac97790e 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql @@ -1,5 +1,10 @@ SELECT - TRUNC(CAST(CAST(NOTIFICATIONS.created_at AS DATE) AS DATE), 'IW') AS week, + TRUNC( + CAST(CAST(NOTIFICATIONS.created_at AS DATE) - MOD(( + TO_CHAR(CAST(NOTIFICATIONS.created_at AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) AS week, COUNT(*) AS num_notifs, SUM(( MOD(( @@ -10,9 +15,24 @@ FROM MAIN.NOTIFICATIONS NOTIFICATIONS JOIN MAIN.USERS USERS ON NOTIFICATIONS.user_id = USERS.uid AND USERS.country IN ('US', 'CA') WHERE - NOTIFICATIONS.created_at < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') + NOTIFICATIONS.created_at < TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) AND NOTIFICATIONS.created_at >= ( - TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'IW') - NUMTODSINTERVAL(21, 'DAY') + TRUNC( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) - NUMTODSINTERVAL(21, 'DAY') ) GROUP BY - TRUNC(CAST(CAST(NOTIFICATIONS.created_at AS DATE) AS DATE), 'IW') + TRUNC( + CAST(CAST(NOTIFICATIONS.created_at AS DATE) - MOD(( + TO_CHAR(CAST(NOTIFICATIONS.created_at AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) diff --git a/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql index b506340af..ce6911baa 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql @@ -10,5 +10,5 @@ JOIN MAIN.USERS USERS ON USERS.country = 'US' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE) AS DATE), 'DD') ) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql index 2fb495684..eaea85d51 100644 --- a/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql @@ -3,5 +3,5 @@ SELECT FROM MAIN.WALLET_USER_BALANCE_DAILY WHERE ( - CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) - CAST(updated_at AS DATE) + TRUNC(CAST(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(updated_at AS DATE) AS DATE), 'DD') ) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql index e602608c1..b70006ebc 100644 --- a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql @@ -4,7 +4,7 @@ WITH "_S1" AS ( receiver_id AS RECEIVER_ID FROM MAIN.WALLET_TRANSACTIONS_DAILY WHERE - created_at >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(150, 'day'), 'DAY') + created_at >= TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(150, 'day'), 'DD') AND receiver_type = 1 ) SELECT diff --git a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql index 0cc2e2312..e98b8a4b5 100644 --- a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql +++ b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql @@ -19,7 +19,7 @@ WITH "_T0" AS ( AND MERCHANTS.mid = WALLET_MERCHANT_BALANCE_DAILY.merchant_id AND MERCHANTS.status = 'active' WHERE - TRUNC(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS DATE), 'DAY') = TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DAY') + TRUNC(CAST(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS DATE) AS DATE), 'DD') = TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DD') ) SELECT AVG(EXPR_1) AS "_expr0" diff --git a/tests/test_sql_refsols/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql index 78afedfe7..8bc2ed8e7 100644 --- a/tests/test_sql_refsols/double_cross_oracle.sql +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -10,7 +10,7 @@ WITH "_T3" AS ( SELECT FLOOR( ( - CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(ORDERS.o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S0".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S0".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) @@ -26,7 +26,7 @@ WITH "_T3" AS ( JOIN TPCH.ORDERS ORDERS ON FLOOR( ( - CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(ORDERS.o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S0".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S0".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) @@ -42,7 +42,7 @@ WITH "_T3" AS ( GROUP BY FLOOR( ( - CAST(ORDERS.o_orderdate AS DATE) - CAST("_S0".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(ORDERS.o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S0".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S0".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) @@ -61,7 +61,7 @@ WITH "_T3" AS ( SELECT FLOOR( ( - CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(LINEITEM.l_receiptdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S3".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) @@ -81,7 +81,7 @@ WITH "_T3" AS ( ON EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATE)) = 1992 AND FLOOR( ( - CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(LINEITEM.l_receiptdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S3".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) @@ -96,7 +96,7 @@ WITH "_T3" AS ( AND LINEITEM.l_shipmode = 'RAIL' AND "_S2".ORD_WK = FLOOR( ( - CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(LINEITEM.l_receiptdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S3".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) @@ -110,7 +110,7 @@ WITH "_T3" AS ( GROUP BY FLOOR( ( - CAST(LINEITEM.l_receiptdate AS DATE) - CAST("_S3".MIN_O_ORDERDATE AS DATE) + ( + TRUNC(CAST(CAST(LINEITEM.l_receiptdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S3".MIN_O_ORDERDATE AS DATE) AS DATE), 'DD') + ( MOD(( TO_CHAR(CAST("_S3".MIN_O_ORDERDATE AS DATE), 'D') + -1 ), 7) diff --git a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql index 95f7660bb..7916b3dc0 100644 --- a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql +++ b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql @@ -4,7 +4,10 @@ WITH "_T2" AS ( ERAS.er_name AS ER_NAME, ERAS.er_start_year AS ER_START_YEAR, EVENTS.ev_dt AS EV_DT, - CAST(EVENTS.ev_dt AS DATE) - CAST(LAG(EVENTS.ev_dt, 1) OVER (PARTITION BY ERAS.er_name, ERAS.er_name ORDER BY EVENTS.ev_dt) AS DATE) AS DAY_GAP + TRUNC(CAST(CAST(EVENTS.ev_dt AS DATE) AS DATE), 'DD') - TRUNC( + CAST(CAST(LAG(EVENTS.ev_dt, 1) OVER (PARTITION BY ERAS.er_name, ERAS.er_name ORDER BY EVENTS.ev_dt) AS DATE) AS DATE), + 'DD' + ) AS DAY_GAP FROM ERAS ERAS JOIN EVENTS EVENTS ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) diff --git a/tests/test_sql_refsols/extract_colors_oracle.sql b/tests/test_sql_refsols/extract_colors_oracle.sql index e5e2ab57e..d599bd46c 100644 --- a/tests/test_sql_refsols/extract_colors_oracle.sql +++ b/tests/test_sql_refsols/extract_colors_oracle.sql @@ -1,11 +1,113 @@ SELECT p_partkey AS key, - UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 1)) AS c1, - UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 2)) AS c2, - UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 3)) AS c3, - UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 4)) AS c4, - UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 5)) AS c5, - UPPER(REGEXP_SUBSTR(p_name, '[^ ]+', 1, 6)) AS c6 + UPPER( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ) + ) AS c1, + UPPER( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 1 + THEN 2 + ELSE NULL + END, + NULL, + 1 + ) + ) AS c2, + UPPER( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 2 + THEN 3 + ELSE NULL + END, + NULL, + 1 + ) + ) AS c3, + UPPER( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 3 + THEN 4 + ELSE NULL + END, + NULL, + 1 + ) + ) AS c4, + UPPER( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 4 + THEN 5 + ELSE NULL + END, + NULL, + 1 + ) + ) AS c5, + UPPER( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 5 + THEN 6 + ELSE NULL + END, + NULL, + 1 + ) + ) AS c6 FROM TPCH.PART ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/function_sampler_oracle.sql b/tests/test_sql_refsols/function_sampler_oracle.sql index 412f2fe19..fe3d2cd63 100644 --- a/tests/test_sql_refsols/function_sampler_oracle.sql +++ b/tests/test_sql_refsols/function_sampler_oracle.sql @@ -1,8 +1,5 @@ SELECT - LTRIM( - NVL2(REGION.r_name, '-' || REGION.r_name, NULL) || NVL2(NATION.n_name, '-' || NATION.n_name, NULL) || NVL2(SUBSTR(CUSTOMER.c_name, 17), '-' || SUBSTR(CUSTOMER.c_name, 17), NULL), - '-' - ) AS a, + NVL(REGION.r_name, '') || '-' || NVL(NATION.n_name, '') || '-' || NVL(SUBSTR(CUSTOMER.c_name, 17), '') AS a, ROUND(CUSTOMER.c_acctbal, 1) AS b, CASE WHEN SUBSTR(CUSTOMER.c_phone, 1, 1) = '3' THEN CUSTOMER.c_name ELSE NULL END AS c, NOT CASE diff --git a/tests/test_sql_refsols/get_part_multiple_oracle.sql b/tests/test_sql_refsols/get_part_multiple_oracle.sql index e99f6fe52..d175cdcbb 100644 --- a/tests/test_sql_refsols/get_part_multiple_oracle.sql +++ b/tests/test_sql_refsols/get_part_multiple_oracle.sql @@ -1,212 +1,1023 @@ SELECT - CAST(SUBSTR(sbcustid, 2) AS INT) AS "_expr0", + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') AS "_expr0", REGEXP_SUBSTR( sbcustname, - '[^ ]+', + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, ' ') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p1, REGEXP_SUBSTR( sbcustname, - '[^ ]+', + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, ' ') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 - END + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + ELSE NULL + END, + NULL, + 1 ) AS p2, REGEXP_SUBSTR( sbcustemail, - '[^.]+', + '(.*?)(' || REGEXP_REPLACE('.', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustemail, '.') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p3, REGEXP_SUBSTR( sbcustemail, - '[^.]+', + '(.*?)(' || REGEXP_REPLACE('.', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustemail, '.') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 - END + WHEN ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustemail) - LENGTH(REPLACE(sbcustemail, '.')) + ) / LENGTH('.') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + ELSE NULL + END, + NULL, + 1 ) AS p4, REGEXP_SUBSTR( sbcustphone, - '[^-]+', + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustphone, '-') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p5, REGEXP_SUBSTR( sbcustphone, - '[^-]+', + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustphone, '-') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 - END + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + ELSE NULL + END, + NULL, + 1 ) AS p6, REGEXP_SUBSTR( sbcustpostalcode, - '[^00]+', + '(.*?)(' || REGEXP_REPLACE('00', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustpostalcode, '00') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p7, REGEXP_SUBSTR( sbcustpostalcode, - '[^00]+', + '(.*?)(' || REGEXP_REPLACE('00', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustpostalcode, '00') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 - END + WHEN ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '00')) + ) / LENGTH('00') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + ELSE NULL + END, + NULL, + 1 ) AS p8, REGEXP_SUBSTR( sbcustname, - '[^!]+', + '(.*?)(' || REGEXP_REPLACE('!', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, '!') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '!')) + ) / LENGTH('!') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '!')) + ) / LENGTH('!') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '!')) + ) / LENGTH('!') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '!')) + ) / LENGTH('!') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p9, REGEXP_SUBSTR( sbcustname, - '[^@]+', + '(.*?)(' || REGEXP_REPLACE('@', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, '@') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 - END + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '@')) + ) / LENGTH('@') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '@')) + ) / LENGTH('@') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '@')) + ) / LENGTH('@') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '@')) + ) / LENGTH('@') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + ELSE NULL + END, + NULL, + 1 ) AS p10, REGEXP_SUBSTR( sbcustname, - '[^aa]+', + '(.*?)(' || REGEXP_REPLACE('aa', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, 'aa') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, 'aa')) + ) / LENGTH('aa') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, 'aa')) + ) / LENGTH('aa') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, 'aa')) + ) / LENGTH('aa') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, 'aa')) + ) / LENGTH('aa') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p11, REGEXP_SUBSTR( sbcustname, - '[^#$*]+', + '(.*?)(' || REGEXP_REPLACE('#$*', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, '#$*') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 - END + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '#$*')) + ) / LENGTH('#$*') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '#$*')) + ) / LENGTH('#$*') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '#$*')) + ) / LENGTH('#$*') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) > 0 + THEN 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, '#$*')) + ) / LENGTH('#$*') + ) + 2 + ( + 0 - TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ) + END + ELSE NULL + END, + NULL, + 1 ) AS p12, - REGEXP_SUBSTR( - sbcustname, - '[^]+', - 1, - CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustname, '') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END - ) AS p13, + CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 1 + THEN sbcustname + ELSE NULL + END AS p13, REGEXP_SUBSTR( '', - '[^ ]+', + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT('', ' ') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH('') - LENGTH(REPLACE('', ' ')) + ) / LENGTH(' ') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH('') - LENGTH(REPLACE('', ' ')) + ) / LENGTH(' ') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH('') - LENGTH(REPLACE('', ' ')) + ) / LENGTH(' ') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH('') - LENGTH(REPLACE('', ' ')) + ) / LENGTH(' ') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p14, - REGEXP_SUBSTR(sbcustname, '[^ ]+', 1, 1) AS p15, REGEXP_SUBSTR( - sbcuststate, - '[^' || sbcuststate || ']+', + sbcustname, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) >= 0 THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcuststate, sbcuststate) + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE NULL + END, + NULL, + 1 + ) AS p15, + CASE + WHEN sbcuststate = '' OR sbcuststate IS NULL + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 1 + THEN sbcuststate + ELSE NULL END - ) AS p16, + ELSE REGEXP_SUBSTR( + sbcuststate, + '(.*?)(' || REGEXP_REPLACE(sbcuststate, '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcuststate) - LENGTH(REPLACE(sbcuststate, sbcuststate)) + ) / LENGTH(sbcuststate) + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcuststate) - LENGTH(REPLACE(sbcuststate, sbcuststate)) + ) / LENGTH(sbcuststate) + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcuststate) - LENGTH(REPLACE(sbcuststate, sbcuststate)) + ) / LENGTH(sbcuststate) + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcuststate) - LENGTH(REPLACE(sbcuststate, sbcuststate)) + ) / LENGTH(sbcuststate) + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 + ) + END AS p16, REGEXP_SUBSTR( - REGEXP_SUBSTR(sbcustphone, '[^-]+', 1, 1), - '[^5]+', + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ), + '(.*?)(' || REGEXP_REPLACE('5', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(REGEXP_SUBSTR(sbcustphone, '[^-]+', 1, 1), '5') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ) + ) - LENGTH( + REPLACE( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ), + '5' + ) + ) + ) / LENGTH('5') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ) + ) - LENGTH( + REPLACE( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ), + '5' + ) + ) + ) / LENGTH('5') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ) + ) - LENGTH( + REPLACE( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ), + '5' + ) + ) + ) / LENGTH('5') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ) + ) - LENGTH( + REPLACE( + REGEXP_SUBSTR( + sbcustphone, + '(.*?)(' || REGEXP_REPLACE('-', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustphone) - LENGTH(REPLACE(sbcustphone, '-')) + ) / LENGTH('-') + ) >= 0 + THEN 1 + ELSE NULL + END, + NULL, + 1 + ), + '5' + ) + ) + ) / LENGTH('5') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p17, REGEXP_SUBSTR( sbcustpostalcode, - '[^0]+', + '(.*?)(' || REGEXP_REPLACE('0', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', 1, CASE - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 - THEN 1 - WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 - THEN CAST(SUBSTR(sbcustid, 2) AS INT) - ELSE REGEXP_COUNT(sbcustpostalcode, '0') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) - END + WHEN ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '0')) + ) / LENGTH('0') + ) + 1 >= CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '0')) + ) / LENGTH('0') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + AND CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '0')) + ) / LENGTH('0') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END >= 1 + THEN CASE + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') = 0 + THEN 1 + WHEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') > 0 + THEN TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + ELSE ( + ( + LENGTH(sbcustpostalcode) - LENGTH(REPLACE(sbcustpostalcode, '0')) + ) / LENGTH('0') + ) + 2 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') + END + ELSE NULL + END, + NULL, + 1 ) AS p18 FROM MAIN.SBCUSTOMER WHERE - CAST(SUBSTR(sbcustid, 2) AS INT) <= 4 + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') <= 4 ORDER BY 1 NULLS FIRST diff --git a/tests/test_sql_refsols/get_part_single_oracle.sql b/tests/test_sql_refsols/get_part_single_oracle.sql index 79ed97cbd..7f1dee4ea 100644 --- a/tests/test_sql_refsols/get_part_single_oracle.sql +++ b/tests/test_sql_refsols/get_part_single_oracle.sql @@ -1,5 +1,33 @@ SELECT - REGEXP_SUBSTR(sbcustname, '[^ ]+', 1, REGEXP_COUNT(sbcustname, ' ') + 1) AS last_name + REGEXP_SUBSTR( + sbcustname, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 1 >= ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 1 + AND ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) >= 0 + THEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) + 1 + ELSE NULL + END, + NULL, + 1 + ) AS last_name FROM MAIN.SBCUSTOMER WHERE sbcustname = 'Alex Rodriguez' diff --git a/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql index 50c70386f..fda280f63 100644 --- a/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql +++ b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql @@ -1,6 +1,9 @@ SELECT AVG( - CAST(LEAST(LINEITEM.l_commitdate, LINEITEM.l_receiptdate) AS DATE) - CAST(ORDERS.o_orderdate AS DATE) + TRUNC( + CAST(CAST(LEAST(LINEITEM.l_commitdate, LINEITEM.l_receiptdate) AS DATE) AS DATE), + 'DD' + ) - TRUNC(CAST(CAST(ORDERS.o_orderdate AS DATE) AS DATE), 'DD') ) AS avg_gap FROM TPCH.LINEITEM LINEITEM JOIN TPCH.ORDERS ORDERS diff --git a/tests/test_sql_refsols/order_quarter_test_ansi.sql b/tests/test_sql_refsols/order_quarter_test_ansi.sql index a9bfbedd3..da3162a16 100644 --- a/tests/test_sql_refsols/order_quarter_test_ansi.sql +++ b/tests/test_sql_refsols/order_quarter_test_ansi.sql @@ -6,8 +6,8 @@ SELECT DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 1, QUARTER) AS prev_quarter, DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 2, 'QUARTER') AS two_quarters_ahead, DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 2, QUARTER) AS two_quarters_behind, - DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1995-01-01' AS TIMESTAMP), QUARTER) AS quarters_since_1995, - DATEDIFF(CAST('2000-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), QUARTER) AS quarters_until_2000, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1995-01-01' AS DATE), QUARTER) AS quarters_since_1995, + DATEDIFF(CAST('2000-01-01' AS DATE), CAST(o_orderdate AS DATETIME), QUARTER) AS quarters_until_2000, DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 4, QUARTER) AS same_quarter_prev_year, DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 4, 'QUARTER') AS same_quarter_next_year FROM tpch.orders diff --git a/tests/test_sql_refsols/order_quarter_test_mysql.sql b/tests/test_sql_refsols/order_quarter_test_mysql.sql index 6bbeb439d..a4960f153 100644 --- a/tests/test_sql_refsols/order_quarter_test_mysql.sql +++ b/tests/test_sql_refsols/order_quarter_test_mysql.sql @@ -15,14 +15,14 @@ SELECT DATE_ADD(CAST(o_orderdate AS DATETIME), INTERVAL '2' QUARTER) AS two_quarters_ahead, DATE_SUB(CAST(o_orderdate AS DATETIME), INTERVAL '2' QUARTER) AS two_quarters_behind, ( - YEAR(o_orderdate) - YEAR(CAST('1995-01-01' AS DATETIME)) + YEAR(o_orderdate) - YEAR(CAST('1995-01-01' AS DATE)) ) * 4 + ( - QUARTER(o_orderdate) - QUARTER(CAST('1995-01-01' AS DATETIME)) + QUARTER(o_orderdate) - QUARTER(CAST('1995-01-01' AS DATE)) ) AS quarters_since_1995, ( - YEAR(CAST('2000-01-01' AS DATETIME)) - YEAR(o_orderdate) + YEAR(CAST('2000-01-01' AS DATE)) - YEAR(o_orderdate) ) * 4 + ( - QUARTER(CAST('2000-01-01' AS DATETIME)) - QUARTER(o_orderdate) + QUARTER(CAST('2000-01-01' AS DATE)) - QUARTER(o_orderdate) ) AS quarters_until_2000, DATE_SUB(CAST(o_orderdate AS DATETIME), INTERVAL '4' QUARTER) AS same_quarter_prev_year, DATE_ADD(CAST(o_orderdate AS DATETIME), INTERVAL '4' QUARTER) AS same_quarter_next_year diff --git a/tests/test_sql_refsols/order_quarter_test_oracle.sql b/tests/test_sql_refsols/order_quarter_test_oracle.sql index b1f3f0b31..9844cef4f 100644 --- a/tests/test_sql_refsols/order_quarter_test_oracle.sql +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -1,20 +1,30 @@ SELECT o_orderdate AS order_date, - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) AS quarter, + FLOOR(( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - 1 + ) / 3) + 1 AS quarter, TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'Q') AS quarter_start, CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(3, 'MONTH') AS next_quarter, CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(3, 'MONTH') AS prev_quarter, CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(6, 'MONTH') AS two_quarters_ahead, CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(6, 'MONTH') AS two_quarters_behind, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1995-01-01' AS DATE)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1995-01-01', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST('1995-01-01' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('1995-01-01', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS quarters_since_1995, ( - EXTRACT(YEAR FROM CAST('2000-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2000-01-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2000-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2000-01-01', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - 1 + ) / 3) ) AS quarters_until_2000, CAST(o_orderdate AS DATE) - NUMTOYMINTERVAL(12, 'MONTH') AS same_quarter_prev_year, CAST(o_orderdate AS DATE) + NUMTOYMINTERVAL(12, 'MONTH') AS same_quarter_next_year diff --git a/tests/test_sql_refsols/order_quarter_test_postgres.sql b/tests/test_sql_refsols/order_quarter_test_postgres.sql index 12ae148da..36bce998a 100644 --- a/tests/test_sql_refsols/order_quarter_test_postgres.sql +++ b/tests/test_sql_refsols/order_quarter_test_postgres.sql @@ -7,14 +7,14 @@ SELECT CAST(o_orderdate AS TIMESTAMP) + INTERVAL '6 MONTH' AS two_quarters_ahead, CAST(o_orderdate AS TIMESTAMP) - INTERVAL '6 MONTH' AS two_quarters_behind, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('1995-01-01' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST(o_orderdate AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('1995-01-01' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(o_orderdate AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('1995-01-01' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST(o_orderdate AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('1995-01-01' AS DATE)) ) AS quarters_since_1995, ( - EXTRACT(YEAR FROM CAST('2000-01-01' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST(o_orderdate AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2000-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST(o_orderdate AS TIMESTAMP)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2000-01-01' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST(o_orderdate AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2000-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST(o_orderdate AS TIMESTAMP)) ) AS quarters_until_2000, CAST(o_orderdate AS TIMESTAMP) - INTERVAL '12 MONTH' AS same_quarter_prev_year, CAST(o_orderdate AS TIMESTAMP) + INTERVAL '12 MONTH' AS same_quarter_next_year diff --git a/tests/test_sql_refsols/order_quarter_test_snowflake.sql b/tests/test_sql_refsols/order_quarter_test_snowflake.sql index 5308f54d6..52304abbb 100644 --- a/tests/test_sql_refsols/order_quarter_test_snowflake.sql +++ b/tests/test_sql_refsols/order_quarter_test_snowflake.sql @@ -6,8 +6,8 @@ SELECT DATEADD(QUARTER, -1, CAST(o_orderdate AS TIMESTAMP)) AS prev_quarter, DATEADD(QUARTER, 2, CAST(o_orderdate AS TIMESTAMP)) AS two_quarters_ahead, DATEADD(QUARTER, -2, CAST(o_orderdate AS TIMESTAMP)) AS two_quarters_behind, - DATEDIFF(QUARTER, CAST('1995-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME)) AS quarters_since_1995, - DATEDIFF(QUARTER, CAST(o_orderdate AS DATETIME), CAST('2000-01-01' AS TIMESTAMP)) AS quarters_until_2000, + DATEDIFF(QUARTER, CAST('1995-01-01' AS DATE), CAST(o_orderdate AS DATETIME)) AS quarters_since_1995, + DATEDIFF(QUARTER, CAST(o_orderdate AS DATETIME), CAST('2000-01-01' AS DATE)) AS quarters_until_2000, DATEADD(QUARTER, -4, CAST(o_orderdate AS TIMESTAMP)) AS same_quarter_prev_year, DATEADD(QUARTER, 4, CAST(o_orderdate AS TIMESTAMP)) AS same_quarter_next_year FROM tpch.orders diff --git a/tests/test_sql_refsols/order_quarter_test_sqlite.sql b/tests/test_sql_refsols/order_quarter_test_sqlite.sql index 5e514e939..0ad61c7c7 100644 --- a/tests/test_sql_refsols/order_quarter_test_sqlite.sql +++ b/tests/test_sql_refsols/order_quarter_test_sqlite.sql @@ -28,7 +28,7 @@ SELECT DATETIME(o_orderdate, '6 month') AS two_quarters_ahead, DATETIME(o_orderdate, '-6 month') AS two_quarters_behind, ( - CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('1995-01-01')) AS INTEGER) + CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', '1995-01-01') AS INTEGER) ) * 4 + CASE WHEN CAST(STRFTIME('%m', o_orderdate) AS INTEGER) <= 3 AND CAST(STRFTIME('%m', o_orderdate) AS INTEGER) >= 1 @@ -43,33 +43,33 @@ SELECT AND CAST(STRFTIME('%m', o_orderdate) AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('1995-01-01')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '1995-01-01') AS INTEGER) >= 10 THEN 4 END AS quarters_since_1995, ( - CAST(STRFTIME('%Y', DATETIME('2000-01-01')) AS INTEGER) - CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) + CAST(STRFTIME('%Y', '2000-01-01') AS INTEGER) - CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2000-01-01')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2000-01-01') AS INTEGER) >= 10 THEN 4 END - CASE WHEN CAST(STRFTIME('%m', o_orderdate) AS INTEGER) <= 3 diff --git a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql index 64905f5d0..073c7a449 100644 --- a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql +++ b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql @@ -27,7 +27,7 @@ WITH "_S4" AS ( SELECT "_S5".C_NAME AS customer_name, "_S4".O_ORDERKEY AS order_key, - CAST("_S4".O_ORDERDATE AS DATE) - CAST("_S5".O_ORDERDATE AS DATE) AS days_since_first_order + TRUNC(CAST(CAST("_S4".O_ORDERDATE AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST("_S5".O_ORDERDATE AS DATE) AS DATE), 'DD') AS days_since_first_order FROM "_S4" "_S4" LEFT JOIN "_S5" "_S5" ON "_S4".O_CUSTKEY = "_S5".C_CUSTKEY diff --git a/tests/test_sql_refsols/part_reduced_size_ansi.sql b/tests/test_sql_refsols/part_reduced_size_ansi.sql index 654b3fbe0..64f38bae1 100644 --- a/tests/test_sql_refsols/part_reduced_size_ansi.sql +++ b/tests/test_sql_refsols/part_reduced_size_ansi.sql @@ -11,7 +11,7 @@ WITH _s0 AS ( SELECT CAST(_s0.p_size / 2.5 AS DOUBLE) AS reduced_size, CAST(_s0.p_retailprice AS BIGINT) AS retail_price_int, - CONCAT_WS('', 'old size: ', CAST(_s0.p_size AS TEXT)) AS message, + CONCAT_WS(' ', 'old size:', CAST(_s0.p_size AS TEXT)) AS message, lineitem.l_discount AS discount, TIME_TO_STR(lineitem.l_receiptdate, '%d-%m-%Y') AS date_dmy, TIME_TO_STR(lineitem.l_receiptdate, '%m/%d') AS date_md, diff --git a/tests/test_sql_refsols/part_reduced_size_mysql.sql b/tests/test_sql_refsols/part_reduced_size_mysql.sql index b0d8921cb..7aa59b919 100644 --- a/tests/test_sql_refsols/part_reduced_size_mysql.sql +++ b/tests/test_sql_refsols/part_reduced_size_mysql.sql @@ -11,7 +11,7 @@ WITH _s0 AS ( SELECT CAST(_s0.p_size / 2.5 AS DOUBLE) AS reduced_size, TRUNCATE(CAST(_s0.p_retailprice AS FLOAT), 0) AS retail_price_int, - CONCAT_WS('', 'old size: ', CAST(_s0.p_size AS CHAR)) AS message, + CONCAT_WS(' ', 'old size:', CAST(_s0.p_size AS CHAR)) AS message, LINEITEM.l_discount AS discount, DATE_FORMAT(LINEITEM.l_receiptdate, '%d-%m-%Y') COLLATE utf8mb4_bin AS date_dmy, DATE_FORMAT(LINEITEM.l_receiptdate, '%m/%d') AS date_md, diff --git a/tests/test_sql_refsols/part_reduced_size_oracle.sql b/tests/test_sql_refsols/part_reduced_size_oracle.sql index d46b70223..bd9e8d9bb 100644 --- a/tests/test_sql_refsols/part_reduced_size_oracle.sql +++ b/tests/test_sql_refsols/part_reduced_size_oracle.sql @@ -5,24 +5,17 @@ WITH "_S0" AS ( p_size AS P_SIZE FROM TPCH.PART ORDER BY - CAST(p_retailprice AS INT) NULLS FIRST + TRUNC(CAST(p_retailprice AS DOUBLE PRECISION), '0') NULLS FIRST FETCH FIRST 2 ROWS ONLY ) SELECT CAST("_S0".P_SIZE / 2.5 AS DOUBLE PRECISION) AS reduced_size, - CAST("_S0".P_RETAILPRICE AS INT) AS retail_price_int, - LTRIM( - NVL2('old size: ', 'old size: ', NULL) || NVL2( - CAST("_S0".P_SIZE AS VARCHAR2(4000)), - '' || CAST("_S0".P_SIZE AS VARCHAR2(4000)), - NULL - ), - '' - ) AS message, + TRUNC(CAST("_S0".P_RETAILPRICE AS DOUBLE PRECISION), '0') AS retail_price_int, + 'old size: ' || NVL(CAST("_S0".P_SIZE AS VARCHAR2(4000)), '') AS message, LINEITEM.l_discount AS discount, TO_CHAR(LINEITEM.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, TO_CHAR(LINEITEM.l_receiptdate, 'MM/DD') AS date_md, - TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MI%p') AS am_pm + TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MIAM') AS am_pm FROM "_S0" "_S0" JOIN TPCH.LINEITEM LINEITEM ON LINEITEM.l_partkey = "_S0".P_PARTKEY diff --git a/tests/test_sql_refsols/part_reduced_size_postgres.sql b/tests/test_sql_refsols/part_reduced_size_postgres.sql index 31d6c69f9..41e4912a0 100644 --- a/tests/test_sql_refsols/part_reduced_size_postgres.sql +++ b/tests/test_sql_refsols/part_reduced_size_postgres.sql @@ -11,7 +11,7 @@ WITH _s0 AS ( SELECT CAST(_s0.p_size AS DOUBLE PRECISION) / 2.5 AS reduced_size, CAST(_s0.p_retailprice AS INT) AS retail_price_int, - CONCAT_WS('', 'old size: ', CAST(_s0.p_size AS TEXT)) AS message, + CONCAT_WS(' ', 'old size:', CAST(_s0.p_size AS TEXT)) AS message, lineitem.l_discount AS discount, TO_CHAR(lineitem.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, TO_CHAR(lineitem.l_receiptdate, 'MM/DD') AS date_md, diff --git a/tests/test_sql_refsols/part_reduced_size_snowflake.sql b/tests/test_sql_refsols/part_reduced_size_snowflake.sql index d71110aa6..654be9ade 100644 --- a/tests/test_sql_refsols/part_reduced_size_snowflake.sql +++ b/tests/test_sql_refsols/part_reduced_size_snowflake.sql @@ -11,7 +11,7 @@ WITH _s0 AS ( SELECT CAST(_s0.p_size / 2.5 AS DOUBLE) AS reduced_size, CAST(_s0.p_retailprice AS BIGINT) AS retail_price_int, - CONCAT_WS('', 'old size: ', CAST(_s0.p_size AS TEXT)) AS message, + CONCAT_WS(' ', 'old size:', CAST(_s0.p_size AS TEXT)) AS message, lineitem.l_discount AS discount, TO_CHAR(CAST(lineitem.l_receiptdate AS TIMESTAMP), 'DD-mm-yyyy') AS date_dmy, TO_CHAR(CAST(lineitem.l_receiptdate AS TIMESTAMP), 'mm/DD') AS date_md, diff --git a/tests/test_sql_refsols/part_reduced_size_sqlite.sql b/tests/test_sql_refsols/part_reduced_size_sqlite.sql index cdf3c0eb6..64fa12d04 100644 --- a/tests/test_sql_refsols/part_reduced_size_sqlite.sql +++ b/tests/test_sql_refsols/part_reduced_size_sqlite.sql @@ -11,7 +11,7 @@ WITH _s0 AS ( SELECT CAST(CAST(_s0.p_size AS REAL) / 2.5 AS REAL) AS reduced_size, CAST(_s0.p_retailprice AS INTEGER) AS retail_price_int, - CONCAT_WS('', 'old size: ', CAST(_s0.p_size AS TEXT)) AS message, + CONCAT_WS(' ', 'old size:', CAST(_s0.p_size AS TEXT)) AS message, lineitem.l_discount AS discount, STRFTIME('%d-%m-%Y', lineitem.l_receiptdate) AS date_dmy, STRFTIME('%m/%d', lineitem.l_receiptdate) AS date_md, diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql index ec177ba9e..b9a002183 100644 --- a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -19,7 +19,7 @@ WITH "_T2" AS ( AND "_S3".CA_DT >= "_T4".PR_RELEASE JOIN MAIN.DEVICES DEVICES ON DEVICES.de_product_id = 800544 - AND "_S3".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + AND "_S3".CA_DT = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') GROUP BY "_S3".CA_DT ), "_S22" AS ( @@ -60,7 +60,7 @@ WITH "_T2" AS ( ON "_S13".QUARTER = TRUNC(CAST(CAST("_S17".CA_DT AS DATE) AS DATE), 'Q') JOIN MAIN.INCIDENTS INCIDENTS ON COUNTRIES.co_id = INCIDENTS.in_repair_country_id - AND "_S17".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') + AND "_S17".CA_DT = TRUNC(CAST(CAST(INCIDENTS.in_error_report_ts AS DATE) AS DATE), 'DD') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = 800544 WHERE diff --git a/tests/test_sql_refsols/quarter_function_test_ansi.sql b/tests/test_sql_refsols/quarter_function_test_ansi.sql index 6cf6425fa..1cb3f40e1 100644 --- a/tests/test_sql_refsols/quarter_function_test_ansi.sql +++ b/tests/test_sql_refsols/quarter_function_test_ansi.sql @@ -42,17 +42,17 @@ SELECT CAST('2024-02-15' AS DATE) AS syntax2, CAST('2024-08-15' AS DATE) AS syntax3, CAST('2022-08-15' AS DATE) AS syntax4, - DATEDIFF(CAST('2023-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff1, - DATEDIFF(CAST('2023-07-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff2, - DATEDIFF(CAST('2023-10-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff3, - DATEDIFF(CAST('2023-12-31' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff4, - DATEDIFF(CAST('2024-01-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff5, - DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff6, - DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2022-10-15' AS TIMESTAMP), QUARTER) AS q_diff7, - DATEDIFF(CAST('2025-01-01' AS TIMESTAMP), CAST('2020-01-01' AS TIMESTAMP), QUARTER) AS q_diff8, - DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2023-04-15' AS TIMESTAMP), QUARTER) AS q_diff9, - DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2024-01-15' AS TIMESTAMP), QUARTER) AS q_diff10, - DATEDIFF(CAST('2023-04-01' AS TIMESTAMP), CAST('2023-03-31' AS TIMESTAMP), QUARTER) AS q_diff11, - DATEDIFF(CAST('2024-01-01' AS TIMESTAMP), CAST('2023-12-31' AS TIMESTAMP), QUARTER) AS q_diff12 + DATEDIFF(CAST('2023-04-15' AS DATE), CAST('2023-01-15' AS DATE), QUARTER) AS q_diff1, + DATEDIFF(CAST('2023-07-15' AS DATE), CAST('2023-01-15' AS DATE), QUARTER) AS q_diff2, + DATEDIFF(CAST('2023-10-15' AS DATE), CAST('2023-01-15' AS DATE), QUARTER) AS q_diff3, + DATEDIFF(CAST('2023-12-31' AS DATE), CAST('2023-01-15' AS DATE), QUARTER) AS q_diff4, + DATEDIFF(CAST('2024-01-15' AS DATE), CAST('2023-01-15' AS DATE), QUARTER) AS q_diff5, + DATEDIFF(CAST('2024-04-15' AS DATE), CAST('2023-01-15' AS DATE), QUARTER) AS q_diff6, + DATEDIFF(CAST('2024-04-15' AS DATE), CAST('2022-10-15' AS DATE), QUARTER) AS q_diff7, + DATEDIFF(CAST('2025-01-01' AS DATE), CAST('2020-01-01' AS DATE), QUARTER) AS q_diff8, + DATEDIFF(CAST('2023-01-15' AS DATE), CAST('2023-04-15' AS DATE), QUARTER) AS q_diff9, + DATEDIFF(CAST('2023-01-15' AS DATE), CAST('2024-01-15' AS DATE), QUARTER) AS q_diff10, + DATEDIFF(CAST('2023-04-01' AS DATE), CAST('2023-03-31' AS DATE), QUARTER) AS q_diff11, + DATEDIFF(CAST('2024-01-01' AS DATE), CAST('2023-12-31' AS DATE), QUARTER) AS q_diff12 FROM (VALUES (NULL)) AS _q_0(_col_0) diff --git a/tests/test_sql_refsols/quarter_function_test_mysql.sql b/tests/test_sql_refsols/quarter_function_test_mysql.sql index 30d1950e3..d9aa8e3d5 100644 --- a/tests/test_sql_refsols/quarter_function_test_mysql.sql +++ b/tests/test_sql_refsols/quarter_function_test_mysql.sql @@ -43,64 +43,64 @@ SELECT CAST('2024-08-15' AS DATE) AS syntax3, CAST('2022-08-15' AS DATE) AS syntax4, ( - YEAR(CAST('2023-04-15' AS DATETIME)) - YEAR(CAST('2023-01-15' AS DATETIME)) + YEAR(CAST('2023-04-15' AS DATE)) - YEAR(CAST('2023-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-04-15' AS DATETIME)) - QUARTER(CAST('2023-01-15' AS DATETIME)) + QUARTER(CAST('2023-04-15' AS DATE)) - QUARTER(CAST('2023-01-15' AS DATE)) ) AS q_diff1, ( - YEAR(CAST('2023-07-15' AS DATETIME)) - YEAR(CAST('2023-01-15' AS DATETIME)) + YEAR(CAST('2023-07-15' AS DATE)) - YEAR(CAST('2023-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-07-15' AS DATETIME)) - QUARTER(CAST('2023-01-15' AS DATETIME)) + QUARTER(CAST('2023-07-15' AS DATE)) - QUARTER(CAST('2023-01-15' AS DATE)) ) AS q_diff2, ( - YEAR(CAST('2023-10-15' AS DATETIME)) - YEAR(CAST('2023-01-15' AS DATETIME)) + YEAR(CAST('2023-10-15' AS DATE)) - YEAR(CAST('2023-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-10-15' AS DATETIME)) - QUARTER(CAST('2023-01-15' AS DATETIME)) + QUARTER(CAST('2023-10-15' AS DATE)) - QUARTER(CAST('2023-01-15' AS DATE)) ) AS q_diff3, ( - YEAR(CAST('2023-12-31' AS DATETIME)) - YEAR(CAST('2023-01-15' AS DATETIME)) + YEAR(CAST('2023-12-31' AS DATE)) - YEAR(CAST('2023-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-12-31' AS DATETIME)) - QUARTER(CAST('2023-01-15' AS DATETIME)) + QUARTER(CAST('2023-12-31' AS DATE)) - QUARTER(CAST('2023-01-15' AS DATE)) ) AS q_diff4, ( - YEAR(CAST('2024-01-15' AS DATETIME)) - YEAR(CAST('2023-01-15' AS DATETIME)) + YEAR(CAST('2024-01-15' AS DATE)) - YEAR(CAST('2023-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2024-01-15' AS DATETIME)) - QUARTER(CAST('2023-01-15' AS DATETIME)) + QUARTER(CAST('2024-01-15' AS DATE)) - QUARTER(CAST('2023-01-15' AS DATE)) ) AS q_diff5, ( - YEAR(CAST('2024-04-15' AS DATETIME)) - YEAR(CAST('2023-01-15' AS DATETIME)) + YEAR(CAST('2024-04-15' AS DATE)) - YEAR(CAST('2023-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2024-04-15' AS DATETIME)) - QUARTER(CAST('2023-01-15' AS DATETIME)) + QUARTER(CAST('2024-04-15' AS DATE)) - QUARTER(CAST('2023-01-15' AS DATE)) ) AS q_diff6, ( - YEAR(CAST('2024-04-15' AS DATETIME)) - YEAR(CAST('2022-10-15' AS DATETIME)) + YEAR(CAST('2024-04-15' AS DATE)) - YEAR(CAST('2022-10-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2024-04-15' AS DATETIME)) - QUARTER(CAST('2022-10-15' AS DATETIME)) + QUARTER(CAST('2024-04-15' AS DATE)) - QUARTER(CAST('2022-10-15' AS DATE)) ) AS q_diff7, ( - YEAR(CAST('2025-01-01' AS DATETIME)) - YEAR(CAST('2020-01-01' AS DATETIME)) + YEAR(CAST('2025-01-01' AS DATE)) - YEAR(CAST('2020-01-01' AS DATE)) ) * 4 + ( - QUARTER(CAST('2025-01-01' AS DATETIME)) - QUARTER(CAST('2020-01-01' AS DATETIME)) + QUARTER(CAST('2025-01-01' AS DATE)) - QUARTER(CAST('2020-01-01' AS DATE)) ) AS q_diff8, ( - YEAR(CAST('2023-01-15' AS DATETIME)) - YEAR(CAST('2023-04-15' AS DATETIME)) + YEAR(CAST('2023-01-15' AS DATE)) - YEAR(CAST('2023-04-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-01-15' AS DATETIME)) - QUARTER(CAST('2023-04-15' AS DATETIME)) + QUARTER(CAST('2023-01-15' AS DATE)) - QUARTER(CAST('2023-04-15' AS DATE)) ) AS q_diff9, ( - YEAR(CAST('2023-01-15' AS DATETIME)) - YEAR(CAST('2024-01-15' AS DATETIME)) + YEAR(CAST('2023-01-15' AS DATE)) - YEAR(CAST('2024-01-15' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-01-15' AS DATETIME)) - QUARTER(CAST('2024-01-15' AS DATETIME)) + QUARTER(CAST('2023-01-15' AS DATE)) - QUARTER(CAST('2024-01-15' AS DATE)) ) AS q_diff10, ( - YEAR(CAST('2023-04-01' AS DATETIME)) - YEAR(CAST('2023-03-31' AS DATETIME)) + YEAR(CAST('2023-04-01' AS DATE)) - YEAR(CAST('2023-03-31' AS DATE)) ) * 4 + ( - QUARTER(CAST('2023-04-01' AS DATETIME)) - QUARTER(CAST('2023-03-31' AS DATETIME)) + QUARTER(CAST('2023-04-01' AS DATE)) - QUARTER(CAST('2023-03-31' AS DATE)) ) AS q_diff11, ( - YEAR(CAST('2024-01-01' AS DATETIME)) - YEAR(CAST('2023-12-31' AS DATETIME)) + YEAR(CAST('2024-01-01' AS DATE)) - YEAR(CAST('2023-12-31' AS DATE)) ) * 4 + ( - QUARTER(CAST('2024-01-01' AS DATETIME)) - QUARTER(CAST('2023-12-31' AS DATETIME)) + QUARTER(CAST('2024-01-01' AS DATE)) - QUARTER(CAST('2023-12-31' AS DATE)) ) AS q_diff12 FROM (VALUES ROW(NULL)) AS _q_0(_col_0) diff --git a/tests/test_sql_refsols/quarter_function_test_oracle.sql b/tests/test_sql_refsols/quarter_function_test_oracle.sql index 437b7a8f3..ba224a5e3 100644 --- a/tests/test_sql_refsols/quarter_function_test_oracle.sql +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -43,64 +43,112 @@ SELECT TO_DATE('2024-08-15', 'YYYY-MM-DD') AS syntax3, TO_DATE('2022-08-15', 'YYYY-MM-DD') AS syntax4, ( - EXTRACT(YEAR FROM CAST('2023-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-04-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-04-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff1, ( - EXTRACT(YEAR FROM CAST('2023-07-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-07-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-07-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-07-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff2, ( - EXTRACT(YEAR FROM CAST('2023-10-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-10-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-10-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-10-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff3, ( - EXTRACT(YEAR FROM CAST('2023-12-31' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-12-31', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-12-31' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-12-31', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff4, ( - EXTRACT(YEAR FROM CAST('2024-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2024-01-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2024-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff5, ( - EXTRACT(YEAR FROM CAST('2024-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2024-04-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2024-04-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff6, ( - EXTRACT(YEAR FROM CAST('2024-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2022-10-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2024-04-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2022-10-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2022-10-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2024-04-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2022-10-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff7, ( - EXTRACT(YEAR FROM CAST('2025-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2020-01-01' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2025-01-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2020-01-01', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2025-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2020-01-01' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2025-01-01', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2020-01-01', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff8, ( - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-04-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-04-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-04-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-04-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff9, ( - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2024-01-15' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2024-01-15', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2024-01-15' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2024-01-15', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff10, ( - EXTRACT(YEAR FROM CAST('2023-04-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-03-31' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2023-04-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-03-31', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-04-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-03-31' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-04-01', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-03-31', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff11, ( - EXTRACT(YEAR FROM CAST('2024-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-12-31' AS DATE)) + EXTRACT(YEAR FROM TO_DATE('2024-01-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-12-31', 'YYYY-MM-DD')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-12-31' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2024-01-01', 'YYYY-MM-DD')) - 1 + ) / 3) - FLOOR(( + EXTRACT(MONTH FROM TO_DATE('2023-12-31', 'YYYY-MM-DD')) - 1 + ) / 3) ) AS q_diff12 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/quarter_function_test_postgres.sql b/tests/test_sql_refsols/quarter_function_test_postgres.sql index 51131a6bd..5c4c84fff 100644 --- a/tests/test_sql_refsols/quarter_function_test_postgres.sql +++ b/tests/test_sql_refsols/quarter_function_test_postgres.sql @@ -43,64 +43,64 @@ SELECT CAST('2024-08-15' AS DATE) AS syntax3, CAST('2022-08-15' AS DATE) AS syntax4, ( - EXTRACT(YEAR FROM CAST('2023-04-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-04-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff1, ( - EXTRACT(YEAR FROM CAST('2023-07-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-07-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-07-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-07-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff2, ( - EXTRACT(YEAR FROM CAST('2023-10-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-10-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-10-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-10-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff3, ( - EXTRACT(YEAR FROM CAST('2023-12-31' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-12-31' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-12-31' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-12-31' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff4, ( - EXTRACT(YEAR FROM CAST('2024-01-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2024-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-01-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2024-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff5, ( - EXTRACT(YEAR FROM CAST('2024-04-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2024-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-04-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2024-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) ) AS q_diff6, ( - EXTRACT(YEAR FROM CAST('2024-04-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2022-10-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2024-04-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2022-10-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-04-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2022-10-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2024-04-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2022-10-15' AS DATE)) ) AS q_diff7, ( - EXTRACT(YEAR FROM CAST('2025-01-01' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2020-01-01' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2025-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2020-01-01' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2025-01-01' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2020-01-01' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2025-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2020-01-01' AS DATE)) ) AS q_diff8, ( - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-04-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-04-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-04-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-04-15' AS DATE)) ) AS q_diff9, ( - EXTRACT(YEAR FROM CAST('2023-01-15' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2024-01-15' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-01-15' AS DATE)) - EXTRACT(YEAR FROM CAST('2024-01-15' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-01-15' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2024-01-15' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-01-15' AS DATE)) - EXTRACT(QUARTER FROM CAST('2024-01-15' AS DATE)) ) AS q_diff10, ( - EXTRACT(YEAR FROM CAST('2023-04-01' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-03-31' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2023-04-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-03-31' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2023-04-01' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-03-31' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2023-04-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-03-31' AS DATE)) ) AS q_diff11, ( - EXTRACT(YEAR FROM CAST('2024-01-01' AS TIMESTAMP)) - EXTRACT(YEAR FROM CAST('2023-12-31' AS TIMESTAMP)) + EXTRACT(YEAR FROM CAST('2024-01-01' AS DATE)) - EXTRACT(YEAR FROM CAST('2023-12-31' AS DATE)) ) * 4 + ( - EXTRACT(QUARTER FROM CAST('2024-01-01' AS TIMESTAMP)) - EXTRACT(QUARTER FROM CAST('2023-12-31' AS TIMESTAMP)) + EXTRACT(QUARTER FROM CAST('2024-01-01' AS DATE)) - EXTRACT(QUARTER FROM CAST('2023-12-31' AS DATE)) ) AS q_diff12 FROM (VALUES (NULL)) AS _q_0(_col_0) diff --git a/tests/test_sql_refsols/quarter_function_test_snowflake.sql b/tests/test_sql_refsols/quarter_function_test_snowflake.sql index 958f43ddf..8687ca036 100644 --- a/tests/test_sql_refsols/quarter_function_test_snowflake.sql +++ b/tests/test_sql_refsols/quarter_function_test_snowflake.sql @@ -42,17 +42,17 @@ SELECT CAST('2024-02-15' AS DATE) AS syntax2, CAST('2024-08-15' AS DATE) AS syntax3, CAST('2022-08-15' AS DATE) AS syntax4, - DATEDIFF(QUARTER, CAST('2023-01-15' AS TIMESTAMP), CAST('2023-04-15' AS TIMESTAMP)) AS q_diff1, - DATEDIFF(QUARTER, CAST('2023-01-15' AS TIMESTAMP), CAST('2023-07-15' AS TIMESTAMP)) AS q_diff2, - DATEDIFF(QUARTER, CAST('2023-01-15' AS TIMESTAMP), CAST('2023-10-15' AS TIMESTAMP)) AS q_diff3, - DATEDIFF(QUARTER, CAST('2023-01-15' AS TIMESTAMP), CAST('2023-12-31' AS TIMESTAMP)) AS q_diff4, - DATEDIFF(QUARTER, CAST('2023-01-15' AS TIMESTAMP), CAST('2024-01-15' AS TIMESTAMP)) AS q_diff5, - DATEDIFF(QUARTER, CAST('2023-01-15' AS TIMESTAMP), CAST('2024-04-15' AS TIMESTAMP)) AS q_diff6, - DATEDIFF(QUARTER, CAST('2022-10-15' AS TIMESTAMP), CAST('2024-04-15' AS TIMESTAMP)) AS q_diff7, - DATEDIFF(QUARTER, CAST('2020-01-01' AS TIMESTAMP), CAST('2025-01-01' AS TIMESTAMP)) AS q_diff8, - DATEDIFF(QUARTER, CAST('2023-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP)) AS q_diff9, - DATEDIFF(QUARTER, CAST('2024-01-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP)) AS q_diff10, - DATEDIFF(QUARTER, CAST('2023-03-31' AS TIMESTAMP), CAST('2023-04-01' AS TIMESTAMP)) AS q_diff11, - DATEDIFF(QUARTER, CAST('2023-12-31' AS TIMESTAMP), CAST('2024-01-01' AS TIMESTAMP)) AS q_diff12 + DATEDIFF(QUARTER, CAST('2023-01-15' AS DATE), CAST('2023-04-15' AS DATE)) AS q_diff1, + DATEDIFF(QUARTER, CAST('2023-01-15' AS DATE), CAST('2023-07-15' AS DATE)) AS q_diff2, + DATEDIFF(QUARTER, CAST('2023-01-15' AS DATE), CAST('2023-10-15' AS DATE)) AS q_diff3, + DATEDIFF(QUARTER, CAST('2023-01-15' AS DATE), CAST('2023-12-31' AS DATE)) AS q_diff4, + DATEDIFF(QUARTER, CAST('2023-01-15' AS DATE), CAST('2024-01-15' AS DATE)) AS q_diff5, + DATEDIFF(QUARTER, CAST('2023-01-15' AS DATE), CAST('2024-04-15' AS DATE)) AS q_diff6, + DATEDIFF(QUARTER, CAST('2022-10-15' AS DATE), CAST('2024-04-15' AS DATE)) AS q_diff7, + DATEDIFF(QUARTER, CAST('2020-01-01' AS DATE), CAST('2025-01-01' AS DATE)) AS q_diff8, + DATEDIFF(QUARTER, CAST('2023-04-15' AS DATE), CAST('2023-01-15' AS DATE)) AS q_diff9, + DATEDIFF(QUARTER, CAST('2024-01-15' AS DATE), CAST('2023-01-15' AS DATE)) AS q_diff10, + DATEDIFF(QUARTER, CAST('2023-03-31' AS DATE), CAST('2023-04-01' AS DATE)) AS q_diff11, + DATEDIFF(QUARTER, CAST('2023-12-31' AS DATE), CAST('2024-01-01' AS DATE)) AS q_diff12 FROM (VALUES (NULL)) AS _q_0(_col_0) diff --git a/tests/test_sql_refsols/quarter_function_test_sqlite.sql b/tests/test_sql_refsols/quarter_function_test_sqlite.sql index 7b5eccc21..1d5b90721 100644 --- a/tests/test_sql_refsols/quarter_function_test_sqlite.sql +++ b/tests/test_sql_refsols/quarter_function_test_sqlite.sql @@ -43,351 +43,351 @@ SELECT '2024-08-15' AS syntax3, '2022-08-15' AS syntax4, ( - CAST(STRFTIME('%Y', DATETIME('2023-04-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-04-15') AS INTEGER) - CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff1, ( - CAST(STRFTIME('%Y', DATETIME('2023-07-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-07-15') AS INTEGER) - CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-07-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-07-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff2, ( - CAST(STRFTIME('%Y', DATETIME('2023-10-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-10-15') AS INTEGER) - CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-10-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-10-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff3, ( - CAST(STRFTIME('%Y', DATETIME('2023-12-31')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-12-31') AS INTEGER) - CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff4, ( - CAST(STRFTIME('%Y', DATETIME('2024-01-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2024-01-15') AS INTEGER) - CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff5, ( - CAST(STRFTIME('%Y', DATETIME('2024-04-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2024-04-15') AS INTEGER) - CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff6, ( - CAST(STRFTIME('%Y', DATETIME('2024-04-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2022-10-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2024-04-15') AS INTEGER) - CAST(STRFTIME('%Y', '2022-10-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2024-04-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2024-04-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2022-10-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2022-10-15') AS INTEGER) >= 10 THEN 4 END AS q_diff7, ( - CAST(STRFTIME('%Y', DATETIME('2025-01-01')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2020-01-01')) AS INTEGER) + CAST(STRFTIME('%Y', '2025-01-01') AS INTEGER) - CAST(STRFTIME('%Y', '2020-01-01') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2025-01-01')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2025-01-01') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2020-01-01')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2020-01-01') AS INTEGER) >= 10 THEN 4 END AS q_diff8, ( - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-04-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) - CAST(STRFTIME('%Y', '2023-04-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-04-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-04-15') AS INTEGER) >= 10 THEN 4 END AS q_diff9, ( - CAST(STRFTIME('%Y', DATETIME('2023-01-15')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2024-01-15')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-01-15') AS INTEGER) - CAST(STRFTIME('%Y', '2024-01-15') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-01-15') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2024-01-15')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2024-01-15') AS INTEGER) >= 10 THEN 4 END AS q_diff10, ( - CAST(STRFTIME('%Y', DATETIME('2023-04-01')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-03-31')) AS INTEGER) + CAST(STRFTIME('%Y', '2023-04-01') AS INTEGER) - CAST(STRFTIME('%Y', '2023-03-31') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-04-01')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-04-01') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-03-31')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-03-31') AS INTEGER) >= 10 THEN 4 END AS q_diff11, ( - CAST(STRFTIME('%Y', DATETIME('2024-01-01')) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('2023-12-31')) AS INTEGER) + CAST(STRFTIME('%Y', '2024-01-01') AS INTEGER) - CAST(STRFTIME('%Y', '2023-12-31') AS INTEGER) ) * 4 + CASE - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2024-01-01')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2024-01-01') AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('2023-12-31')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '2023-12-31') AS INTEGER) >= 10 THEN 4 END AS q_diff12 FROM (VALUES diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_ansi.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_ansi.sql index 61b779964..bb4a42893 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_ansi.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_ansi.sql @@ -8,12 +8,10 @@ WITH _s1 AS ( ) SELECT nation.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC NULLS FIRST, region.r_name NULLS LAST) AS rank + ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC NULLS FIRST, nation.n_name NULLS LAST) AS rank FROM tpch.nation AS nation JOIN _s1 AS _s1 ON _s1.c_nationkey = nation.n_nationkey -JOIN tpch.region AS region - ON nation.n_regionkey = region.r_regionkey ORDER BY 2 LIMIT 5 diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_mysql.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_mysql.sql index d2c6718d3..4e2520426 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_mysql.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_mysql.sql @@ -8,12 +8,10 @@ WITH _s1 AS ( ) SELECT NATION.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CASE WHEN _s1.n_rows IS NULL THEN 1 ELSE 0 END DESC, _s1.n_rows DESC, CASE WHEN REGION.r_name COLLATE utf8mb4_bin IS NULL THEN 1 ELSE 0 END, REGION.r_name COLLATE utf8mb4_bin) AS `rank` + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CASE WHEN _s1.n_rows IS NULL THEN 1 ELSE 0 END DESC, _s1.n_rows DESC, CASE WHEN NATION.n_name COLLATE utf8mb4_bin IS NULL THEN 1 ELSE 0 END, NATION.n_name COLLATE utf8mb4_bin) AS `rank` FROM tpch.NATION AS NATION JOIN _s1 AS _s1 ON NATION.n_nationkey = _s1.c_nationkey -JOIN tpch.REGION AS REGION - ON NATION.n_regionkey = REGION.r_regionkey ORDER BY 2 LIMIT 5 diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql index 4ea752361..c02cb1415 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql @@ -8,12 +8,10 @@ WITH "_S1" AS ( ) SELECT NATION.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY "_S1".N_ROWS DESC, REGION.r_name) AS rank + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY "_S1".N_ROWS DESC, NATION.n_name) AS rank FROM TPCH.NATION NATION JOIN "_S1" "_S1" ON NATION.n_nationkey = "_S1".C_NATIONKEY -JOIN TPCH.REGION REGION - ON NATION.n_regionkey = REGION.r_regionkey ORDER BY 2 NULLS FIRST FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_postgres.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_postgres.sql index 53caedc3c..ba0016791 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_postgres.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_postgres.sql @@ -8,12 +8,10 @@ WITH _s1 AS ( ) SELECT nation.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC, region.r_name) AS rank + ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC, nation.n_name) AS rank FROM tpch.nation AS nation JOIN _s1 AS _s1 ON _s1.c_nationkey = nation.n_nationkey -JOIN tpch.region AS region - ON nation.n_regionkey = region.r_regionkey ORDER BY 2 NULLS FIRST LIMIT 5 diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_snowflake.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_snowflake.sql index 53caedc3c..ba0016791 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_snowflake.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_snowflake.sql @@ -8,12 +8,10 @@ WITH _s1 AS ( ) SELECT nation.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC, region.r_name) AS rank + ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC, nation.n_name) AS rank FROM tpch.nation AS nation JOIN _s1 AS _s1 ON _s1.c_nationkey = nation.n_nationkey -JOIN tpch.region AS region - ON nation.n_regionkey = region.r_regionkey ORDER BY 2 NULLS FIRST LIMIT 5 diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_sqlite.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_sqlite.sql index 8b72f94e3..466748661 100644 --- a/tests/test_sql_refsols/rank_nations_per_region_by_customers_sqlite.sql +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_sqlite.sql @@ -8,12 +8,10 @@ WITH _s1 AS ( ) SELECT nation.n_name AS nation_name, - ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC, region.r_name) AS rank + ROW_NUMBER() OVER (PARTITION BY nation.n_regionkey ORDER BY _s1.n_rows DESC, nation.n_name) AS rank FROM tpch.nation AS nation JOIN _s1 AS _s1 ON _s1.c_nationkey = nation.n_nationkey -JOIN tpch.region AS region - ON nation.n_regionkey = region.r_regionkey ORDER BY 2 LIMIT 5 diff --git a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql index 8c7859488..bb3b363f4 100644 --- a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql +++ b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql @@ -1,10 +1,10 @@ SELECT 1 AS i1, - CAST(2.2 AS INT) AS i2, - CAST('3' AS INT) AS i3, - CAST('4.3' AS INT) AS i4, - CAST('-5.888' AS INT) AS i5, - CAST(-6.0 AS INT) AS i6, + TRUNC(2.2, '0') AS i2, + TRUNC(CAST('3' AS DOUBLE PRECISION), '0') AS i3, + TRUNC(CAST('4.3' AS DOUBLE PRECISION), '0') AS i4, + TRUNC(CAST('-5.888' AS DOUBLE PRECISION), '0') AS i5, + TRUNC(-6.0, '0') AS i6, 1.0 AS f1, 2.2 AS f2, CAST('3' AS DOUBLE PRECISION) AS f3, diff --git a/tests/test_sql_refsols/simple_range_6_oracle.sql b/tests/test_sql_refsols/simple_range_6_oracle.sql index b41f17b81..1bc801a2c 100644 --- a/tests/test_sql_refsols/simple_range_6_oracle.sql +++ b/tests/test_sql_refsols/simple_range_6_oracle.sql @@ -1,5 +1,5 @@ SELECT - CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS INT) AS first_digit, + TRUNC(CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS DOUBLE PRECISION), '0') AS first_digit, COUNT(*) AS n FROM (VALUES (0), @@ -42,4 +42,4 @@ FROM (VALUES (481), (494)) AS TBL(V) GROUP BY - CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS INT) + TRUNC(CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS DOUBLE PRECISION), '0') diff --git a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql index e0841feef..7f73c9188 100644 --- a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql +++ b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql @@ -10,7 +10,7 @@ SELECT TO_DATE('2024-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), TO_DATE('2023-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ) AS s7, - LEAST('', 'alphabet soup', 'Hello World') AS s8, + LEAST(NVL(NULL, CHR(0)), 'alphabet soup', 'Hello World') AS s8, NULL AS s9, GREATEST(20, 10) AS l1, GREATEST(20, 20) AS l2, @@ -23,7 +23,7 @@ SELECT TO_DATE('2024-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'), TO_DATE('2023-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ) AS l7, - GREATEST('', 'alphabet soup', 'Hello World') AS l8, + GREATEST(NVL(NULL, CHR(0)), 'alphabet soup', 'Hello World') AS l8, NULL AS l9 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/simple_var_std_oracle.sql b/tests/test_sql_refsols/simple_var_std_oracle.sql index a188907b7..f5a6ebd85 100644 --- a/tests/test_sql_refsols/simple_var_std_oracle.sql +++ b/tests/test_sql_refsols/simple_var_std_oracle.sql @@ -1,10 +1,18 @@ SELECT ANY_VALUE(NATION.n_name) AS name, - VARIANCE_POP(SUPPLIER.s_acctbal) AS var, + VAR_POP(SUPPLIER.s_acctbal) AS var, STDDEV_POP(SUPPLIER.s_acctbal) AS std, - VARIANCE(SUPPLIER.s_acctbal) AS sample_var, - STDDEV(SUPPLIER.s_acctbal) AS sample_std, - VARIANCE_POP(SUPPLIER.s_acctbal) AS pop_var, + CASE + WHEN COUNT(SUPPLIER.s_acctbal) < 2 + THEN NULL + ELSE VARIANCE(SUPPLIER.s_acctbal) + END AS sample_var, + CASE + WHEN COUNT(SUPPLIER.s_acctbal) < 2 + THEN NULL + ELSE STDDEV(SUPPLIER.s_acctbal) + END AS sample_std, + VAR_POP(SUPPLIER.s_acctbal) AS pop_var, STDDEV_POP(SUPPLIER.s_acctbal) AS pop_std FROM TPCH.NATION NATION JOIN TPCH.SUPPLIER SUPPLIER diff --git a/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql index d8ee22aff..315959fff 100644 --- a/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql +++ b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql @@ -1,13 +1,37 @@ SELECT - VARIANCE(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_samp_0_nnull, - VARIANCE(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_samp_1_nnull, - VARIANCE(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_samp_2_nnull, - VARIANCE_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_pop_0_nnull, - VARIANCE_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_pop_1_nnull, - VARIANCE_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_pop_2_nnull, - STDDEV(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS std_samp_0_nnull, - STDDEV(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS std_samp_1_nnull, - STDDEV(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS std_samp_2_nnull, + CASE + WHEN COUNT(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) < 2 + THEN NULL + ELSE VARIANCE(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) + END AS var_samp_0_nnull, + CASE + WHEN COUNT(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) < 2 + THEN NULL + ELSE VARIANCE(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) + END AS var_samp_1_nnull, + CASE + WHEN COUNT(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) < 2 + THEN NULL + ELSE VARIANCE(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) + END AS var_samp_2_nnull, + VAR_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_pop_0_nnull, + VAR_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_pop_1_nnull, + VAR_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_pop_2_nnull, + CASE + WHEN COUNT(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) < 2 + THEN NULL + ELSE STDDEV(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) + END AS std_samp_0_nnull, + CASE + WHEN COUNT(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) < 2 + THEN NULL + ELSE STDDEV(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) + END AS std_samp_1_nnull, + CASE + WHEN COUNT(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) < 2 + THEN NULL + ELSE STDDEV(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) + END AS std_samp_2_nnull, STDDEV_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS std_pop_0_nnull, STDDEV_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS std_pop_1_nnull, STDDEV_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS std_pop_2_nnull diff --git a/tests/test_sql_refsols/simplification_3_oracle.sql b/tests/test_sql_refsols/simplification_3_oracle.sql index c48b4fe0e..3da3a6bb4 100644 --- a/tests/test_sql_refsols/simplification_3_oracle.sql +++ b/tests/test_sql_refsols/simplification_3_oracle.sql @@ -1,15 +1,19 @@ WITH "_T2" AS ( SELECT - ABS(CAST(sbcustpostalcode AS INT)) AS EXPR_13, + ABS(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0')) AS EXPR_13, ROW_NUMBER() OVER (ORDER BY sbcustname) AS RANK, - AVG(CAST(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER () AS RAVG1, + AVG( + CAST(ABS(COALESCE(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0'), 0)) AS DOUBLE PRECISION) + ) OVER () AS RAVG1, COALESCE( - AVG(CAST(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), + AVG( + CAST(ABS(COALESCE(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0'), 0)) AS DOUBLE PRECISION) + ) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), 0.1 ) AS RAVG2, - COUNT(CAST(sbcustpostalcode AS INT)) OVER () AS RCNT1, + COUNT(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0')) OVER () AS RCNT1, COALESCE( - COUNT(CAST(sbcustpostalcode AS INT)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + COUNT(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0')) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0.1 ) AS RCNT2, COUNT(*) OVER () AS RSIZ1, @@ -17,9 +21,9 @@ WITH "_T2" AS ( COUNT(*) OVER (ORDER BY sbcustname ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING), 0.1 ) AS RSIZ2, - SUM(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0))) OVER () AS RSUM1, + SUM(ABS(COALESCE(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0'), 0))) OVER () AS RSUM1, COALESCE( - SUM(ABS(COALESCE(CAST(sbcustpostalcode AS INT), 0))) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + SUM(ABS(COALESCE(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0'), 0))) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), 0.1 ) AS RSUM2 FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql index 57f58fcd6..d5f7d3c97 100644 --- a/tests/test_sql_refsols/simplification_4_oracle.sql +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -9,7 +9,12 @@ WITH "_T" AS ( ) SELECT SBTXDATETIME AS date_time, - TRUNC(CAST(CAST(SBTXDATETIME AS DATE) AS DATE), 'IW') - NUMTODSINTERVAL(56, 'DAY') AS s00, + TRUNC( + CAST(CAST(SBTXDATETIME AS DATE) - MOD(( + TO_CHAR(CAST(SBTXDATETIME AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) - NUMTODSINTERVAL(56, 'DAY') AS s00, FALSE AS s01, EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (1, 2, 3) AS s02, EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATE)) IN (4, 5, 6) AS s03, diff --git a/tests/test_sql_refsols/smoke_a_oracle.sql b/tests/test_sql_refsols/smoke_a_oracle.sql index c561ea955..e6450edfe 100644 --- a/tests/test_sql_refsols/smoke_a_oracle.sql +++ b/tests/test_sql_refsols/smoke_a_oracle.sql @@ -1,11 +1,7 @@ SELECT p_partkey AS key, - CAST(LTRIM( - NVL2( - SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), - '' || SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), - NULL - ) || NVL2(SUBSTR(p_brand, 8), '' || SUBSTR(p_brand, 8), NULL) || NVL2( + TRUNC( + CAST(NVL(SUBSTR(p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END), '') || '' || NVL(SUBSTR(p_brand, 8), '') || '' || NVL( SUBSTR( p_brand, CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END, @@ -15,26 +11,66 @@ SELECT ELSE GREATEST(1, 0) END ), - '' || SUBSTR( - p_brand, - CASE WHEN ABS(-2) < LENGTH(p_brand) THEN -2 ELSE 1 END, - CASE - WHEN ABS(-2) > LENGTH(p_brand) - THEN LENGTH(p_brand) + -1 - ELSE GREATEST(1, 0) - END - ), - NULL - ), - '' - ) AS INT) AS a, + '' + ) AS DOUBLE PRECISION), + '0' + ) AS a, UPPER( LEAST( - REGEXP_SUBSTR(p_name, '[^ ]+', 1, 2), - REGEXP_SUBSTR(p_name, '[^ ]+', 1, REGEXP_COUNT(p_name, ' ') + 1) + NVL( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 1 + THEN 2 + ELSE NULL + END, + NULL, + 1 + ), + CHR(0) + ), + NVL( + REGEXP_SUBSTR( + p_name, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) + 1 >= ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) + 1 + AND ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) >= 0 + THEN ( + ( + LENGTH(p_name) - LENGTH(REPLACE(p_name, ' ')) + ) / LENGTH(' ') + ) + 1 + ELSE NULL + END, + NULL, + 1 + ), + CHR(0) + ) ) ) AS b, - TRIM('o' FROM SUBSTR(p_name, 1, 2)) AS c, + RTRIM(LTRIM(SUBSTR(p_name, 1, 2), 'o'), 'o') AS c, CASE WHEN LENGTH(CAST(p_size AS VARCHAR2(4000))) >= 3 THEN SUBSTR(CAST(p_size AS VARCHAR2(4000)), 1, 3) @@ -44,13 +80,15 @@ SELECT REPLACE(p_mfgr, 'Manufacturer#', 'm') AS f, REPLACE(LOWER(p_container), ' ', '') AS g, CASE - WHEN LENGTH('o') = 0 + WHEN LENGTH('o') IS NULL OR LENGTH(p_name) IS NULL THEN 0 ELSE CAST(( - LENGTH(p_name) - LENGTH(REPLACE(p_name, 'o', '')) + LENGTH(p_name) - NVL(LENGTH(REPLACE(p_name, 'o', '')), 0) ) / LENGTH('o') AS INT) END + ( - INSTR(p_name, 'o') / 100.0 + ( + INSTR(p_name, 'o') - 1 + ) / 100.0 ) AS h, ROUND(POWER(GREATEST(p_size, 10), 0.5), 3) AS i FROM TPCH.PART diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql index 9e072b6cf..378b58d1b 100644 --- a/tests/test_sql_refsols/smoke_b_oracle.sql +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -1,99 +1,63 @@ SELECT o_orderkey AS key, - LTRIM( - NVL2( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)), - '_' || EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)), - NULL - ) || NVL2( - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)), - '_' || EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)), - NULL - ) || NVL2( - EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), - '_' || EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), - NULL - ) || NVL2( - EXTRACT(DAY FROM CAST(o_orderdate AS DATE)), - '_' || EXTRACT(DAY FROM CAST(o_orderdate AS DATE)), - NULL - ), - '_' - ) AS a, - LTRIM( - NVL2( - CASE - WHEN TO_CHAR(o_orderdate, 'D') = 1 - THEN 'Sunday' - WHEN TO_CHAR(o_orderdate, 'D') = 2 - THEN 'Monday' - WHEN TO_CHAR(o_orderdate, 'D') = 3 - THEN 'Tuesday' - WHEN TO_CHAR(o_orderdate, 'D') = 4 - THEN 'Wednesday' - WHEN TO_CHAR(o_orderdate, 'D') = 5 - THEN 'Thursday' - WHEN TO_CHAR(o_orderdate, 'D') = 6 - THEN 'Friday' - WHEN TO_CHAR(o_orderdate, 'D') = 7 - THEN 'Saturday' - END, - ':' || CASE - WHEN TO_CHAR(o_orderdate, 'D') = 1 - THEN 'Sunday' - WHEN TO_CHAR(o_orderdate, 'D') = 2 - THEN 'Monday' - WHEN TO_CHAR(o_orderdate, 'D') = 3 - THEN 'Tuesday' - WHEN TO_CHAR(o_orderdate, 'D') = 4 - THEN 'Wednesday' - WHEN TO_CHAR(o_orderdate, 'D') = 5 - THEN 'Thursday' - WHEN TO_CHAR(o_orderdate, 'D') = 6 - THEN 'Friday' - WHEN TO_CHAR(o_orderdate, 'D') = 7 - THEN 'Saturday' - END, - NULL - ) || NVL2( - ( - MOD(( - TO_CHAR(o_orderdate, 'D') + -1 - ), 7) - ), - ':' || MOD(( - TO_CHAR(o_orderdate, 'D') + -1 - ), 7), - NULL - ), - ':' - ) AS b, + NVL(EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)), '') || '_' || NVL(FLOOR(( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - 1 + ) / 3) + 1, '') || '_' || NVL(EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), '') || '_' || NVL(EXTRACT(DAY FROM CAST(o_orderdate AS DATE)), '') AS a, + NVL( + CASE + WHEN TO_CHAR(o_orderdate, 'D') = 1 + THEN 'Sunday' + WHEN TO_CHAR(o_orderdate, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(o_orderdate, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(o_orderdate, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(o_orderdate, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(o_orderdate, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(o_orderdate, 'D') = 7 + THEN 'Saturday' + END, + '' + ) || ':' || NVL(( + MOD(( + TO_CHAR(o_orderdate, 'D') + -1 + ), 7) + ), '') AS b, ADD_MONTHS(TRUNC(CAST(o_orderdate AS DATE), 'YEAR'), 6) - NUMTODSINTERVAL(13, 'day') AS c, ADD_MONTHS(TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'Q'), 12) + NUMTODSINTERVAL(25, 'hour') AS d, TO_DATE('2025-01-01 12:35:00', 'YYYY-MM-DD HH24:MI:SS') AS e, TO_DATE('2025-07-22 12:00:00', 'YYYY-MM-DD HH24:MI:SS') AS f, TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, - LTRIM( - NVL2(12, ';' || 12, NULL) || NVL2(20, ';' || 20, NULL) || NVL2(6, ';' || 6, NULL), - ';' - ) AS h, - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1993-05-25 12:45:36' AS DATE)) AS i, + 12 || ';' || 20 || ';' || 6 AS h, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) AS i, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1993-05-25 12:45:36' AS DATE)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) ) * 4 + ( - EXTRACT(QUARTER FROM CAST(o_orderdate AS DATE)) - EXTRACT(QUARTER FROM CAST('1993-05-25 12:45:36' AS DATE)) + FLOOR(( + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - 1 + ) / 3) - FLOOR( + ( + EXTRACT(MONTH FROM TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) - 1 + ) / 3 + ) ) AS j, ( - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM CAST('1993-05-25 12:45:36' AS DATE)) + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) - EXTRACT(YEAR FROM TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) ) * 12 + ( - EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM CAST('1993-05-25 12:45:36' AS DATE)) + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)) - EXTRACT(MONTH FROM TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) ) AS k, FLOOR( ( - CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) + ( - MOD(( - TO_CHAR(CAST('1993-05-25 12:45:36' AS DATE), 'D') + -1 - ), 7) + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'DD') + ( + MOD( + ( + TO_CHAR(TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS'), 'D') + -1 + ), + 7 + ) ) - ( MOD(( TO_CHAR(CAST(o_orderdate AS DATE), 'D') + -1 @@ -101,17 +65,22 @@ SELECT ) ) / 7 ) AS l, - CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) AS m, + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'DD') - TRUNC(CAST(TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'DD') AS m, ( - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'HH24') - TRUNC(CAST(CAST('1993-05-25 12:45:36' AS DATE) AS DATE), 'HH24') + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'HH24') - TRUNC(CAST(TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'HH24') ) * 24 AS n, ( - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'MI') - TRUNC(CAST(CAST('1993-05-25 12:45:36' AS DATE) AS DATE), 'MI') + TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'MI') - TRUNC(CAST(TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS') AS DATE), 'MI') ) * 1440 AS o, ( - CAST(o_orderdate AS DATE) - CAST('1993-05-25 12:45:36' AS DATE) + CAST(o_orderdate AS DATE) - TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS') ) * 86400 AS p, - TRUNC(CAST(CAST(o_orderdate AS DATE) AS DATE), 'IW') AS q + TRUNC( + CAST(CAST(o_orderdate AS DATE) - MOD(( + TO_CHAR(CAST(o_orderdate AS DATE), 'D') + -1 + ), 7) AS DATE), + 'DD' + ) AS q FROM TPCH.ORDERS WHERE o_clerk LIKE '%5' AND o_comment LIKE '%fo%' AND o_orderpriority LIKE '3%' diff --git a/tests/test_sql_refsols/smoke_b_sqlite.sql b/tests/test_sql_refsols/smoke_b_sqlite.sql index a56aa99c8..bcabb21a4 100644 --- a/tests/test_sql_refsols/smoke_b_sqlite.sql +++ b/tests/test_sql_refsols/smoke_b_sqlite.sql @@ -58,9 +58,9 @@ SELECT '2025-07-22 12:00:00' AS f, '2025-01-01' AS g, CONCAT_WS(';', 12, 20, 6) AS h, - CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('1993-05-25 12:45:36')) AS INTEGER) AS i, + CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', '1993-05-25 12:45:36') AS INTEGER) AS i, ( - CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('1993-05-25 12:45:36')) AS INTEGER) + CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', '1993-05-25 12:45:36') AS INTEGER) ) * 4 + CASE WHEN CAST(STRFTIME('%m', o_orderdate) AS INTEGER) <= 3 AND CAST(STRFTIME('%m', o_orderdate) AS INTEGER) >= 1 @@ -75,22 +75,22 @@ SELECT AND CAST(STRFTIME('%m', o_orderdate) AS INTEGER) >= 10 THEN 4 END - CASE - WHEN CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) <= 3 - AND CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) >= 1 + WHEN CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) <= 3 + AND CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) >= 1 THEN 1 - WHEN CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) <= 6 - AND CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) >= 4 + WHEN CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) <= 6 + AND CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) >= 4 THEN 2 - WHEN CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) <= 9 - AND CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) >= 7 + WHEN CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) <= 9 + AND CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) >= 7 THEN 3 - WHEN CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) <= 12 - AND CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) >= 10 + WHEN CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) <= 12 + AND CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) >= 10 THEN 4 END AS j, ( - CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME('1993-05-25 12:45:36')) AS INTEGER) - ) * 12 + CAST(STRFTIME('%m', o_orderdate) AS INTEGER) - CAST(STRFTIME('%m', DATETIME('1993-05-25 12:45:36')) AS INTEGER) AS k, + CAST(STRFTIME('%Y', o_orderdate) AS INTEGER) - CAST(STRFTIME('%Y', '1993-05-25 12:45:36') AS INTEGER) + ) * 12 + CAST(STRFTIME('%m', o_orderdate) AS INTEGER) - CAST(STRFTIME('%m', '1993-05-25 12:45:36') AS INTEGER) AS k, CAST(CAST(CAST(( JULIANDAY( DATE( @@ -100,30 +100,30 @@ SELECT ) ) - JULIANDAY( DATE( - DATETIME('1993-05-25 12:45:36'), - '-' || CAST(CAST(STRFTIME('%w', DATETIME(DATETIME('1993-05-25 12:45:36'))) AS INTEGER) AS TEXT) || ' days', + '1993-05-25 12:45:36', + '-' || CAST(CAST(STRFTIME('%w', DATETIME('1993-05-25 12:45:36')) AS INTEGER) AS TEXT) || ' days', 'start of day' ) ) ) AS INTEGER) AS REAL) / 7 AS INTEGER) AS l, CAST(( - JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE(DATETIME('1993-05-25 12:45:36'), 'start of day')) + JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE('1993-05-25 12:45:36', 'start of day')) ) AS INTEGER) AS m, CAST(( - JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE(DATETIME('1993-05-25 12:45:36'), 'start of day')) - ) AS INTEGER) * 24 + CAST(STRFTIME('%H', o_orderdate) AS INTEGER) - CAST(STRFTIME('%H', DATETIME('1993-05-25 12:45:36')) AS INTEGER) AS n, + JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE('1993-05-25 12:45:36', 'start of day')) + ) AS INTEGER) * 24 + CAST(STRFTIME('%H', o_orderdate) AS INTEGER) - CAST(STRFTIME('%H', '1993-05-25 12:45:36') AS INTEGER) AS n, ( CAST(( - JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE(DATETIME('1993-05-25 12:45:36'), 'start of day')) - ) AS INTEGER) * 24 + CAST(STRFTIME('%H', o_orderdate) AS INTEGER) - CAST(STRFTIME('%H', DATETIME('1993-05-25 12:45:36')) AS INTEGER) - ) * 60 + CAST(STRFTIME('%M', o_orderdate) AS INTEGER) - CAST(STRFTIME('%M', DATETIME('1993-05-25 12:45:36')) AS INTEGER) AS o, + JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE('1993-05-25 12:45:36', 'start of day')) + ) AS INTEGER) * 24 + CAST(STRFTIME('%H', o_orderdate) AS INTEGER) - CAST(STRFTIME('%H', '1993-05-25 12:45:36') AS INTEGER) + ) * 60 + CAST(STRFTIME('%M', o_orderdate) AS INTEGER) - CAST(STRFTIME('%M', '1993-05-25 12:45:36') AS INTEGER) AS o, ( ( CAST(( - JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE(DATETIME('1993-05-25 12:45:36'), 'start of day')) - ) AS INTEGER) * 24 + CAST(STRFTIME('%H', o_orderdate) AS INTEGER) - CAST(STRFTIME('%H', DATETIME('1993-05-25 12:45:36')) AS INTEGER) - ) * 60 + CAST(STRFTIME('%M', o_orderdate) AS INTEGER) - CAST(STRFTIME('%M', DATETIME('1993-05-25 12:45:36')) AS INTEGER) - ) * 60 + CAST(STRFTIME('%S', o_orderdate) AS INTEGER) - CAST(STRFTIME('%S', DATETIME('1993-05-25 12:45:36')) AS INTEGER) AS p, + JULIANDAY(DATE(o_orderdate, 'start of day')) - JULIANDAY(DATE('1993-05-25 12:45:36', 'start of day')) + ) AS INTEGER) * 24 + CAST(STRFTIME('%H', o_orderdate) AS INTEGER) - CAST(STRFTIME('%H', '1993-05-25 12:45:36') AS INTEGER) + ) * 60 + CAST(STRFTIME('%M', o_orderdate) AS INTEGER) - CAST(STRFTIME('%M', '1993-05-25 12:45:36') AS INTEGER) + ) * 60 + CAST(STRFTIME('%S', o_orderdate) AS INTEGER) - CAST(STRFTIME('%S', '1993-05-25 12:45:36') AS INTEGER) AS p, DATE( o_orderdate, '-' || CAST(CAST(STRFTIME('%w', DATETIME(o_orderdate)) AS INTEGER) AS TEXT) || ' days', diff --git a/tests/test_sql_refsols/smoke_c_oracle.sql b/tests/test_sql_refsols/smoke_c_oracle.sql index 7cd5610d8..421ef44ff 100644 --- a/tests/test_sql_refsols/smoke_c_oracle.sql +++ b/tests/test_sql_refsols/smoke_c_oracle.sql @@ -33,10 +33,24 @@ SELECT MAX(C_ACCTBAL) AS g, ANY_VALUE(SUBSTR(C_NAME, 1, 1)) AS h, COUNT(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END) AS i, - CEIL(VARIANCE_POP(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END)) AS j, - ROUND(VARIANCE(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END), 4) AS k, + CEIL(VAR_POP(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END)) AS j, + ROUND( + CASE + WHEN COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) < 2 + THEN NULL + ELSE VARIANCE(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) + END, + 4 + ) AS k, FLOOR(STDDEV_POP(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END)) AS l, - ROUND(STDDEV(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END), 4) AS m, + ROUND( + CASE + WHEN COUNT(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END) < 2 + THEN NULL + ELSE STDDEV(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END) + END, + 4 + ) AS m, ROUND(AVG(COALESCE(CASE WHEN C_ACCTBAL > 0 THEN C_ACCTBAL ELSE NULL END, 0)), 2) AS n, SUM(NOT CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS o, SUM(CASE WHEN C_ACCTBAL > 1000 THEN C_ACCTBAL ELSE NULL END IS NULL) AS p, diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql index 0eb9299c0..8eeca96d1 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 1 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql index 7e1dae063..a38426a61 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 1 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql index 41db613e1..f3c95a383 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql index ada3d17f0..3c96ada60 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql index bbb4e34d4..fa14f366d 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 0 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql index acac57829..4d9044590 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 0 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql index 17bd59ad5..dc0d15ecf 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + -1 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql index 8e8995616..cdee8eab9 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + -1 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql index baa49f02a..5c4286e28 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 2 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql index f1b4a7a1b..96fff6197 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 2 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql index f572c456b..4cfd9c09a 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 4 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql index 43a4bab80..6c9d16123 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 4 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql index 2b43e5447..f92743508 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 3 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql index 214e9cd69..9149b4532 100644 --- a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql @@ -1,6 +1,11 @@ SELECT sbtxdatetime AS date_time, - TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'IW') AS sow, + TRUNC( + CAST(CAST(sbtxdatetime AS DATE) - MOD(( + TO_CHAR(CAST(sbtxdatetime AS DATE), 'D') + 3 + ), 7) AS DATE), + 'DD' + ) AS sow, CASE WHEN TO_CHAR(sbtxdatetime, 'D') = 1 THEN 'Sunday' diff --git a/tests/test_sql_refsols/string_format_specifiers_oracle.sql b/tests/test_sql_refsols/string_format_specifiers_oracle.sql index cb5c13d68..d924b9f85 100644 --- a/tests/test_sql_refsols/string_format_specifiers_oracle.sql +++ b/tests/test_sql_refsols/string_format_specifiers_oracle.sql @@ -1,18 +1,23 @@ SELECT TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'YYYY') AS d1, TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'YY') AS d2, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MM') AS d3, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'Mon') AS d4, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MMMM') AS d5, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DD') AS d6, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DY') AS d7, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DYDY') AS d8, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'HH24') AS d9, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'HH12') AS d10, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MI') AS d11, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'SS') AS d12, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'P.M.') AS d13, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), '.FF') AS d14, - TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'TZH:TZM') AS d15 + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'RR') AS d3, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MM') AS d4, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MON') AS d5, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MONTH') AS d6, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'Q') AS d7, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DD') AS d8, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DDD') AS d9, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'D') AS d10, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DY') AS d11, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'DAY') AS d12, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'W') AS d13, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'WW') AS d14, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'IW') AS d15, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'HH24') AS d16, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'HH12') AS d17, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'MI') AS d18, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'SS') AS d19, + TO_CHAR(TO_DATE('2023-07-15 14:30:45', 'YYYY-MM-DD HH24:MI:SS'), 'P.M.') AS d20 FROM (VALUES (NULL)) AS "_Q_0"("_COL_0") diff --git a/tests/test_sql_refsols/string_functions_oracle.sql b/tests/test_sql_refsols/string_functions_oracle.sql index 97366cb90..7fb1d2d52 100644 --- a/tests/test_sql_refsols/string_functions_oracle.sql +++ b/tests/test_sql_refsols/string_functions_oracle.sql @@ -6,28 +6,27 @@ SELECT CUSTOMER.c_name LIKE '%z' AS ends_with_z, CUSTOMER.c_name LIKE '%sub%' AS contains_sub, CUSTOMER.c_name LIKE '%test%' AS matches_like, - LTRIM( - NVL2(CUSTOMER.c_name, '::' || CUSTOMER.c_name, NULL) || NVL2(NATION.n_name, '::' || NATION.n_name, NULL), - '::' - ) AS joined_string, + NVL(CUSTOMER.c_name, '') || '::' || NVL(NATION.n_name, '') AS joined_string, CASE WHEN LENGTH(CUSTOMER.c_name) >= 20 THEN SUBSTR(CUSTOMER.c_name, 1, 20) ELSE SUBSTR(CONCAT('********************', CUSTOMER.c_name), -20) END AS lpad_name, SUBSTR(CONCAT(CUSTOMER.c_name, '--------------------'), 1, 20) AS rpad_name, - TRIM(CUSTOMER.c_name) AS stripped, - TRIM('aeiou' FROM CUSTOMER.c_name) AS stripped_vowels, + RTRIM(LTRIM(CUSTOMER.c_name, ' + '), ' + ') AS stripped, + RTRIM(LTRIM(CUSTOMER.c_name, 'aeiou'), 'aeiou') AS stripped_vowels, REPLACE(CUSTOMER.c_name, 'Corp', 'Inc') AS replaced_name, REPLACE(CUSTOMER.c_name, 'Ltd', '') AS removed_substr, CASE - WHEN LENGTH('e') = 0 + WHEN LENGTH('e') IS NULL OR LENGTH(CUSTOMER.c_name) IS NULL THEN 0 ELSE CAST(( - LENGTH(CUSTOMER.c_name) - LENGTH(REPLACE(CUSTOMER.c_name, 'e', '')) + LENGTH(CUSTOMER.c_name) - NVL(LENGTH(REPLACE(CUSTOMER.c_name, 'e', '')), 0) ) / LENGTH('e') AS INT) END AS count_e, - INSTR(CUSTOMER.c_name, 'Alex') AS idx_Alex + INSTR(CUSTOMER.c_name, 'Alex') - 1 AS idx_Alex FROM TPCH.CUSTOMER CUSTOMER JOIN TPCH.NATION NATION ON CUSTOMER.c_nationkey = NATION.n_nationkey diff --git a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql index 0f56df6c4..40c14ff5d 100644 --- a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql +++ b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql @@ -8,7 +8,7 @@ JOIN MAIN.CALENDAR CALENDAR_2 CAST(CALENDAR.ca_dt AS DATE) + NUMTODSINTERVAL(5, 'day') ) JOIN MAIN.DEVICES DEVICES - ON CALENDAR_2.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + ON CALENDAR_2.ca_dt = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') WHERE EXTRACT(YEAR FROM CAST(CALENDAR.ca_dt AS DATE)) = 2024 GROUP BY diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql index 1f3c0bd39..76e32ed07 100644 --- a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -19,7 +19,7 @@ WITH "_T2" AS ( JOIN MAIN.CALENDAR CALENDAR ON CALENDAR.ca_dt >= ADD_MONTHS(CAST("_T4".CA_DT AS DATE), -6) JOIN MAIN.DEVICES DEVICES - ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + ON CALENDAR.ca_dt = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') JOIN "_T5" "_T5" ON DEVICES.de_production_country_id = "_T5".CO_ID GROUP BY @@ -30,7 +30,7 @@ WITH "_T2" AS ( COUNT(*) AS N_ROWS FROM "_T2" "_T7" JOIN MAIN.INCIDENTS INCIDENTS - ON "_T7".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') + ON "_T7".CA_DT = TRUNC(CAST(CAST(INCIDENTS.in_error_report_ts AS DATE) AS DATE), 'DD') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id JOIN "_T5" "_T8" @@ -53,21 +53,13 @@ WITH "_T2" AS ( EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATE)) ) SELECT - LTRIM( - NVL2(YEAR_CA_DT, '-' || YEAR_CA_DT, NULL) || NVL2( - CASE - WHEN LENGTH(MONTH_CA_DT) >= 2 - THEN SUBSTR(MONTH_CA_DT, 1, 2) - ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) - END, - '-' || CASE - WHEN LENGTH(MONTH_CA_DT) >= 2 - THEN SUBSTR(MONTH_CA_DT, 1, 2) - ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) - END, - NULL - ), - '-' + NVL(YEAR_CA_DT, '') || '-' || NVL( + CASE + WHEN LENGTH(MONTH_CA_DT) >= 2 + THEN SUBSTR(MONTH_CA_DT, 1, 2) + ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) + END, + '' ) AS month, ROUND(( 1000000.0 * COALESCE(SUM_N_ROWS, 0) diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql index d4a144ecd..82f42d1c0 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql @@ -21,7 +21,7 @@ WITH "_S14" AS ( COUNT(*) AS N_ROWS FROM "_S6" "_S0" JOIN MAIN.INCIDENTS INCIDENTS - ON "_S0".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') + ON "_S0".CA_DT = TRUNC(CAST(CAST(INCIDENTS.in_error_report_ts AS DATE) AS DATE), 'DD') JOIN MAIN.DEVICES DEVICES ON DEVICES.de_id = INCIDENTS.in_device_id JOIN "_T5" "_T5" @@ -34,7 +34,7 @@ WITH "_S14" AS ( COUNT(*) AS N_ROWS FROM "_S6" "_S8" JOIN MAIN.DEVICES DEVICES - ON "_S8".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + ON "_S8".CA_DT = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') JOIN "_T5" "_T7" ON DEVICES.de_product_id = "_T7".PR_ID GROUP BY diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql index 0ec8fb986..9a9d71be2 100644 --- a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql @@ -8,7 +8,7 @@ WITH "_S2" AS ( COUNT(*) AS N_ROWS FROM "_S2" "_S0" JOIN MAIN.DEVICES DEVICES - ON "_S0".CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS DATE), 'DAY') + ON "_S0".CA_DT = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') GROUP BY "_S0".CA_DT ), "_S7" AS ( @@ -17,7 +17,7 @@ WITH "_S2" AS ( COUNT(*) AS N_ROWS FROM "_S2" "_S4" JOIN MAIN.INCIDENTS INCIDENTS - ON "_S4".CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS DATE), 'DAY') + ON "_S4".CA_DT = TRUNC(CAST(CAST(INCIDENTS.in_error_report_ts AS DATE) AS DATE), 'DD') GROUP BY "_S4".CA_DT ), "_T1" AS ( diff --git a/tests/test_sql_refsols/time_threshold_reached_oracle.sql b/tests/test_sql_refsols/time_threshold_reached_oracle.sql index e5e5f419f..b204f6a36 100644 --- a/tests/test_sql_refsols/time_threshold_reached_oracle.sql +++ b/tests/test_sql_refsols/time_threshold_reached_oracle.sql @@ -2,15 +2,15 @@ WITH "_T3" AS ( SELECT sbtxdatetime AS SBTXDATETIME, ( - 100.0 * SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS DATE), 'DAY') ORDER BY sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) - ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS DATE), 'DAY')) AS PCT_OF_DAY + 100.0 * SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'DD') ORDER BY sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) + ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(CAST(sbtxdatetime AS DATE) AS DATE), 'DD')) AS PCT_OF_DAY FROM MAIN.SBTRANSACTION WHERE EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 ), "_T" AS ( SELECT SBTXDATETIME, - ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS DATE), 'DAY') ORDER BY PCT_OF_DAY) AS "_W" + ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(CAST(SBTXDATETIME AS DATE) AS DATE), 'DD') ORDER BY PCT_OF_DAY) AS "_W" FROM "_T3" WHERE PCT_OF_DAY >= 50.0 diff --git a/tests/testing_utilities.py b/tests/testing_utilities.py index 85c87d05c..446ce0221 100644 --- a/tests/testing_utilities.py +++ b/tests/testing_utilities.py @@ -1407,6 +1407,19 @@ def harmonize_types(column_a, column_b): Returns: A tuple of the two harmonized columns. """ + # String Sanitization: Convert "\x00" to "" and handle None/NaN for strings + # Address issues where CHR(0) vs '' caused a mismatch. + if pd.api.types.is_object_dtype(column_a) or pd.api.types.is_object_dtype(column_b): + + def sanitize_string(val): + if isinstance(val, str): + return val.replace("\x00", "") + return val + + # Apply sanitization to both columns if they are object/string types + column_a = column_a.map(sanitize_string) + column_b = column_b.map(sanitize_string) + # Different integer types if pd.api.types.is_integer_dtype(column_a) and pd.api.types.is_integer_dtype( column_b From fc17d418c1b938202f045a8bcb1d59423126e55e Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Wed, 4 Mar 2026 16:57:45 -0600 Subject: [PATCH 24/48] [run ci] [run dialects] From d15086cb717ad4e119a0cd5cf39687cb9d2cc9bf Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 08:36:22 -0600 Subject: [PATCH 25/48] updating refsol files, test metadata fixed [run ci][run dialects] --- tests/test_metadata.py | 2 +- .../dataframe_collection_datatypes_oracle.sql | 2 + .../defog_dealership_adv13_oracle.sql | 2 + .../defog_dealership_adv8_ansi.sql | 23 +-------- .../defog_dealership_adv8_mysql.sql | 23 +-------- .../defog_dealership_adv8_oracle.sql | 47 +++++++------------ .../defog_dealership_adv8_postgres.sql | 23 +-------- .../defog_dealership_adv8_snowflake.sql | 23 +-------- .../defog_dealership_adv8_sqlite.sql | 23 +-------- tests/test_sql_refsols/smoke_d_oracle.sql | 2 +- 10 files changed, 33 insertions(+), 137 deletions(-) diff --git a/tests/test_metadata.py b/tests/test_metadata.py index ffdda1520..8a6af9fb9 100644 --- a/tests/test_metadata.py +++ b/tests/test_metadata.py @@ -442,7 +442,7 @@ def test_semantic_info(get_sample_graph: graph_fetcher) -> None: id="sample-valid", ), pytest.param( - "keywords_graph.json", + "custom_datasets_graphs.json", "keywords", None, id="keywords-valid", diff --git a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql index cef83a2c8..3d31e1b00 100644 --- a/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql +++ b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql @@ -26,3 +26,5 @@ FROM (VALUES TO_TIMESTAMP('2024-01-02 00:00:00', 'YYYY-MM-DD HH24:MI:SS') ), (NULL, 2, NULL, 7.0, 0, NULL, NULL)) AS ALLDATATYPES(STRING_COL, INT_COL, FLOAT_COL, NULLABLE_INT_COL, BOOL_COL, NULL_COL, DATETIME_COL) +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql index 44c18d2a0..2cc6a7e96 100644 --- a/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql @@ -34,3 +34,5 @@ SELECT SUM_PAYMENT AS total_payments, SUM_PAYMENT - LAG(SUM_PAYMENT, 1) OVER (ORDER BY DT) AS MoM_change FROM "_T0" +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql b/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql index 618e8db4f..092077170 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_ansi.sql @@ -1,28 +1,9 @@ -WITH _s6 AS ( - SELECT DISTINCT - column1 AS month_start - FROM (VALUES - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) - CROSS JOIN main.sales AS sales -), _s7 AS ( +WITH _s3 AS ( SELECT DATE_TRUNC('MONTH', CAST(sales.sale_date AS TIMESTAMP)) AS sale_month, COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price - FROM (VALUES - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) - JOIN main.sales AS sales - ON TIME_TO_STR(column1, '%Y-%m') = TIME_TO_STR(sales.sale_date, '%Y-%m') + FROM main.sales AS sales JOIN main.salespersons AS salespersons ON EXTRACT(YEAR FROM CAST(salespersons.hire_date AS DATETIME)) <= 2023 AND EXTRACT(YEAR FROM CAST(salespersons.hire_date AS DATETIME)) >= 2022 diff --git a/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql b/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql index ebc064471..e9835ecd8 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_mysql.sql @@ -1,15 +1,4 @@ -WITH _s6 AS ( - SELECT DISTINCT - months_range.month_start - FROM (VALUES - ROW(CAST('2025-09-01 00:00:00' AS DATETIME)), - ROW(CAST('2025-10-01 00:00:00' AS DATETIME)), - ROW(CAST('2025-11-01 00:00:00' AS DATETIME)), - ROW(CAST('2025-12-01 00:00:00' AS DATETIME)), - ROW(CAST('2026-01-01 00:00:00' AS DATETIME)), - ROW(CAST('2026-02-01 00:00:00' AS DATETIME))) AS months_range(month_start) - CROSS JOIN dealership.sales AS sales -), _s7 AS ( +WITH _s3 AS ( SELECT STR_TO_DATE( CONCAT( @@ -22,15 +11,7 @@ WITH _s6 AS ( ) AS sale_month, COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price - FROM (VALUES - ROW(CAST('2025-09-01 00:00:00' AS DATETIME)), - ROW(CAST('2025-10-01 00:00:00' AS DATETIME)), - ROW(CAST('2025-11-01 00:00:00' AS DATETIME)), - ROW(CAST('2025-12-01 00:00:00' AS DATETIME)), - ROW(CAST('2026-01-01 00:00:00' AS DATETIME)), - ROW(CAST('2026-02-01 00:00:00' AS DATETIME))) AS months_range_2(month_start) - JOIN dealership.sales AS sales - ON DATE_FORMAT(months_range_2.month_start, '%Y-%m') = DATE_FORMAT(sales.sale_date, '%Y-%m') + FROM dealership.sales AS sales JOIN dealership.salespersons AS salespersons ON EXTRACT(YEAR FROM CAST(salespersons.hire_date AS DATETIME)) <= 2023 AND EXTRACT(YEAR FROM CAST(salespersons.hire_date AS DATETIME)) >= 2022 diff --git a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql index e39e68a6e..067859a59 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql @@ -1,41 +1,28 @@ -WITH "_S6" AS ( - SELECT DISTINCT - MONTHS_RANGE.MONTH_START - FROM (VALUES - (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2026-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE(MONTH_START) - CROSS JOIN MAIN.SALES SALES -), "_S7" AS ( +WITH "_S3" AS ( SELECT - MONTHS_RANGE_2.MONTH_START, + TRUNC(CAST(SALES.sale_date AS DATE), 'MONTH') AS SALE_MONTH, COUNT(*) AS N_ROWS, SUM(SALES.sale_price) AS SUM_SALE_PRICE - FROM (VALUES - (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), - (TO_TIMESTAMP('2026-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE_2(MONTH_START) - JOIN MAIN.SALES SALES - ON TO_CHAR(MONTHS_RANGE_2.MONTH_START, 'YYYY-MM') = TO_CHAR(SALES.sale_date, 'YYYY-MM') + FROM MAIN.SALES SALES JOIN MAIN.SALESPERSONS SALESPERSONS ON EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) <= 2023 AND EXTRACT(YEAR FROM CAST(SALESPERSONS.hire_date AS DATE)) >= 2022 AND SALES.salesperson_id = SALESPERSONS."_id" GROUP BY - MONTHS_RANGE_2.MONTH_START + TRUNC(CAST(SALES.sale_date AS DATE), 'MONTH') ) SELECT - TO_CHAR("_S6".MONTH_START, 'YYYY-MM-DD') AS month, - COALESCE("_S7".N_ROWS, 0) AS PMSPS, - COALESCE("_S7".SUM_SALE_PRICE, 0) AS PMSR -FROM "_S6" "_S6" -LEFT JOIN "_S7" "_S7" - ON "_S6".MONTH_START = "_S7".MONTH_START + TO_CHAR(TRUNC(CAST(MONTHS_RANGE.DT AS DATE), 'MONTH'), 'YYYY-MM-DD') AS month, + COALESCE("_S3".N_ROWS, 0) AS PMSPS, + COALESCE("_S3".SUM_SALE_PRICE, 0) AS PMSR +FROM (VALUES + (TO_TIMESTAMP('2025-09-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-10-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-11-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2025-12-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2026-01-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS')), + (TO_TIMESTAMP('2026-02-01 00:00:00', 'YYYY-MM-DD HH24:MI:SS'))) AS MONTHS_RANGE(DT) +LEFT JOIN "_S3" "_S3" + ON "_S3".SALE_MONTH = TRUNC(CAST(MONTHS_RANGE.DT AS DATE), 'MONTH') ORDER BY - "_S6".MONTH_START NULLS FIRST + TRUNC(CAST(MONTHS_RANGE.DT AS DATE), 'MONTH') NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql b/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql index d12e93efc..953a44fb1 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_postgres.sql @@ -1,28 +1,9 @@ -WITH _s6 AS ( - SELECT DISTINCT - months_range.month_start - FROM (VALUES - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) - CROSS JOIN main.sales AS sales -), _s7 AS ( +WITH _s3 AS ( SELECT DATE_TRUNC('MONTH', CAST(sales.sale_date AS TIMESTAMP)) AS sale_month, COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price - FROM (VALUES - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) - JOIN main.sales AS sales - ON TO_CHAR(months_range_2.month_start, 'YYYY-MM') = TO_CHAR(sales.sale_date, 'YYYY-MM') + FROM main.sales AS sales JOIN main.salespersons AS salespersons ON EXTRACT(YEAR FROM CAST(salespersons.hire_date AS TIMESTAMP)) <= 2023 AND EXTRACT(YEAR FROM CAST(salespersons.hire_date AS TIMESTAMP)) >= 2022 diff --git a/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql b/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql index d64e48e58..3795202db 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_snowflake.sql @@ -1,28 +1,9 @@ -WITH _s6 AS ( - SELECT DISTINCT - months_range.month_start - FROM (VALUES - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range(month_start) - CROSS JOIN dealership.sales AS sales -), _s7 AS ( +WITH _s3 AS ( SELECT DATE_TRUNC('MONTH', CAST(sales.sale_date AS TIMESTAMP)) AS sale_month, COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price - FROM (VALUES - (CAST('2025-09-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-10-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-11-01 00:00:00' AS TIMESTAMP)), - (CAST('2025-12-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-01-01 00:00:00' AS TIMESTAMP)), - (CAST('2026-02-01 00:00:00' AS TIMESTAMP))) AS months_range_2(month_start) - JOIN dealership.sales AS sales - ON TO_CHAR(CAST(sales.sale_date AS TIMESTAMP), 'yyyy-mm') = TO_CHAR(months_range_2.month_start, 'yyyy-mm') + FROM dealership.sales AS sales JOIN dealership.salespersons AS salespersons ON YEAR(CAST(salespersons.hire_date AS TIMESTAMP)) <= 2023 AND YEAR(CAST(salespersons.hire_date AS TIMESTAMP)) >= 2022 diff --git a/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql b/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql index 344106879..d9d71ea06 100644 --- a/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql +++ b/tests/test_sql_refsols/defog_dealership_adv8_sqlite.sql @@ -1,28 +1,9 @@ -WITH _s6 AS ( - SELECT DISTINCT - months_range.column1 AS month_start - FROM (VALUES - ('2025-09-01 00:00:00'), - ('2025-10-01 00:00:00'), - ('2025-11-01 00:00:00'), - ('2025-12-01 00:00:00'), - ('2026-01-01 00:00:00'), - ('2026-02-01 00:00:00')) AS months_range - CROSS JOIN main.sales AS sales -), _s7 AS ( +WITH _s3 AS ( SELECT DATE(sales.sale_date, 'start of month') AS sale_month, COUNT(*) AS n_rows, SUM(sales.sale_price) AS sum_sale_price - FROM (VALUES - ('2025-09-01 00:00:00'), - ('2025-10-01 00:00:00'), - ('2025-11-01 00:00:00'), - ('2025-12-01 00:00:00'), - ('2026-01-01 00:00:00'), - ('2026-02-01 00:00:00')) AS months_range_2 - JOIN main.sales AS sales - ON STRFTIME('%Y-%m', months_range_2.column1) = STRFTIME('%Y-%m', sales.sale_date) + FROM main.sales AS sales JOIN main.salespersons AS salespersons ON CAST(STRFTIME('%Y', salespersons.hire_date) AS INTEGER) <= 2023 AND CAST(STRFTIME('%Y', salespersons.hire_date) AS INTEGER) >= 2022 diff --git a/tests/test_sql_refsols/smoke_d_oracle.sql b/tests/test_sql_refsols/smoke_d_oracle.sql index 4d35b673c..cffb7e85e 100644 --- a/tests/test_sql_refsols/smoke_d_oracle.sql +++ b/tests/test_sql_refsols/smoke_d_oracle.sql @@ -7,7 +7,7 @@ SELECT NTILE(100) OVER (ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS e, NTILE(12) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS f, LAG(CUSTOMER.c_custkey, 1) OVER (ORDER BY CUSTOMER.c_custkey) AS g, - LAG(CUSTOMER.c_custkey, 2, -1) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS h, + LAG(CUSTOMER.c_custkey, 2, 42) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS h, LEAD(CUSTOMER.c_custkey, 1) OVER (ORDER BY CUSTOMER.c_custkey) AS i, LEAD(CUSTOMER.c_custkey, 6000) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS j, SUM(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) AS k, From 852b287d5aa031352257182efc21acc3de710445 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 11:04:14 -0600 Subject: [PATCH 26/48] adding oracle workflow [run oracle] --- .github/workflows/oracle_testing.yml | 61 ++++++++++++++++++++++++++++ .github/workflows/pr_testing.yml | 21 ++++++++++ documentation/usage.md | 3 -- pyproject.toml | 2 + 4 files changed, 84 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/oracle_testing.yml diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml new file mode 100644 index 000000000..246e3bc4c --- /dev/null +++ b/.github/workflows/oracle_testing.yml @@ -0,0 +1,61 @@ +name: Run Oracle Tests + +on: + workflow_call: + inputs: + python-versions: + description: "JSON string of Python versions" + type: string + required: true + secrets: + ORACLE_PASSWORD: + required: true + +jobs: + oracle-tests: + name: Oracle Tests (Python ${{ matrix.python-version }}) + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ${{ fromJSON(inputs.python-versions) }} + + # Define services here to run Docker containers alongside your job + services: + oracle: + image: bodoai1/pydough-oracle-tpch:latest + env: + # Set environment variables for MySQL container + ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + ports: + - 1521:1521 + env: + ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + ORACLE_SERVICE: FREEPDB1 + ORACLE_HOST: 127.0.0.1 + + steps: + - uses: actions/checkout@v4 + + - name: Setup Python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + + - name: Install uv + uses: astral-sh/setup-uv@v3 + with: + version: "0.4.23" + + - name: Create virtual environment + run: uv venv + + - name: Install dependencies + run: uv pip install -e ".[oracle]" + + - name: Confirm Oracle connector is installed + run: uv run python -c "import oracledb; print('Oracle connector installed')" + + - name: Run Oracle Tests + + run: uv run pytest -m oracle tests/ -rs diff --git a/.github/workflows/pr_testing.yml b/.github/workflows/pr_testing.yml index 3ca39ea72..cff0ab85f 100644 --- a/.github/workflows/pr_testing.yml +++ b/.github/workflows/pr_testing.yml @@ -49,6 +49,11 @@ on: description: "Run Postgres Tests" type: boolean required: false + default: false + run-oracle: + description: "Run Oracle Tests" + type: boolean + required: false default: false run-sf_masked: description: "Run Snowflake Masked Tests" @@ -286,3 +291,19 @@ jobs: python-versions: ${{ github.event_name == 'workflow_dispatch' && needs.get-py-ver-matrix.outputs.matrix || '["3.10", "3.11", "3.12", "3.13"]' }} + + run-oracle-tests: + name: Oracle Tests + needs: [get-msg, get-py-ver-matrix] + if: | + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run all]')) || + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run dialects]')) || + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run oracle]')) || + (github.event_name == 'workflow_dispatch' && (inputs.run-all || inputs.run-dialects || inputs.run-oracle)) + uses: ./.github/workflows/oracle_testing.yml + secrets: + ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + with: + python-versions: ${{ github.event_name == 'workflow_dispatch' + && needs.get-py-ver-matrix.outputs.matrix + || '["3.10", "3.11", "3.12", "3.13"]' }} diff --git a/documentation/usage.md b/documentation/usage.md index 476b94572..2295e8d8e 100644 --- a/documentation/usage.md +++ b/documentation/usage.md @@ -370,11 +370,8 @@ Here’s a quick reference table showing which connector is needed for each dial | `mysql` | `mysql-connector-python` | | `snowflake` | `snowflake-connector-python[pandas]` | | `postgres` | `psycopg2-binary` | -<<<<<<< HEAD | `oracle` | `python-oracledb` | -======= | `bodosql` | Depends on the catalog being used | ->>>>>>> main Below are examples of how to access the context and switch it out for a newly created one, either by manually setting it or by using `session.load_database`. These examples assume that there are two different sqlite database files located at `db_files/education.db` and `db_files/shakespeare.db`. diff --git a/pyproject.toml b/pyproject.toml index 024fcd13f..82246639a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -38,6 +38,7 @@ dev-dependencies = [ "pydough[postgres]", "pydough[server]", "pydough[bodo]", + "pydough[oracle]", ] [project.optional-dependencies] @@ -46,6 +47,7 @@ mysql = ["mysql-connector-python==9.5.0"] postgres = ["psycopg2-binary"] server = ["fastapi", "httpx", "uvicorn"] bodo = ["bodo>=2026.2", "bodosql>=2026.2", "pyiceberg[pyiceberg-core]==0.10.0"] +oracle = ["python-oracledb==3.4.2"] [build-system] requires = ["hatchling", "hatch-vcs"] From ee63c7626df73321f20827092d9fe57831cdb27a Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 11:07:04 -0600 Subject: [PATCH 27/48] oracle added to run tests [run oracle] --- .github/workflows/oracle_testing.yml | 2 +- .github/workflows/pr_testing.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 246e3bc4c..d97faccb9 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -24,7 +24,7 @@ jobs: oracle: image: bodoai1/pydough-oracle-tpch:latest env: - # Set environment variables for MySQL container + # Set environment variables for Oracle container ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} ports: - 1521:1521 diff --git a/.github/workflows/pr_testing.yml b/.github/workflows/pr_testing.yml index cff0ab85f..ca12ec15d 100644 --- a/.github/workflows/pr_testing.yml +++ b/.github/workflows/pr_testing.yml @@ -173,7 +173,7 @@ jobs: run: uv run ruff check . - name: Run Tests - run: uv run pytest tests/ -m "not (snowflake or mysql or postgres or sf_masked or s3 or bodosql)" -rs + run: uv run pytest tests/ -m "not (snowflake or mysql or postgres or sf_masked or s3 or bodosql or oracle)" -rs run-defog-daily-update: name: Run DEFOG Daily Update From 9d2f06ce5fec1df89adddfc102ed29ae2f00de4d Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 11:32:17 -0600 Subject: [PATCH 28/48] pr testing workflow fixed [run oracle] --- .github/workflows/pr_testing.yml | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/.github/workflows/pr_testing.yml b/.github/workflows/pr_testing.yml index ca12ec15d..aca742ade 100644 --- a/.github/workflows/pr_testing.yml +++ b/.github/workflows/pr_testing.yml @@ -293,17 +293,17 @@ jobs: || '["3.10", "3.11", "3.12", "3.13"]' }} run-oracle-tests: - name: Oracle Tests - needs: [get-msg, get-py-ver-matrix] - if: | - (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run all]')) || - (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run dialects]')) || - (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run oracle]')) || - (github.event_name == 'workflow_dispatch' && (inputs.run-all || inputs.run-dialects || inputs.run-oracle)) - uses: ./.github/workflows/oracle_testing.yml - secrets: - ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} - with: - python-versions: ${{ github.event_name == 'workflow_dispatch' - && needs.get-py-ver-matrix.outputs.matrix - || '["3.10", "3.11", "3.12", "3.13"]' }} + name: Oracle Tests + needs: [get-msg, get-py-ver-matrix] + if: | + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run all]')) || + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run dialects]')) || + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run oracle]')) || + (github.event_name == 'workflow_dispatch' && (inputs.run-all || inputs.run-dialects || inputs.run-oracle)) + uses: ./.github/workflows/oracle_testing.yml + secrets: + ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + with: + python-versions: ${{ github.event_name == 'workflow_dispatch' + && needs.get-py-ver-matrix.outputs.matrix + || '["3.10", "3.11", "3.12", "3.13"]' }} From f5b0b9735a1266cecf5a3e0dda0dc29d899182e5 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 11:38:42 -0600 Subject: [PATCH 29/48] oracle test workflow [run oracle] --- .github/workflows/pr_testing.yml | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/.github/workflows/pr_testing.yml b/.github/workflows/pr_testing.yml index aca742ade..1db734a6d 100644 --- a/.github/workflows/pr_testing.yml +++ b/.github/workflows/pr_testing.yml @@ -292,18 +292,18 @@ jobs: && needs.get-py-ver-matrix.outputs.matrix || '["3.10", "3.11", "3.12", "3.13"]' }} - run-oracle-tests: - name: Oracle Tests - needs: [get-msg, get-py-ver-matrix] - if: | - (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run all]')) || - (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run dialects]')) || - (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run oracle]')) || - (github.event_name == 'workflow_dispatch' && (inputs.run-all || inputs.run-dialects || inputs.run-oracle)) - uses: ./.github/workflows/oracle_testing.yml - secrets: - ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} - with: - python-versions: ${{ github.event_name == 'workflow_dispatch' - && needs.get-py-ver-matrix.outputs.matrix - || '["3.10", "3.11", "3.12", "3.13"]' }} + run-oracle-tests: + name: Oracle Tests + needs: [get-msg, get-py-ver-matrix] + if: | + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run all]')) || + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run dialects]')) || + (github.event_name == 'pull_request' && contains(needs.get-msg.outputs.commitMsg, '[run oracle]')) || + (github.event_name == 'workflow_dispatch' && (inputs.run-all || inputs.run-dialects || inputs.run-oracle)) + uses: ./.github/workflows/oracle_testing.yml + secrets: + ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + with: + python-versions: ${{ github.event_name == 'workflow_dispatch' + && needs.get-py-ver-matrix.outputs.matrix + || '["3.10", "3.11", "3.12", "3.13"]' }} From 24484af2e85f40b22eb1502d30f1972d3e5e6be6 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 12:13:20 -0600 Subject: [PATCH 30/48] oracle connector [run oracle] --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 82246639a..69ddfa169 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -47,7 +47,7 @@ mysql = ["mysql-connector-python==9.5.0"] postgres = ["psycopg2-binary"] server = ["fastapi", "httpx", "uvicorn"] bodo = ["bodo>=2026.2", "bodosql>=2026.2", "pyiceberg[pyiceberg-core]==0.10.0"] -oracle = ["python-oracledb==3.4.2"] +oracle = ["oracledb==3.4.2"] [build-system] requires = ["hatchling", "hatch-vcs"] From 9d2463eb9e83b933fae3f025293265e0832f11a8 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 12:32:11 -0600 Subject: [PATCH 31/48] adding mark [run oracle] --- .github/workflows/oracle_testing.yml | 1 + pytest.ini | 1 + 2 files changed, 2 insertions(+) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index d97faccb9..00fca0983 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -32,6 +32,7 @@ jobs: ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} ORACLE_SERVICE: FREEPDB1 ORACLE_HOST: 127.0.0.1 + ORACLE_PORT: 1521 steps: - uses: actions/checkout@v4 diff --git a/pytest.ini b/pytest.ini index 47be5edaa..e00e06e7d 100644 --- a/pytest.ini +++ b/pytest.ini @@ -8,3 +8,4 @@ markers = sf_masked: marks tests that require Snowflake Masked credentials s3: marks tests that require custom datasets from s3 bodosql: marks tests that use BodoSQL + oracle: marks tests that require Oracle Credentials From 5ce8d44abc5c0d97bb717352461801fb61adee59 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 12:48:45 -0600 Subject: [PATCH 32/48] adding waiting time [run oracle] --- tests/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index eb79d5a86..59e4d3241 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1495,10 +1495,10 @@ def oracle_docker_setup() -> None: except ImportError as e: raise RuntimeError("python-oracledb is not installed") from e - # Wait for Oracle to be ready for 3 minutes max + # Wait for Oracle to be ready for 5 minutes max # Check for keywords (last created schema) conn: oracledb.Connection | None = None - for _ in range(180): + for _ in range(300): try: if not conn: conn = oracledb.connect( From b3543ee0daf56fefc22187bfce65382584db806f Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 13:10:47 -0600 Subject: [PATCH 33/48] adding 10 min [run oracle] --- tests/conftest.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 59e4d3241..1cc132b65 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1495,10 +1495,10 @@ def oracle_docker_setup() -> None: except ImportError as e: raise RuntimeError("python-oracledb is not installed") from e - # Wait for Oracle to be ready for 5 minutes max + # Wait for Oracle to be ready for 10 minutes max # Check for keywords (last created schema) conn: oracledb.Connection | None = None - for _ in range(300): + for _ in range(600): try: if not conn: conn = oracledb.connect( @@ -1518,12 +1518,12 @@ def oracle_docker_setup() -> None: conn.close() break else: - print(f"Waiting {_ + 1}/180 seconds for data to be load...") + print(f"Waiting {_ + 1}/600 seconds for data to be load...") time.sleep(1) except oracledb.Error as e: print("Error occurred while connecting to Oracle:", e) - print(f"Waiting {_ + 1}/180 seconds for Oracle to be ready...") + print(f"Waiting {_ + 1}/600 seconds for Oracle to be ready...") time.sleep(1) else: subprocess.run(["docker", "rm", "-f", ORACLE_DOCKER_CONTAINER]) From 2bb84bf0ef63644f60d9331a2dc76f8e02a01422 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 13:51:14 -0600 Subject: [PATCH 34/48] print timer [run oracle] --- tests/conftest.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/conftest.py b/tests/conftest.py index 1cc132b65..fa4b48bc9 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1527,7 +1527,9 @@ def oracle_docker_setup() -> None: time.sleep(1) else: subprocess.run(["docker", "rm", "-f", ORACLE_DOCKER_CONTAINER]) - pytest.fail("Oracle container did not become ready in time.") + pytest.fail( + f"Oracle container did not become ready in time. Waited {_}/600 seconds" + ) @pytest.fixture(scope="session") From fd0823396e3e4458a906f1927a970e3331ab0a1a Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 15:13:00 -0600 Subject: [PATCH 35/48] workflow fix [run oracle] --- .github/workflows/oracle_testing.yml | 34 ++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 00fca0983..0c74cd72c 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -54,6 +54,40 @@ jobs: - name: Install dependencies run: uv pip install -e ".[oracle]" + - name: Install Oracle SQL*Plus + run: | + sudo apt-get update + sudo apt-get install -y libaio1 wget unzip + wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-basiclite-linuxx64.zip + wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-sqlplus-linuxx64.zip + unzip instantclient-basiclite-linuxx64.zip + unzip instantclient-sqlplus-linuxx64.zip + sudo mv instantclient_* /opt/oracle + echo "/opt/oracle" | sudo tee /etc/ld.so.conf.d/oracle-instantclient.conf + sudo ldconfig + echo "/opt/oracle" >> $GITHUB_PATH + + - name: Wait for Oracle to be ready + run: | + for i in $(seq 1 180); do + COUNT=$(echo "SET HEADING OFF FEEDBACK OFF; + SELECT COUNT(*) FROM lineitem; + EXIT;" | sqlplus -s tpch/$ORACLE_PASSWORD@$ORACLE_HOST:1521/$ORACLE_SERVICE) + + COUNT=$(echo $COUNT | xargs) + + if [ "$COUNT" = "6001215" ]; then + echo "Oracle is ready and data loaded" + exit 0 + fi + + echo "Waiting for Oracle data to load... ($i/180)" + sleep 1 + done + + echo "Oracle did not become ready in time" + exit 1 + - name: Confirm Oracle connector is installed run: uv run python -c "import oracledb; print('Oracle connector installed')" From d06f848176032b9b6dfc358d3f1b28a27184e353 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 15:43:21 -0600 Subject: [PATCH 36/48] installing dependencies [run oracle] --- .github/workflows/oracle_testing.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 0c74cd72c..b05d4c012 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -57,7 +57,7 @@ jobs: - name: Install Oracle SQL*Plus run: | sudo apt-get update - sudo apt-get install -y libaio1 wget unzip + sudo apt-get install -y libaio1t64 wget unzip wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-basiclite-linuxx64.zip wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-sqlplus-linuxx64.zip unzip instantclient-basiclite-linuxx64.zip From 15fd17d3643a49e47a0d8ea5b656d452ff1ef45f Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 15:49:50 -0600 Subject: [PATCH 37/48] sqlplus [run oracle] --- .github/workflows/oracle_testing.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index b05d4c012..306e4f4e8 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -60,8 +60,8 @@ jobs: sudo apt-get install -y libaio1t64 wget unzip wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-basiclite-linuxx64.zip wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-sqlplus-linuxx64.zip - unzip instantclient-basiclite-linuxx64.zip - unzip instantclient-sqlplus-linuxx64.zip + unzip -o instantclient-basiclite-linuxx64.zip + unzip -o instantclient-sqlplus-linuxx64.zip sudo mv instantclient_* /opt/oracle echo "/opt/oracle" | sudo tee /etc/ld.so.conf.d/oracle-instantclient.conf sudo ldconfig From 0be5d53c19b505d05413160f060a564044bc3c5d Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 15:54:37 -0600 Subject: [PATCH 38/48] sqlplus [run oracle] --- .github/workflows/oracle_testing.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 306e4f4e8..24f99ca74 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -58,6 +58,7 @@ jobs: run: | sudo apt-get update sudo apt-get install -y libaio1t64 wget unzip + sudo ln -s /usr/lib/x86_64-linux-gnu/libaio.so.1t64 /usr/lib/x86_64-linux-gnu/libaio.so.1 wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-basiclite-linuxx64.zip wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-sqlplus-linuxx64.zip unzip -o instantclient-basiclite-linuxx64.zip From 1727274d29579913fbda49065c6f01ffadd749d6 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 16:23:15 -0600 Subject: [PATCH 39/48] check data without sqlplus [run oracle] --- .github/workflows/oracle_testing.yml | 33 ++++++++-------------------- 1 file changed, 9 insertions(+), 24 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 24f99ca74..5bb8502b4 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -54,39 +54,24 @@ jobs: - name: Install dependencies run: uv pip install -e ".[oracle]" - - name: Install Oracle SQL*Plus + - name: Wait for TPCH data to load run: | - sudo apt-get update - sudo apt-get install -y libaio1t64 wget unzip - sudo ln -s /usr/lib/x86_64-linux-gnu/libaio.so.1t64 /usr/lib/x86_64-linux-gnu/libaio.so.1 - wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-basiclite-linuxx64.zip - wget https://download.oracle.com/otn_software/linux/instantclient/instantclient-sqlplus-linuxx64.zip - unzip -o instantclient-basiclite-linuxx64.zip - unzip -o instantclient-sqlplus-linuxx64.zip - sudo mv instantclient_* /opt/oracle - echo "/opt/oracle" | sudo tee /etc/ld.so.conf.d/oracle-instantclient.conf - sudo ldconfig - echo "/opt/oracle" >> $GITHUB_PATH - - - name: Wait for Oracle to be ready - run: | - for i in $(seq 1 180); do - COUNT=$(echo "SET HEADING OFF FEEDBACK OFF; - SELECT COUNT(*) FROM lineitem; - EXIT;" | sqlplus -s tpch/$ORACLE_PASSWORD@$ORACLE_HOST:1521/$ORACLE_SERVICE) - - COUNT=$(echo $COUNT | xargs) + for i in {1..600}; do + COUNT=$(docker exec ${{ job.services.oracle.id }} bash -c \ + "echo 'SET HEADING OFF FEEDBACK OFF; SELECT COUNT(*) FROM tpch.lineitem; EXIT;' | sqlplus -s tpch/$ORACLE_PASSWORD@localhost:1521/FREEPDB1" \ + 2>/dev/null | tr -dc '0-9') if [ "$COUNT" = "6001215" ]; then - echo "Oracle is ready and data loaded" + echo "TPCH data loaded" exit 0 fi - echo "Waiting for Oracle data to load... ($i/180)" + echo "Waiting for TPCH load... ($i/600)" sleep 1 done - echo "Oracle did not become ready in time" + echo "TPCH did not finish loading" + docker logs ${{ job.services.oracle.id }} exit 1 - name: Confirm Oracle connector is installed From 4e51da456cb286b4c1ac5cd30b33686e9cf5bd96 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 16:37:22 -0600 Subject: [PATCH 40/48] checking count [run oracle] --- .github/workflows/oracle_testing.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 5bb8502b4..f4758fe58 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -66,7 +66,7 @@ jobs: exit 0 fi - echo "Waiting for TPCH load... ($i/600)" + echo "Waiting for TPCH load... ($i/600), $COUNT/6001215" sleep 1 done From d4a43f77ae0c6d129b56b3de2b3f3ef3843cd70b Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 16:41:22 -0600 Subject: [PATCH 41/48] fixing count [run oracle] --- .github/workflows/oracle_testing.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index f4758fe58..1f0dd2bb4 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -58,8 +58,8 @@ jobs: run: | for i in {1..600}; do COUNT=$(docker exec ${{ job.services.oracle.id }} bash -c \ - "echo 'SET HEADING OFF FEEDBACK OFF; SELECT COUNT(*) FROM tpch.lineitem; EXIT;' | sqlplus -s tpch/$ORACLE_PASSWORD@localhost:1521/FREEPDB1" \ - 2>/dev/null | tr -dc '0-9') + "echo 'SET HEADING OFF FEEDBACK OFF VERIFY OFF PAGESIZE 0; SELECT COUNT(*) FROM tpch.lineitem; EXIT;' | sqlplus -s tpch/$ORACLE_PASSWORD@localhost:1521/FREEPDB1" \ + 2>/dev/null | awk 'NF {print $1; exit}') if [ "$COUNT" = "6001215" ]; then echo "TPCH data loaded" From 4df5b39ac9125b6fb187fb8c4e6e37115754988d Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Fri, 6 Mar 2026 16:56:30 -0600 Subject: [PATCH 42/48] waiting [run oracle] --- .github/workflows/oracle_testing.yml | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 1f0dd2bb4..c25ab63c3 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -57,23 +57,14 @@ jobs: - name: Wait for TPCH data to load run: | for i in {1..600}; do - COUNT=$(docker exec ${{ job.services.oracle.id }} bash -c \ - "echo 'SET HEADING OFF FEEDBACK OFF VERIFY OFF PAGESIZE 0; SELECT COUNT(*) FROM tpch.lineitem; EXIT;' | sqlplus -s tpch/$ORACLE_PASSWORD@localhost:1521/FREEPDB1" \ - 2>/dev/null | awk 'NF {print $1; exit}') - - if [ "$COUNT" = "6001215" ]; then + if docker logs ${{ job.services.oracle.id }} 2>&1 | grep -q "02_tpch_data.sh"; then echo "TPCH data loaded" - exit 0 + break fi - - echo "Waiting for TPCH load... ($i/600), $COUNT/6001215" - sleep 1 + echo "Waiting for TPCH load... ($i/600)" + sleep 5 done - echo "TPCH did not finish loading" - docker logs ${{ job.services.oracle.id }} - exit 1 - - name: Confirm Oracle connector is installed run: uv run python -c "import oracledb; print('Oracle connector installed')" From ab740eddf50a3a0a63bab4d42f8b7da5d328152d Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 9 Mar 2026 07:45:09 -0600 Subject: [PATCH 43/48] debugging oracle container ci [run oracle] --- .github/workflows/oracle_testing.yml | 40 +++++++++++++++++++++++++--- 1 file changed, 37 insertions(+), 3 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index c25ab63c3..4ebc792cb 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -31,7 +31,7 @@ jobs: env: ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} ORACLE_SERVICE: FREEPDB1 - ORACLE_HOST: 127.0.0.1 + ORACLE_HOST: oracle ORACLE_PORT: 1521 steps: @@ -52,7 +52,42 @@ jobs: run: uv venv - name: Install dependencies - run: uv pip install -e ".[oracle]" + run: uv pip install -e ".[oracle]" + + - name: Debug Oracle container (DELETE LATER) + run: | + echo "=== docker ps ===" + docker ps -a + + echo "=== oracle logs (last 300 lines) ===" + docker logs --tail 300 ${{ job.services.oracle.id }} + + - name: Check Oracle network (DELETE LATER) + run: | + echo "DNS:" + getent hosts oracle || true + + echo "TCP:" + for i in {1..10}; do + nc -z oracle 1521 && echo "Port open" && exit 0 + echo "Waiting for port... ($i/10)" + sleep 5 + done + + echo "Oracle port never opened" + exit 1 + + - name: Test Oracle inside container (DELETE LATER) + run: | + docker exec ${{ job.services.oracle.id }} bash -c " + echo 'SELECT name, open_mode FROM v\$pdbs;' | + sqlplus -s system/$ORACLE_PASSWORD@localhost:1521/FREEPDB1 + " + + - name: Check TPCH loader + run: | + docker exec ${{ job.services.oracle.id }} ls -l /opt/oracle/scripts/startup || true + docker logs ${{ job.services.oracle.id }} | grep -i tpch || true - name: Wait for TPCH data to load run: | @@ -69,5 +104,4 @@ jobs: run: uv run python -c "import oracledb; print('Oracle connector installed')" - name: Run Oracle Tests - run: uv run pytest -m oracle tests/ -rs From 77a29989a29bd63a2aa241e569c845ca4f431230 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 9 Mar 2026 07:59:46 -0600 Subject: [PATCH 44/48] debugging pwd [run oracle] --- .github/workflows/oracle_testing.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 4ebc792cb..9453d1dbd 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -25,13 +25,13 @@ jobs: image: bodoai1/pydough-oracle-tpch:latest env: # Set environment variables for Oracle container - ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + ORACLE_PWD: ${{ secrets.ORACLE_PASSWORD }} ports: - 1521:1521 env: ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} ORACLE_SERVICE: FREEPDB1 - ORACLE_HOST: oracle + ORACLE_HOST: 127.0.0.1 ORACLE_PORT: 1521 steps: @@ -84,7 +84,7 @@ jobs: sqlplus -s system/$ORACLE_PASSWORD@localhost:1521/FREEPDB1 " - - name: Check TPCH loader + - name: Check TPCH loader (DELETE LATER) run: | docker exec ${{ job.services.oracle.id }} ls -l /opt/oracle/scripts/startup || true docker logs ${{ job.services.oracle.id }} | grep -i tpch || true From 3f6520a55b255c7c9db3cad5ce89b030475cac21 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 9 Mar 2026 08:05:47 -0600 Subject: [PATCH 45/48] debugging network conn [run oracle] --- .github/workflows/oracle_testing.yml | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 9453d1dbd..1a051d60a 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -64,17 +64,21 @@ jobs: - name: Check Oracle network (DELETE LATER) run: | - echo "DNS:" - getent hosts oracle || true + echo "Checking Oracle TCP port on localhost" - echo "TCP:" for i in {1..10}; do - nc -z oracle 1521 && echo "Port open" && exit 0 - echo "Waiting for port... ($i/10)" + if nc -z 127.0.0.1 1521; then + echo "Oracle port is open on localhost" + exit 0 + fi + + echo "Waiting for Oracle port on localhost... ($i/10)" sleep 5 done - echo "Oracle port never opened" + echo "Oracle port never opened on localhost" + docker ps -a + docker logs ${{ job.services.oracle.id }} exit 1 - name: Test Oracle inside container (DELETE LATER) From eb002a8288881f2db64a35167e0ef5477edb7d28 Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 9 Mar 2026 08:15:59 -0600 Subject: [PATCH 46/48] testing oracle [run ci] [run dialects] --- .github/workflows/oracle_testing.yml | 39 ---------------------------- 1 file changed, 39 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index 1a051d60a..c0efb635d 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -54,45 +54,6 @@ jobs: - name: Install dependencies run: uv pip install -e ".[oracle]" - - name: Debug Oracle container (DELETE LATER) - run: | - echo "=== docker ps ===" - docker ps -a - - echo "=== oracle logs (last 300 lines) ===" - docker logs --tail 300 ${{ job.services.oracle.id }} - - - name: Check Oracle network (DELETE LATER) - run: | - echo "Checking Oracle TCP port on localhost" - - for i in {1..10}; do - if nc -z 127.0.0.1 1521; then - echo "Oracle port is open on localhost" - exit 0 - fi - - echo "Waiting for Oracle port on localhost... ($i/10)" - sleep 5 - done - - echo "Oracle port never opened on localhost" - docker ps -a - docker logs ${{ job.services.oracle.id }} - exit 1 - - - name: Test Oracle inside container (DELETE LATER) - run: | - docker exec ${{ job.services.oracle.id }} bash -c " - echo 'SELECT name, open_mode FROM v\$pdbs;' | - sqlplus -s system/$ORACLE_PASSWORD@localhost:1521/FREEPDB1 - " - - - name: Check TPCH loader (DELETE LATER) - run: | - docker exec ${{ job.services.oracle.id }} ls -l /opt/oracle/scripts/startup || true - docker logs ${{ job.services.oracle.id }} | grep -i tpch || true - - name: Wait for TPCH data to load run: | for i in {1..600}; do From 645200b17788fc7e023b28205a9133667726849d Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 9 Mar 2026 08:42:03 -0600 Subject: [PATCH 47/48] fixing sf academic_gen14 [run s3][run ci][run dialects] --- .../test_pydough_functions/defog_test_functions.py | 14 +++++++++----- .../test_sql_refsols/defog_academic_gen14_ansi.sql | 2 ++ .../defog_academic_gen14_mysql.sql | 2 ++ .../defog_academic_gen14_oracle.sql | 2 ++ .../defog_academic_gen14_postgres.sql | 2 ++ .../defog_academic_gen14_snowflake.sql | 2 ++ .../defog_academic_gen14_sqlite.sql | 2 ++ 7 files changed, 21 insertions(+), 5 deletions(-) diff --git a/tests/test_pydough_functions/defog_test_functions.py b/tests/test_pydough_functions/defog_test_functions.py index 8d9a2ba46..c5f6e1e45 100644 --- a/tests/test_pydough_functions/defog_test_functions.py +++ b/tests/test_pydough_functions/defog_test_functions.py @@ -2642,11 +2642,15 @@ def impl_defog_academic_gen14(): """ n_pubs = COUNT(publications) n_jours = NDISTINCT(publications.journal_id) - return publications.PARTITION(name="years", by=year).CALCULATE( - year, - num_publications=n_pubs, - num_journals=n_jours, - ratio=n_pubs / n_jours, + return ( + publications.PARTITION(name="years", by=year) + .CALCULATE( + year, + num_publications=n_pubs, + num_journals=n_jours, + ratio=n_pubs / n_jours, + ) + .ORDER_BY(year.ASC()) ) diff --git a/tests/test_sql_refsols/defog_academic_gen14_ansi.sql b/tests/test_sql_refsols/defog_academic_gen14_ansi.sql index f578e20e5..5379a49cf 100644 --- a/tests/test_sql_refsols/defog_academic_gen14_ansi.sql +++ b/tests/test_sql_refsols/defog_academic_gen14_ansi.sql @@ -6,3 +6,5 @@ SELECT FROM main.publication GROUP BY 1 +ORDER BY + 1 diff --git a/tests/test_sql_refsols/defog_academic_gen14_mysql.sql b/tests/test_sql_refsols/defog_academic_gen14_mysql.sql index c07df8237..d5a62c7ac 100644 --- a/tests/test_sql_refsols/defog_academic_gen14_mysql.sql +++ b/tests/test_sql_refsols/defog_academic_gen14_mysql.sql @@ -6,3 +6,5 @@ SELECT FROM publication GROUP BY 1 +ORDER BY + 1 diff --git a/tests/test_sql_refsols/defog_academic_gen14_oracle.sql b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql index ca6d0ba14..b9f3f32f7 100644 --- a/tests/test_sql_refsols/defog_academic_gen14_oracle.sql +++ b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql @@ -6,3 +6,5 @@ SELECT FROM MAIN.PUBLICATION GROUP BY year +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen14_postgres.sql b/tests/test_sql_refsols/defog_academic_gen14_postgres.sql index eecc51955..bdc49435a 100644 --- a/tests/test_sql_refsols/defog_academic_gen14_postgres.sql +++ b/tests/test_sql_refsols/defog_academic_gen14_postgres.sql @@ -6,3 +6,5 @@ SELECT FROM main.publication GROUP BY 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen14_snowflake.sql b/tests/test_sql_refsols/defog_academic_gen14_snowflake.sql index 51621b549..1b14f04b3 100644 --- a/tests/test_sql_refsols/defog_academic_gen14_snowflake.sql +++ b/tests/test_sql_refsols/defog_academic_gen14_snowflake.sql @@ -6,3 +6,5 @@ SELECT FROM academic.publication GROUP BY 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen14_sqlite.sql b/tests/test_sql_refsols/defog_academic_gen14_sqlite.sql index 0a2b57a4f..9f1ac8d77 100644 --- a/tests/test_sql_refsols/defog_academic_gen14_sqlite.sql +++ b/tests/test_sql_refsols/defog_academic_gen14_sqlite.sql @@ -6,3 +6,5 @@ SELECT FROM main.publication GROUP BY 1 +ORDER BY + 1 From 6bf5755315bd81f1394c6362f5f60d46d0f3b29c Mon Sep 17 00:00:00 2001 From: john-sanchez31 Date: Mon, 9 Mar 2026 09:50:35 -0600 Subject: [PATCH 48/48] fixing typo [run s3][run ci][run dialects] --- .github/workflows/oracle_testing.yml | 3 --- pydough/database_connectors/builtin_databases.py | 4 ++-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml index c0efb635d..53e9d488a 100644 --- a/.github/workflows/oracle_testing.yml +++ b/.github/workflows/oracle_testing.yml @@ -30,9 +30,6 @@ jobs: - 1521:1521 env: ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} - ORACLE_SERVICE: FREEPDB1 - ORACLE_HOST: 127.0.0.1 - ORACLE_PORT: 1521 steps: - uses: actions/checkout@v4 diff --git a/pydough/database_connectors/builtin_databases.py b/pydough/database_connectors/builtin_databases.py index 750b297cb..034585788 100644 --- a/pydough/database_connectors/builtin_databases.py +++ b/pydough/database_connectors/builtin_databases.py @@ -325,7 +325,7 @@ def load_oracle_connection(**kwargs) -> DatabaseConnection: - `host`: Oracle server host (default: "127.0.0.1"/"localhost"). - `port`: Oracle server port (default: 1521). - `tcp_connect_timeout`: Timeout for the connection (default: 3 seconds). - - `attempts` (not an Oralce connector parameter): Number of connection attempts (default: 3) + - `attempts` (not an Oracle connector parameter): Number of connection attempts (default: 3) - `delay` (not an Oracle connector parameter): Delay between connection attempts (default: 2 seconds). If a connection object is provided, it will be used directly. All arguments must be accepted by the Oracle connector connect API. @@ -353,7 +353,7 @@ def load_oracle_connection(**kwargs) -> DatabaseConnection: return DatabaseConnection(connection) # Oracle connection requires specific parameters: - # user, password and dsn or host, port and service_name instead of dsn. + # user, password, host and service_name. # Raise an error if any of these are missing. # NOTE: host, port are optional and will default to the oracle defaults. # See: https://python-oracledb.readthedocs.io/en/latest/user_guide/connection_handling.html