diff --git a/.github/workflows/oracle_testing.yml b/.github/workflows/oracle_testing.yml new file mode 100644 index 000000000..53e9d488a --- /dev/null +++ b/.github/workflows/oracle_testing.yml @@ -0,0 +1,69 @@ +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 Oracle container + ORACLE_PWD: ${{ secrets.ORACLE_PASSWORD }} + ports: + - 1521:1521 + env: + ORACLE_PASSWORD: ${{ secrets.ORACLE_PASSWORD }} + + 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: Wait for TPCH data to load + run: | + for i in {1..600}; do + if docker logs ${{ job.services.oracle.id }} 2>&1 | grep -q "02_tpch_data.sh"; then + echo "TPCH data loaded" + break + fi + echo "Waiting for TPCH load... ($i/600)" + sleep 5 + done + + - 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..1db734a6d 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" @@ -168,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 @@ -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/demos/README.md b/demos/README.md index aea4e263a..3453f9105 100644 --- a/demos/README.md +++ b/demos/README.md @@ -27,4 +27,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..dde15416a --- /dev/null +++ b/demos/notebooks/Oracle_TCPH.ipynb @@ -0,0 +1,317 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d1cd6a33", + "metadata": {}, + "source": [ + "# 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_user = \"tpch\"\n", + "oracle_password = os.getenv(\"ORACLE_PASSWORD\")\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=oracle_user,\n", + " password=oracle_password,\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", + ")" + ] + }, + { + "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": { + "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, + "nbformat_minor": 5 +} diff --git a/documentation/usage.md b/documentation/usage.md index 33b97f291..2295e8d8e 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. - `bodosql`: uses a BodoSQL context. [See here](https://docs.bodo.ai/latest/api_docs/sql/bodosqlcontext/) for details on the BodoSQL context and [here](https://docs.bodo.ai/latest/api_docs/sql/database_catalogs/) for details on the various kinds of catalogs that can be connected to a BodoSQL context. @@ -368,6 +370,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` | | `bodosql` | Depends on the catalog being used | 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`. @@ -444,6 +447,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 1746eb2c1..034585788 100644 --- a/pydough/database_connectors/builtin_databases.py +++ b/pydough/database_connectors/builtin_databases.py @@ -18,6 +18,7 @@ "load_bodosql_context", "load_database_context", "load_mysql_connection", + "load_oracle_connection", "load_postgres_connection", "load_snowflake_connection", "load_sqlite_connection", @@ -37,7 +38,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 | BodoSQLContext dialect: DatabaseDialect match database_name.lower(): @@ -53,6 +54,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 "bodosql": connection = load_bodosql_context(**kwargs) dialect = DatabaseDialect.BODOSQL @@ -306,6 +310,98 @@ def load_postgres_connection(**kwargs) -> DatabaseConnection: 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 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. + + 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, 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 + + 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") + + def load_bodosql_context(**kwargs) -> "BodoSQLContext": """ Loads a BodoSQL context from the keyword arguments, which are expected to diff --git a/pydough/database_connectors/database_connector.py b/pydough/database_connectors/database_connector.py index b13ddd083..90c7deac6 100644 --- a/pydough/database_connectors/database_connector.py +++ b/pydough/database_connectors/database_connector.py @@ -110,6 +110,7 @@ class DatabaseDialect(Enum): SNOWFLAKE = "snowflake" MYSQL = "mysql" POSTGRES = "postgres" + ORACLE = "oracle" BODOSQL = "bodosql" @staticmethod diff --git a/pydough/database_connectors/db_types.py b/pydough/database_connectors/db_types.py index c59cc3c56..32b6cbe73 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 import bodosql @@ -62,6 +71,8 @@ MySQLCursor: TypeAlias = Any PostgresConn: TypeAlias = Any PostgresCursor: TypeAlias = Any + OracleConn: TypeAlias = Any + OracleCursor: TypeAlias = Any BodoSQLContext: TypeAlias = Any # This allows us to use these type aliases in the rest of the code @@ -72,6 +83,8 @@ "DBCursor", "MySQLConn", "MySQLCursor", + "OracleConn", + "OracleCursor", "PostgresConn", "PostgresCursor", "SQLiteConn", diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index e1e92e7e4..8f7b71cef 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -11,10 +11,13 @@ 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 +from sqlglot.dialects.dialect import rename_func from sqlglot.dialects.mysql import MySQL +from sqlglot.dialects.oracle import Oracle from sqlglot.errors import SqlglotError from sqlglot.expressions import ( Alias, @@ -204,7 +207,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) @@ -214,10 +217,16 @@ 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 -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: @@ -293,7 +302,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 @@ -350,9 +361,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) @@ -466,6 +479,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. @@ -490,6 +531,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}") @@ -510,6 +553,17 @@ 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" + + # 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 @@ -523,6 +577,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/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/sqlglot_relational_expression_visitor.py b/pydough/sqlglot/sqlglot_relational_expression_visitor.py index b812a1bd9..454f844e0 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,31 @@ 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_DATE", + expressions=[ + sqlglot_expressions.convert( + literal_expression.value.strftime("%Y-%m-%d %H:%M:%S") + ), + sqlglot_expressions.Literal.string("YYYY-MM-DD HH24:MI:SS"), + ], + ) self._stack.append(literal) def visit_correlated_reference( 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/pydough/sqlglot/transform_bindings/__init__.py b/pydough/sqlglot/transform_bindings/__init__.py index af970d134..306cb1fc6 100644 --- a/pydough/sqlglot/transform_bindings/__init__.py +++ b/pydough/sqlglot/transform_bindings/__init__.py @@ -21,6 +21,7 @@ from .base_transform_bindings import BaseTransformBindings from .bodosql_transform_bindings import BodoSQLTransformBindings 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 @@ -59,5 +60,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..5ddf9de95 --- /dev/null +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -0,0 +1,1165 @@ +""" +Definition of SQLGlot transformation bindings for the Oracle dialect. +""" + +__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 pydough.types.string_type import StringType + +from .base_transform_bindings import BaseTransformBindings +from .sqlglot_transform_utils import ( + DateTimeUnit, + apply_parens, +) + + +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, + } + + @property + 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", # 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.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 + ) + 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_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], + 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: + """ + Convert a PyDough slice operation to a SQLGlot expression. + Oracle uses the SUBSTR 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 SUBSTR(x, 1) + case (+a, None): + return SUBSTR(x, a + 1) + case (-a, None): + return SUBSTR(x, a) + case (None, +b): + return SUBSTR(x, 1, b) + case (None, -b): + return SUBSTR(x, 1, LENGTH(x) + b) + case (+a, +b): + return SUBSTR(x, a + 1, GREATEST(b - a, 0)) + case (-a, -b): + return SUBSTR(x, a, GREATEST(b - a, 0)) + case (+a, -b): + return SUBSTR(x, a + 1, GREATEST(LENGTH(x) + b - a, 0)) + case (-a, +b): + return SUBSTR(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_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: + """ + GETPART(str, delim, idx) -> + 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 + + string_expr, delimiter_expr, index_expr = args + literal_0: SQLGlotExpression = sqlglot_expressions.Literal.number(0) + literal_1: SQLGlotExpression = sqlglot_expressions.Literal.number(1) + + 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=apply_parens(index_expr), expression=literal_0 + ), + true=index_expr, + ), + ], + 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 + ), + true=case_neg_idx, + ) + ], + default=sqlglot_expressions.Null(), + ) + + regexp_substr: SQLGlotExpression = sqlglot_expressions.Anonymous( + this="REGEXP_SUBSTR", + expressions=[ + string_expr, + delim_regexp, + literal_1, + case_occurrence, + sqlglot_expressions.Null(), + literal_1, + ], + ) + # 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( + 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: 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: + 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 + + # (FLOOR((EXTRACT(MONTH FROM date2) - 1) / 3) - + # FLOOR((EXTRACT(MONTH FROM date1) - 1) / 3)) + quarter_diff: SQLGlotExpression = sqlglot_expressions.Sub( + 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.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), + ) + ), + ) + + 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 = FLOOR((raw_delta + dow1 - dow2) / 7) + raw_delta: SQLGlotExpression = 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") + ), + ) + + 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, '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 + 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.Mul( + this=apply_parens(hours_diff), + expression=sqlglot_expressions.Literal.number(24), + ) + + case DateTimeUnit.MINUTE: + # (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.Mul( + this=apply_parens(minutes_diff), + expression=sqlglot_expressions.Literal.number(24 * 60), + ) + + case DateTimeUnit.SECOND: + # (date2 - date1) * 24 * 60 * 60 + dates_sub: SQLGlotExpression = sqlglot_expressions.Sub( + this=date2, expression=date1 + ) + second_diff: SQLGlotExpression = sqlglot_expressions.Mul( + this=apply_parens(dates_sub), + expression=sqlglot_expressions.Literal.number(24 * 60 * 60), + ) + return 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), + ) + + 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 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.QUARTER: + # TRUNC(o_orderdate, 'Q') + return sqlglot_expressions.Anonymous( + this="TRUNC", + expressions=[ + self.make_datetime_arg(base), + sqlglot_expressions.Var(this="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: + # 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.Literal.string("DD"), + ) + 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 + 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: + 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.") + + if original_amt > 0: + new_expr = sqlglot_expressions.Add(this=base, expression=interval) + elif original_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: + if len(args) == 1: + return sqlglot_expressions.Literal.string("") + elif len(args) == 2: + # Return the first string + return args[1] + + delim_expr = args[0] + + # 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( + 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" + ) + + 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: + """ + 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: + 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=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 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/pyproject.toml b/pyproject.toml index 024fcd13f..69ddfa169 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 = ["oracledb==3.4.2"] [build-system] requires = ["hatchling", "hatch-vcs"] 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 diff --git a/tests/conftest.py b/tests/conftest.py index 7649fec29..fa4b48bc9 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -39,8 +39,10 @@ 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_bodosql, string_format_specifiers_mysql, + string_format_specifiers_oracle, string_format_specifiers_postgres, string_format_specifiers_snowflake, ) @@ -228,7 +230,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 @@ -264,6 +282,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, @@ -433,6 +467,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: @@ -1392,6 +1427,162 @@ 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 10 minutes max + # Check for keywords (last created schema) + conn: oracledb.Connection | None = None + for _ in range(600): + 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}/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}/600 seconds for Oracle to be ready...") + time.sleep(1) + else: + subprocess.run(["docker", "rm", "-f", ORACLE_DOCKER_CONTAINER]) + pytest.fail( + f"Oracle container did not become ready in time. Waited {_}/600 seconds" + ) + + +@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: """ @@ -1699,14 +1890,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", @@ -2130,176 +2321,252 @@ 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", - ) - elif dialect == DatabaseDialect.BODOSQL: + 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 DatabaseDialect.ORACLE: + return PyDoughPandasTest( + string_format_specifiers_oracle, + "TPCH", + lambda: pd.DataFrame( + { + # ===== YEAR ===== + "d1": ["2023"], # YYYY + "d2": ["23"], # YY + "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", + ) + case DatabaseDialect.BODOSQL: + return PyDoughPandasTest( + string_format_specifiers_bodosql, + "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 + "d9": ["14"], # HH24 + "d10": ["02"], # HH12 + "d11": ["30"], # MI + "d12": ["45"], # SS + "d13": ["PM"], # AM / PM + } + ), + "string_format_specifiers", + ) + 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( - string_format_specifiers_bodosql, + simple_int_float_string_cast, "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 - "d9": ["14"], # HH24 - "d10": ["02"], # HH12 - "d11": ["30"], # MI - "d12": ["45"], # SS - "d13": ["PM"], # AM / PM + "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"], } ), - "string_format_specifiers", + "simple_int_float_string_cast", ) + return test 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_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..af67c08a5 --- /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_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json new file mode 100644 index 000000000..553e6ff32 --- /dev/null +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -0,0 +1,4673 @@ +[ + { + "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"] + } + ], + "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": {} + }, + { + "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_pub", + "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..21a6e5dad --- /dev/null +++ b/tests/test_pipeline_oracle.py @@ -0,0 +1,566 @@ +""" +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, + week_offset, +) +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.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( + 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_oracle_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_oracle_test_data.run_e2e_test( + get_oracle_defog_graphs, + oracle_conn_db_context(defog_custom_oracle_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_oracle_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_oracle_custom_datasets_graph, + oracle_conn_db_context(custom_datasets_test_data.graph_name.lower()), + coerce_types=True, + ) 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/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_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/defog_test_functions.py b/tests/test_pydough_functions/defog_test_functions.py index 9c73a3f4f..c5f6e1e45 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, @@ -887,7 +890,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)) @@ -1324,7 +1327,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( @@ -1482,7 +1485,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)) @@ -2638,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()) ) @@ -2704,7 +2712,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_pydough_functions/simple_pydough_functions.py b/tests/test_pydough_functions/simple_pydough_functions.py index 9d0a28bbd..fd3cf0295 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"), ) @@ -2908,6 +2958,40 @@ def string_format_specifiers_snowflake(): ) +def string_format_specifiers_oracle(): + # String format specifiers for date/time with a static datetime + # 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( + # ===== 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) + ) + + def string_format_specifiers_bodosql(): # String format specifiers for date/time with a static datetime # Works for BodoSQL @@ -2951,8 +3035,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_pydough_functions/user_collections.py b/tests/test_pydough_functions/user_collections.py index 969c2af1a..cf984b87f 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_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/agg_partition_oracle.sql b/tests/test_sql_refsols/agg_partition_oracle.sql new file mode 100644 index 000000000..7c5cefcf7 --- /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 DATE)) +) +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..a61a7200e --- /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, + COALESCE(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, + CASE WHEN NOT AUG_EXCHANGE IS NULL THEN 1 ELSE 0 END 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..5cd93957d --- /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, + 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, + 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..662cb96a0 --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql @@ -0,0 +1,46 @@ +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 DATE)) 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(COALESCE("_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..97178b3c5 --- /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 DATE)) 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(COALESCE("_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..ec784947d --- /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 DATE)) = 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(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 +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..721ff25d9 --- /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, + 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" + GROUP BY + C_NATIONKEY +) +SELECT + 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, + 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..1431d2cb2 --- /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(CAST("_S0".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER + FROM "_S0" "_S0" + JOIN "_T2" "_T2" + 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 + 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(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(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(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 + ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = "_S9".PR_ID + GROUP BY + TRUNC(CAST(CAST("_S2".CA_DT AS DATE) AS DATE), 'Q') +), "_S21" AS ( + SELECT + 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(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(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') + JOIN "_T5" "_T9" + ON DEVICES.de_product_id = "_T9".PR_ID + GROUP BY + TRUNC(CAST(CAST("_S14".CA_DT AS DATE) AS DATE), 'Q') +) +SELECT + "_S12".QUARTER AS quarter, + COALESCE("_S13".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + COALESCE("_S21".N_ROWS, 0) AS n_sold, + ROUND( + 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" +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..d656e9d2b --- /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..5be1dfd75 --- /dev/null +++ b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql @@ -0,0 +1,13 @@ +WITH "_T0" AS ( + SELECT + 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' +) +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..1a48285bf --- /dev/null +++ b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql @@ -0,0 +1,23 @@ +WITH "_T1" AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + ORDERS.o_custkey AS O_CUSTKEY, + 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' + 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..b8d8ce13c --- /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, + COALESCE("_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..4a7d1a623 --- /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..4a7d1a623 --- /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..2de33d6b0 --- /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(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 +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders +FROM "_T" +WHERE + 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_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 new file mode 100644 index 000000000..919ca6fa9 --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql @@ -0,0 +1,41 @@ +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 +), "_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" +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/casting_functions_oracle.sql b/tests/test_sql_refsols/casting_functions_oracle.sql new file mode 100644 index 000000000..19579e241 --- /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 VARCHAR2(4000)) AS cast_to_string2, + 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/comparisons_and_logical_operators_oracle.sql b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql new file mode 100644 index 000000000..9e21400ab --- /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..2e7fc4d16 --- /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, + 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 + 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..68b3ec7da --- /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 < 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(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 + 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 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 < 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 + GROUP BY + TRUNC(CAST("_S3".CA_DT AS DATE), 'YEAR'), + "_T3".CO_NAME +) +SELECT + "_T1".CO_NAME AS country_name, + "_S17".START_OF_YEAR AS start_of_year, + COALESCE("_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..017ac2cc0 --- /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 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 < ADD_MONTHS(CAST(PRODUCTS.pr_release AS DATE), 24) + 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..9a0b54849 --- /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(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(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) + ) / 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 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 new file mode 100644 index 000000000..ab0db546a --- /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 DATE)) = 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 DATE)) = 1994 + GROUP BY + ORDERS.o_orderkey +), "_T" AS ( + SELECT + ANYTHING_O_CUSTKEY, + ANYTHING_O_ORDERDATE, + SUM_R, + 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, + 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 + 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..2492728a4 --- /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, + COALESCE("_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/dataframe_collection_best_oracle.sql b/tests/test_sql_refsols/dataframe_collection_best_oracle.sql new file mode 100644 index 000000000..2d30185d8 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_best_oracle.sql @@ -0,0 +1,27 @@ +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, + 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 (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, + "_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..b4e64d2f6 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_correlation_oracle.sql @@ -0,0 +1,32 @@ +WITH "_S3" AS ( + SELECT + 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_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_3(KEY, CLASS_NAME, LANGUAGE) + ON CLASSES_2.KEY <> CLASSES_3.KEY AND CLASSES_2.LANGUAGE = CLASSES_3.LANGUAGE + GROUP BY + CLASSES_2.KEY +) +SELECT + 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'), + (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 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 new file mode 100644 index 000000000..15098b5ca --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_cross_oracle.sql @@ -0,0 +1,18 @@ +SELECT + 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 (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 new file mode 100644 index 000000000..3d31e1b00 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_datatypes_oracle.sql @@ -0,0 +1,30 @@ +SELECT + 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, + 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) +ORDER BY + 2 NULLS FIRST 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..dff8e9f86 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_highest_rating_oracle.sql @@ -0,0 +1,67 @@ +WITH "_T" AS ( + SELECT + 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), + (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) + ON CLASSES.KEY = TEACHING.CLASS_KEY +) +SELECT + "_T".CLASS_NAME AS class_name, + "_T".SEMESTER AS last_semester, + TEACHERS.FIRST_NAME AS teacher_first_name, + TEACHERS.LAST_NAME AS teacher_last_name +FROM "_T" "_T" +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 new file mode 100644 index 000000000..c3609b090 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_inf_oracle.sql @@ -0,0 +1,9 @@ +SELECT + 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), + (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_language_highest_rating_oracle.sql b/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql new file mode 100644 index 000000000..d1cd23c7d --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_language_highest_rating_oracle.sql @@ -0,0 +1,69 @@ +WITH "_T" AS ( + SELECT + 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), + (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) + ON CLASSES.KEY = TEACHING.CLASS_KEY + WHERE + NOT CLASSES.LANGUAGE IS NULL +) +SELECT + "_T".LANGUAGE AS language, + "_T".RATING AS rating, + TEACHERS.FIRST_NAME AS first_name, + TEACHERS.LAST_NAME AS last_name +FROM "_T" "_T" +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 new file mode 100644 index 000000000..2353d7392 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_numbers_oracle.sql @@ -0,0 +1,13 @@ +SELECT + 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), + (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..002e1d29c --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_partition_oracle.sql @@ -0,0 +1,17 @@ +SELECT + PRODUCTS_COLLECTION.PRODUCT_CATEGORY AS product_category, + AVG(PRODUCTS_COLLECTION.PRICE) AS avg_price, + COUNT(*) AS n_products, + 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 (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 + 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 new file mode 100644 index 000000000..1f22b9459 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_strings_oracle.sql @@ -0,0 +1,11 @@ +SELECT + 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"'), + ('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..bc4dff024 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_taught_recently_oracle.sql @@ -0,0 +1,67 @@ +WITH "_T" AS ( + SELECT + 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), + (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) + ON CLASSES.KEY = TEACHING.CLASS_KEY +) +SELECT + "_T".CLASS_NAME AS class_name, + "_T".SEMESTER AS last_semester, + TEACHERS.FIRST_NAME AS teacher_first_name, + TEACHERS.LAST_NAME AS teacher_last_name +FROM "_T" "_T" +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 new file mode 100644 index 000000000..853bb3534 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_teacher_class_oracle.sql @@ -0,0 +1,68 @@ +WITH "_T" AS ( + SELECT + 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), + (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) + ON TEACHERS.TID = TEACHING.TEACHER_ID +) +SELECT + "_T".FIRST_NAME AS first_name, + "_T".LAST_NAME AS last_name, + "_T".SEMESTER AS recent_semester, + CLASSES.CLASS_NAME AS class_name +FROM "_T" "_T" +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 new file mode 100644 index 000000000..019dc8055 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_teacher_count_oracle.sql @@ -0,0 +1,85 @@ +SELECT + 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), + (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 (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 + 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 new file mode 100644 index 000000000..c8e6322d8 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_teacher_lowest_rating_oracle.sql @@ -0,0 +1,68 @@ +WITH "_T" AS ( + SELECT + 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), + (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) + ON TEACHERS.TID = TEACHING.TEACHER_ID +) +SELECT + "_T".FIRST_NAME AS first_name, + "_T".LAST_NAME AS last_name, + "_T".RATING AS rating, + CLASSES.CLASS_NAME AS class_name +FROM "_T" "_T" +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 new file mode 100644 index 000000000..f84af103a --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_top_k_oracle.sql @@ -0,0 +1,21 @@ +SELECT + PART.p_name AS name, + DISCOUNTS.SHIPPING_TYPE AS shipping_type, + LINEITEM.l_extendedprice AS extended_price, + LINEITEM.l_discount + DISCOUNTS.ADDED_DISCOUNT AS added_discount, + LINEITEM.l_extendedprice * ( + 1 - ( + LINEITEM.l_discount + DISCOUNTS.ADDED_DISCOUNT + ) + ) 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 DISCOUNTS.SHIPPING_TYPE = 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..cf50e68d9 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_unique_partition_oracle.sql @@ -0,0 +1,16 @@ +SELECT DISTINCT + TEACHERS.FIRST_NAME AS first_name, + TEACHERS.LAST_NAME 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..8cda8283b --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_where_date_oracle.sql @@ -0,0 +1,25 @@ +SELECT + DATES.CLERK_ID AS clerk_id, + COUNT(*) AS n_orders +FROM (VALUES + ( + 'Clerk#000000456', + 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', + 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', + 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 + AND DATES.END_DATE >= CAST(ORDERS.o_orderdate AS DATE) + AND DATES.START_DATE <= CAST(ORDERS.o_orderdate AS DATE) +GROUP BY + 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 new file mode 100644 index 000000000..cdcc58444 --- /dev/null +++ b/tests/test_sql_refsols/dataframe_collection_where_oracle.sql @@ -0,0 +1,67 @@ +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 THRESHOLDS_COLLECTION.MIN_ACCOUNT_BALANCE < "_S1".S_ACCTBAL + JOIN "_S5" "_S5" + ON THRESHOLDS_COLLECTION.REGION_NAME = "_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 THRESHOLDS_COLLECTION_2.MIN_ACCOUNT_BALANCE < "_S7".S_ACCTBAL + JOIN "_S11" "_S11" + ON THRESHOLDS_COLLECTION_2.REGION_NAME = "_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..a83a2a08a --- /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, + CUSTOMERS_FILTERS.MRK_SEGMENT, + NATION.n_name AS N_NAME, + CUSTOMERS_FILTERS.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/datediff_oracle.sql b/tests/test_sql_refsols/datediff_oracle.sql new file mode 100644 index 000000000..79d35830e --- /dev/null +++ b/tests/test_sql_refsols/datediff_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS x, + 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, + 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, + ( + 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) + ) * 86400 AS seconds_diff +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..00c1805e5 --- /dev/null +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -0,0 +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), '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 new file mode 100644 index 000000000..39311f28d --- /dev/null +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -0,0 +1,78 @@ +SELECT + SYS_EXTRACT_UTC(SYSTIMESTAMP) AS ts_now_1, + 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, + TO_DATE('1995-10-08', 'YYYY-MM-DD') AS ts_now_6, + 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 DATE)) AS month_col, + 2 AS month_str, + 1 AS month_dt, + 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, + 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 + ( + 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( + ( + 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) + ) - ( + 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, + 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 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 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..37c10147c --- /dev/null +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -0,0 +1,19 @@ +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 DATE), 'YEAR') AS d1, + TRUNC(CAST(O_ORDERDATE AS DATE), 'MONTH') AS d2, + 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 +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..c07bd63e0 --- /dev/null +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -0,0 +1,191 @@ +SELECT + 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", + 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 DATE) AS "_expr19", + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), SECOND) AS "_expr20", + 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", + 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", + ADD_MONTHS( + TIMESTAMP_TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(312, 'hour'), SECOND), + 576 + ) AS "_expr29", + 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'), + '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), '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'), '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( + CAST(o_orderdate AS DATE) + NUMTODSINTERVAL(82, 'second') + NUMTODSINTERVAL(415, 'second') - NUMTODSINTERVAL(160, 'second'), + 'YEAR' + ) AS "_expr41", + 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( + ADD_MONTHS(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP) + NUMTODSINTERVAL(297, 'day'), 72), -92), + HOUR + ) AS "_expr45", + 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'), + 'MONTH' + ) - NUMTODSINTERVAL(21, 'day') AS "_expr48", + 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", + ADD_MONTHS( + TIMESTAMP_TRUNC(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(60, 'hour'), 'DD'), MINUTE), + 2352 + ) 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", + 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), + 'DD' + ) + NUMTODSINTERVAL(78, 'second') AS "_expr56", + 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", + EXTRACT(MONTH FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr62", + 6 AS "_expr63", + 3 AS "_expr64", + EXTRACT(DAY FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE)) AS "_expr65", + 4 AS "_expr66", + 4 AS "_expr67", + EXTRACT(HOUR FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS TIMESTAMP)) AS "_expr68", + 0 AS "_expr69", + 0 AS "_expr70", + EXTRACT(MINUTE FROM CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS TIMESTAMP)) AS "_expr71", + 30 AS "_expr72", + 0 AS "_expr73", + 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('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('1999-03-14' AS DATE)) - EXTRACT(YEAR FROM TO_DATE('2005-06-30', 'YYYY-MM-DD')) + ) * 12 + ( + 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')) + ) * 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", + 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", + ( + 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 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 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('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('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('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('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", + 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", + ( + 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 DATE), 'MI') - TRUNC(CAST(TO_DATE('2005-06-30', 'YYYY-MM-DD') AS DATE), 'MI') + ) * 1440 AS "_expr97", + ( + 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('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') + ) * 86400 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..7fbb26eae --- /dev/null +++ b/tests/test_sql_refsols/deep_best_analysis_oracle.sql @@ -0,0 +1,110 @@ +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..1fe24b015 --- /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..48de0e7eb --- /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, + 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 +LEFT JOIN "_S3" "_S3" + ON DOMAIN.did = "_S3".DID 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 new file mode 100644 index 000000000..b9f3f32f7 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql @@ -0,0 +1,10 @@ +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 +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 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..0f021fc85 --- /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, + COALESCE(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..bda7a8a4e --- /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..cb493537e --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ANY_VALUE(CONFERENCE.name) AS name, + COUNT(PUBLICATION.cid) 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_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 new file mode 100644 index 000000000..21fff6ee5 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql @@ -0,0 +1,18 @@ +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, + COALESCE("_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, + 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_academic_gen19_oracle.sql b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql new file mode 100644 index 000000000..3fd973bf0 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ANY_VALUE(CONFERENCE.name) AS name, + COUNT(PUBLICATION.cid) 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..0219ee3c3 --- /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_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 new file mode 100644 index 000000000..2b11f8126 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..affeda650 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql @@ -0,0 +1,24 @@ +WITH "_S0" AS ( + SELECT + 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 +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 new file mode 100644 index 000000000..156bcc464 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..098e3337e --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql @@ -0,0 +1,22 @@ +WITH "_u_0" AS ( + SELECT + 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 + 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 + GROUP BY + DOMAIN_CONFERENCE.cid, + WRITES.pid +) +SELECT + PUBLICATION.title +FROM MAIN.PUBLICATION PUBLICATION +LEFT JOIN "_u_0" "_u_0" + ON PUBLICATION.cid = "_u_0"."_u_1" AND PUBLICATION.pid = "_u_0"."_u_2" +WHERE + NOT "_u_0"."_u_1" IS NULL AND 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..1d51cb6b7 --- /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, + 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_gen3_oracle.sql b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql new file mode 100644 index 000000000..b6f4e060f --- /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..45874c5c8 --- /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..2d0bbbfbe --- /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, + COALESCE("_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..edd7075c6 --- /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 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 DATE)), + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)), + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS "_id", + SBCUSTOMER.sbcustname AS name, + 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 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_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 new file mode 100644 index 000000000..fe0770b5e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql @@ -0,0 +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 +LEFT JOIN "_u_0" "_u_0" + ON SBCUSTOMER.sbcustid = "_u_0"."_u_1" +WHERE + NOT "_u_0"."_u_1" IS NULL AND 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..3a15fbd40 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql @@ -0,0 +1,21 @@ +WITH "_S1" AS ( + SELECT + sbdptickerid AS SBDPTICKERID, + COUNT(sbdpclose) AS COUNT_SBDPCLOSE, + SUM(sbdpclose) AS SUM_SBDPCLOSE + FROM MAIN.SBDAILYPRICE + WHERE + ( + 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 +) +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_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 new file mode 100644 index 000000000..27e8a3575 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql @@ -0,0 +1,11 @@ +SELECT + sbcustcountry AS country, + 100 * ( + COALESCE(SUM(sbcuststatus = 'active'), 0) / COUNT(*) + ) AS ar +FROM MAIN.SBCUSTOMER +WHERE + 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 new file mode 100644 index 000000000..f2dbb53c9 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -0,0 +1,24 @@ +WITH "_S1" AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + SUM(sbtxtax + sbtxcommission) AS SUM_EXPR, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -1) + AND sbtxtype = 'sell' + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + ( + 100.0 * ( + COALESCE("_S1".SUM_SBTXAMOUNT, 0) - COALESCE("_S1".SUM_EXPR, 0) + ) + ) / NULLIF("_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..73659f88e --- /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, + COALESCE("_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..fc718c212 --- /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(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(10, 'day'), 'DD') + AND sbtxtype = 'buy' + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + COALESCE("_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..9d6861271 --- /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 * COALESCE("_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..e082d47ff --- /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..520322238 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql @@ -0,0 +1,60 @@ +WITH "_S0" AS ( + SELECT + 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, + MAX(sbdphigh) AS MAX_SBDPHIGH, + MIN(sbdplow) AS MIN_SBDPLOW, + SUM(sbdpclose) AS SUM_SBDPCLOSE + FROM MAIN.SBDAILYPRICE + GROUP BY + 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 ( + 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) + ) / 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 new file mode 100644 index 000000000..688af7536 --- /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, + 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 new file mode 100644 index 000000000..702fe0f43 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -0,0 +1,74 @@ +WITH "_S2" AS ( + SELECT + 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 + WHERE + sbcustjoindate < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND sbcustjoindate >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'MONTH') + GROUP BY + 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 + 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, + '' + ) AS MONTH, + AVG(SBTRANSACTION.sbtxamount) AS AVG_SBTXAMOUNT + FROM MAIN.SBCUSTOMER SBCUSTOMER + JOIN MAIN.SBTRANSACTION SBTRANSACTION + 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(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'MONTH') + GROUP BY + 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, + '' + ) +) +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..df89f9c3f --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql @@ -0,0 +1,22 @@ +SELECT + NULLIF(COUNT(*), 0) AS n_transactions, + 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( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) + AND SBTRANSACTION.sbtxdatetime >= ( + 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 new file mode 100644 index 000000000..61543341f --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql @@ -0,0 +1,42 @@ +SELECT + 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(( + MOD(( + TO_CHAR(SBTRANSACTION.sbtxdatetime, 'D') + 5 + ), 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( + SYS_EXTRACT_UTC(SYSTIMESTAMP) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) + AND SBTRANSACTION.sbtxdatetime >= ( + 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) - MOD(( + TO_CHAR(CAST(SBTRANSACTION.sbtxdatetime AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) 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 new file mode 100644 index 000000000..ddd74032e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql @@ -0,0 +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 +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_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql new file mode 100644 index 000000000..cfbf91605 --- /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(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(30, 'day'), 'DD') + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustcountry AS country, + 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 +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..1ea7dea87 --- /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, + 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 +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..d301c4449 --- /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_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 new file mode 100644 index 000000000..70cf23747 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..fcbc32619 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql @@ -0,0 +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 +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_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_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 new file mode 100644 index 000000000..dbffc9064 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql @@ -0,0 +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 +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_broker_gen1_oracle.sql b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql new file mode 100644 index 000000000..6d5cbd5a6 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql @@ -0,0 +1,10 @@ +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 + ( + 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 new file mode 100644 index 000000000..1d1b396a6 --- /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(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(70, 'day'), 'DD') 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..f9e3d8d2d --- /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, + ( + ( + CAST("_S1".MIN_SBTXDATETIME AS DATE) - CAST(SBCUSTOMER.sbcustjoindate AS DATE) + ) * 86400 + ) / 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..8b1fb08fe --- /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(CAST(sbtxdatetime AS DATE) AS DATE), 'DD') = TO_DATE('2023-04-01', 'YYYY-MM-DD') + AND sbtxtype = 'sell' + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS "_id", + SBCUSTOMER.sbcustname AS name, + COALESCE("_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..694a27f2e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql @@ -0,0 +1,12 @@ +SELECT + TRUNC(CAST(sbtxdatetime AS DATE), 'MONTH') AS month, + AVG(sbtxprice) AS avg_price +FROM MAIN.SBTRANSACTION +WHERE + 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 DATE), '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..566612f27 --- /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( + 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_adv11_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql new file mode 100644 index 000000000..754884217 --- /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 DATE)) = 2023 + GROUP BY + car_id +) +SELECT + ( + ( + 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 + 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..51a389dea --- /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_adv13_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql new file mode 100644 index 000000000..2cc6a7e96 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv13_oracle.sql @@ -0,0 +1,38 @@ +WITH "_S1" AS ( + SELECT + 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 DATE), 'MONTH') +), "_T0" AS ( + SELECT + 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), + (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, MONTHS.N || ' months') + GROUP BY + DATETIME("_S1".START_MONTH, MONTHS.N || ' 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" +ORDER BY + 1 NULLS FIRST 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..9630ed94d --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS TSC +FROM MAIN.SALES +WHERE + ( + 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_adv15_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql new file mode 100644 index 000000000..1af15049a --- /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..ddbb439ad --- /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, + COALESCE("_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..80c7273d0 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -0,0 +1,55 @@ +SELECT + 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( + ( + MOD(( + TO_CHAR(PAYMENTS_RECEIVED.payment_date, 'D') + 5 + ), 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 + FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE), 'D') + 5 + ), 7) + ) + ) / 7 + ) <= 8 + AND FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE), 'D') + 5 + ), 7) + ) + ) / 7 + ) >= 1 +GROUP BY + 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 new file mode 100644 index 000000000..c9ee54ad4 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql @@ -0,0 +1,23 @@ +WITH "_S1" AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS + FROM MAIN.SALES + WHERE + ( + 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 +) +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..f7886bed4 --- /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, + COALESCE(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..6f5ad39ef --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql @@ -0,0 +1,11 @@ +SELECT + COUNT(*) AS num_sales, + 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 >= ( + 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 new file mode 100644 index 000000000..387400d35 --- /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, + COALESCE("_S1".SUM_SALE_PRICE, 0) AS total_sales, + "_S1".N_ROWS AS num_sales, + 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 +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..db2736f0c --- /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..c9b4087aa --- /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_adv8_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql new file mode 100644 index 000000000..067859a59 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv8_oracle.sql @@ -0,0 +1,28 @@ +WITH "_S3" AS ( + SELECT + TRUNC(CAST(SALES.sale_date AS DATE), 'MONTH') AS SALE_MONTH, + COUNT(*) AS N_ROWS, + SUM(SALES.sale_price) AS SUM_SALE_PRICE + 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 + TRUNC(CAST(SALES.sale_date AS DATE), 'MONTH') +) +SELECT + 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 + TRUNC(CAST(MONTHS_RANGE.DT AS DATE), 'MONTH') NULLS FIRST 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 new file mode 100644 index 000000000..27040b869 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql @@ -0,0 +1,6 @@ +SELECT + AVG(sale_price) AS ASP +FROM MAIN.SALES +WHERE + 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 new file mode 100644 index 000000000..2118a6099 --- /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 >= ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -3) + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + 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 +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY 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 new file mode 100644 index 000000000..e81d1523f --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..0226adadc --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..765d7a83c --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..deb8447da --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql @@ -0,0 +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 +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_dealership_basic5_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql new file mode 100644 index 000000000..b21122f4e --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql @@ -0,0 +1,24 @@ +WITH "_S1" AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + ( + 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 +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + "_S1".N_ROWS AS total_sales, + COALESCE("_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..e571e96ca --- /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, + COALESCE(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..9bb734c78 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql @@ -0,0 +1,10 @@ +SELECT + payment_method, + COUNT(*) AS total_payments, + COALESCE(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..5d99b226b --- /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, + 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 +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..cabb783ea --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql @@ -0,0 +1,11 @@ +SELECT + first_name, + last_name, + phone, + 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 +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..488d5af69 --- /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(( + TO_CHAR(payment_date, 'D') + 5 + ), 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..1e118cc68 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql @@ -0,0 +1,25 @@ +SELECT + payment_date, + payment_method, + COALESCE(SUM(payment_amount), 0) AS total_amount +FROM MAIN.PAYMENTS_RECEIVED +WHERE + FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(SYS_EXTRACT_UTC(SYSTIMESTAMP) AS DATE), 'D') + 5 + ), 7) + ) + ) / 7 + ) = 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..d98130421 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -0,0 +1,33 @@ +WITH "_S0" AS ( + SELECT + 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(CAST(sale_date AS DATE) AS DATE), 'Q'), + 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..815788cfa --- /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 DATE)) = 3 + AND EXTRACT(YEAR FROM CAST(snapshot_date AS DATE)) = 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..f277dc356 --- /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 DATE), 'MONTH') = TRUNC(CAST(TREATMENTS.start_dt AS DATE), '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_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 new file mode 100644 index 000000000..4ea39b25b --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -0,0 +1,36 @@ +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( + tot_drug_amt / CASE + WHEN ( + TRUNC(CAST(CAST(end_dt AS DATE) AS DATE), 'DD') - TRUNC(CAST(CAST(start_dt AS DATE) AS DATE), 'DD') + ) <> 0 + 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 + 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 +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_adv16_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql new file mode 100644 index 000000000..cf736ba1f --- /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) + ) / NULLIF(AVG(day7_pasi_score), 0) + ) * 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_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 new file mode 100644 index 000000000..046397694 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..8880cb617 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql @@ -0,0 +1,39 @@ +WITH "_u_0" AS ( + SELECT + 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 + 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 + WHERE + NOT "_u_0"."_u_1" IS NULL + 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 VARCHAR2(4000)) AS year, + N_ROWS AS number_of_new_patients, + CASE + WHEN ( + N_ROWS - COALESCE(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + ) <> 0 + THEN N_ROWS - COALESCE(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..46c7b7aca --- /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..517536534 --- /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(SYS_EXTRACT_UTC(SYSTIMESTAMP), '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 new file mode 100644 index 000000000..143da8c87 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -0,0 +1,26 @@ +WITH "_T0" AS ( + SELECT + 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 + 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') +) +SELECT + 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 +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..c03025e5f --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -0,0 +1,68 @@ +WITH "_S2" AS ( + SELECT + 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 + WHERE + start_dt < TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH') + AND start_dt >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -3) + GROUP BY + 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 + 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 + JOIN MAIN.DRUGS DRUGS + 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 >= ADD_MONTHS(TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'MONTH'), -3) + GROUP BY + 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 + "_S2".TREATMENT_MONTH AS month, + "_S2".NDISTINCT_PATIENT_ID AS patient_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 +ORDER BY + 1 DESC NULLS LAST 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 new file mode 100644 index 000000000..9ed9076d2 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql @@ -0,0 +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 +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_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql new file mode 100644 index 000000000..6ee8534ea --- /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(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DD') + 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, + COALESCE(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_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 new file mode 100644 index 000000000..0c6016235 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql @@ -0,0 +1,79 @@ +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 DATE)) = 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 +), "_u_0" AS ( + SELECT + TREATMENT_ID AS "_u_1" + FROM "_T3" + GROUP BY + TREATMENT_ID +), "_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" + 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, + 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" + 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 +) +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..ba66491d8 --- /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, + 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" + 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..8268f4b01 --- /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_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 new file mode 100644 index 000000000..e14d6a2a5 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..5c2425013 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql @@ -0,0 +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 +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_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_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 new file mode 100644 index 000000000..5dfffa6c4 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql @@ -0,0 +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 +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_dermtreatment_gen1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql new file mode 100644 index 000000000..804754c54 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql @@ -0,0 +1,11 @@ +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 ( + 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_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql new file mode 100644 index 000000000..c43c42ec6 --- /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 CAST(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -24) AS DATE)) 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..5d476b173 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql @@ -0,0 +1,7 @@ +SELECT + 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 new file mode 100644 index 000000000..c63b88eda --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql @@ -0,0 +1,17 @@ +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 ( + 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 +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..6707dc193 --- /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(ADD_MONTHS(SYS_EXTRACT_UTC(SYSTIMESTAMP), -6), 'DD') 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_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 c90e2ef50..4ad794e0a 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 ewallet.users AS users JOIN ewallet.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 new file mode 100644 index 000000000..bbfc650e3 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql @@ -0,0 +1,16 @@ +SELECT + USER_SESSIONS.user_id AS uid, + SUM( + ( + 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 < 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 + 2 DESC NULLS LAST 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 8929c6899..ef986a644 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 ewallet.users AS users JOIN ewallet.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 new file mode 100644 index 000000000..89cf77714 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUPONS.cid AS coupon_id, + 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 +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..1e8417ea8 --- /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(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_adv14_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql new file mode 100644 index 000000000..869fb10c4 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql @@ -0,0 +1,11 @@ +SELECT + COALESCE(SUM(status = 'success'), 0) / NULLIF(COUNT(*), 0) AS "_expr0" +FROM MAIN.WALLET_TRANSACTIONS_DAILY +WHERE + ( + ( + 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_adv15_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql new file mode 100644 index 000000000..2721473af --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql @@ -0,0 +1,27 @@ +WITH "_S3" AS ( + SELECT + COUPONS.merchant_id AS MERCHANT_ID, + COUNT(*) AS N_ROWS + FROM MAIN.COUPONS COUPONS + JOIN MAIN.MERCHANTS MERCHANTS + 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, + COALESCE("_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..0d2ca987c --- /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) / 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 + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + WALLET_TRANSACTIONS_DAILY.receiver_id 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 new file mode 100644 index 000000000..dac97790e --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql @@ -0,0 +1,38 @@ +SELECT + 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(( + 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) - MOD(( + TO_CHAR(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'D') + 5 + ), 7), + 'DD' + ) + AND NOTIFICATIONS.created_at >= ( + 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) - MOD(( + TO_CHAR(CAST(NOTIFICATIONS.created_at AS DATE), 'D') + 5 + ), 7) AS DATE), + 'DD' + ) 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_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..ce6911baa --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql @@ -0,0 +1,14 @@ +SELECT + COUNT(*) AS num_transactions, + CASE + WHEN COUNT(*) <> 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 + ( + 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 new file mode 100644 index 000000000..eaea85d51 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql @@ -0,0 +1,7 @@ +SELECT + AVG(balance) AS AMB +FROM MAIN.WALLET_USER_BALANCE_DAILY +WHERE + ( + 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_adv6_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql new file mode 100644 index 000000000..c68ff399e --- /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..1de2c9b86 --- /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..551e3fcdc --- /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, + 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 + 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..225ded5c7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql @@ -0,0 +1,10 @@ +SELECT + 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 >= 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_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql new file mode 100644 index 000000000..b70006ebc --- /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(SYS_EXTRACT_UTC(SYSTIMESTAMP) - NUMTODSINTERVAL(150, 'day'), 'DD') + AND receiver_type = 1 +) +SELECT + ANY_VALUE(MERCHANTS.name) AS merchant_name, + 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 +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..7b5b817b2 --- /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 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 + ON USERS.status = 'active' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + 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 + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATE), 'MONTH') 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 new file mode 100644 index 000000000..04ff871d4 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..ab9c12081 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..46556c698 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..6d65082a9 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql @@ -0,0 +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 +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_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..919f60a5a --- /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, + 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 +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..2b419d7b8 --- /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, + 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 +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..e98b8a4b5 --- /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(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS DATE) AS DATE), 'DD') = TRUNC(SYS_EXTRACT_UTC(SYSTIMESTAMP), 'DD') +) +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..4206306c5 --- /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 DATE)) = 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 DATE)) = 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..0a5c52c5a --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql @@ -0,0 +1,8 @@ +SELECT + device_type, + 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 new file mode 100644 index 000000000..920b63623 --- /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 <= ADD_MONTHS(CAST("_S4".ANYTHING_CREATED_AT AS DATE), 12) 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 new file mode 100644 index 000000000..860d41dff --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -0,0 +1,20 @@ +WITH "_u_0" AS ( + SELECT + NOTIFICATIONS.user_id AS "_u_1" + FROM MAIN.NOTIFICATIONS NOTIFICATIONS + JOIN MAIN.USERS USERS + 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 + NOTIFICATIONS.user_id +) +SELECT + USERS.username, + USERS.email, + USERS.created_at +FROM MAIN.USERS USERS +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_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..ecb606335 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql @@ -0,0 +1,3 @@ +SELECT + SUM(rating > 4.5) / NULLIF(COUNT(*), 0) AS ratio +FROM MAIN.RESTAURANT 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..145f7169e --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql @@ -0,0 +1,3 @@ +SELECT + 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 new file mode 100644 index 000000000..082b6d399 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql @@ -0,0 +1,5 @@ +SELECT + 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 new file mode 100644 index 000000000..442a90119 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql @@ -0,0 +1,8 @@ +SELECT + 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 new file mode 100644 index 000000000..575d4a461 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql @@ -0,0 +1,5 @@ +SELECT + 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_gen16_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql new file mode 100644 index 000000000..07da2b0a3 --- /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_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 new file mode 100644 index 000000000..63f68c3d5 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql @@ -0,0 +1,59 @@ +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 +), "_u_0" AS ( + SELECT + CITY_NAME AS "_u_1" + FROM "_S1" + GROUP BY + CITY_NAME +), "_S6" AS ( + SELECT DISTINCT + "_S0".REGION + FROM "_S0" "_S0" + 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, + 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" + 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 +) +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..d0bdf54fd --- /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..bb6f0c403 --- /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..bec2c68df --- /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(NOT RESTAURANT.rating IS NULL) 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/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/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/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql new file mode 100644 index 000000000..8bc2ed8e7 --- /dev/null +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -0,0 +1,136 @@ +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 + FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(ORDERS.o_orderdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ) AS ORD_WK, + COUNT(*) AS N_ROWS + FROM "_S0" "_S0" + JOIN TPCH.ORDERS ORDERS + ON FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(ORDERS.o_orderdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ) < 10 + AND ORDERS.o_orderpriority = '1-URGENT' + AND ORDERS.o_orderstatus = 'F' + GROUP BY + FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(ORDERS.o_orderdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ) +), "_S3" AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM "_T3" +), "_T0" AS ( + SELECT + FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ) 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 EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATE)) = 1992 + AND FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ) < 10 + AND LINEITEM.l_returnflag = 'R' + AND LINEITEM.l_shipmode = 'RAIL' + AND "_S2".ORD_WK = FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ) + GROUP BY + FLOOR( + ( + 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) + ) - ( + MOD(( + TO_CHAR(CAST(LINEITEM.l_receiptdate AS DATE), 'D') + -1 + ), 7) + ) + ) / 7 + ), + "_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..2982b9c1e --- /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 DATE)) AS YEAR_O_ORDERDATE, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(MONTH FROM CAST(o_orderdate AS DATE)), + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) +) +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..031b6c7f9 --- /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..4a0d4e730 --- /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 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 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 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 TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST("_S6".EV_DT AS TIMESTAMP)) +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..7916b3dc0 --- /dev/null +++ b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql @@ -0,0 +1,26 @@ +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, + 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)) + 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 DATE)) + AND ER_START_YEAR <= EXTRACT(YEAR FROM CAST(EV_DT AS DATE)) +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..b373e1ad2 --- /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 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 + 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..ea23ab825 --- /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 DATE)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) +) +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..e4e1ddc54 --- /dev/null +++ b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql @@ -0,0 +1,89 @@ +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 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 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 + "_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 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 + 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 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 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 * COALESCE("_S16".SUM_IS_INTRA_SEASON, 0) + ) / "_S16".N_ROWS, 2) AS pct_season_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 +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..538e49051 --- /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 TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) + 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..fb281fa9d --- /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_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 new file mode 100644 index 000000000..02afb1d37 --- /dev/null +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql @@ -0,0 +1,27 @@ +WITH "_S0" AS ( + SELECT + 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 +FROM "_S0" "_S0" +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)) +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/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..075eb0a4c --- /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..5d61e2b6c --- /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..409975580 --- /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 TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) + 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..e7d336788 --- /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 TIMESTAMP)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS TIMESTAMP)) + 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..907c19a30 --- /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 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 + 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..29b3ec33f --- /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 DATE)) <= 2019 + AND EXTRACT(YEAR FROM CAST(search_ts AS DATE)) >= 2010 + GROUP BY + search_engine +) +SELECT + "_S0".SEARCH_ENGINE AS engine, + COALESCE("_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..e9d96d9d1 --- /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 DATE)) + AND ERAS.er_name = 'Cold War' + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATE)) + 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..d599bd46c --- /dev/null +++ b/tests/test_sql_refsols/extract_colors_oracle.sql @@ -0,0 +1,114 @@ +SELECT + p_partkey AS key, + 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 +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..f23de7893 --- /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 DATE)) = 1 +) +SELECT + O_ORDERDATE AS order_date, + O_ORDERKEY AS key +FROM "_T" +WHERE + 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/first_order_per_customer_oracle.sql b/tests/test_sql_refsols/first_order_per_customer_oracle.sql new file mode 100644 index 000000000..f6b67b34f --- /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..60a8753cb --- /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/function_sampler_oracle.sql b/tests/test_sql_refsols/function_sampler_oracle.sql new file mode 100644 index 000000000..fe3d2cd63 --- /dev/null +++ b/tests/test_sql_refsols/function_sampler_oracle.sql @@ -0,0 +1,21 @@ +SELECT + 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 + 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_multiple_oracle.sql b/tests/test_sql_refsols/get_part_multiple_oracle.sql new file mode 100644 index 000000000..d175cdcbb --- /dev/null +++ b/tests/test_sql_refsols/get_part_multiple_oracle.sql @@ -0,0 +1,1023 @@ +SELECT + TRUNC(CAST(SUBSTR(sbcustid, 2) AS DOUBLE PRECISION), '0') AS "_expr0", + REGEXP_SUBSTR( + sbcustname, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + 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 ( + ( + 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 ( + ( + 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 ( + ( + 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 ( + ( + 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 ( + ( + 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, + '(.*?)(' || REGEXP_REPLACE('00', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + 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, + '(.*?)(' || REGEXP_REPLACE('00', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + 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 ( + ( + 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 ( + ( + 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, + '(.*?)(' || REGEXP_REPLACE('aa', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + 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 ( + ( + 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, + 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 ( + ( + 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, + '(.*?)(' || REGEXP_REPLACE(' ', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + WHEN ( + ( + LENGTH(sbcustname) - LENGTH(REPLACE(sbcustname, ' ')) + ) / LENGTH(' ') + ) >= 0 + THEN 1 + 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 + 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, + '(.*?)(' || 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 ( + ( + 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, + '(.*?)(' || REGEXP_REPLACE('0', '([][(){}.*+?^$|\#-])', '\\\1') || '|$)', + 1, + CASE + 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 + 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 new file mode 100644 index 000000000..7f1dee4ea --- /dev/null +++ b/tests/test_sql_refsols/get_part_single_oracle.sql @@ -0,0 +1,33 @@ +SELECT + 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/global_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..4928cd2c3 --- /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/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_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 new file mode 100644 index 000000000..9162d185a --- /dev/null +++ b/tests/test_sql_refsols/has_cross_correlated_singular_oracle.sql @@ -0,0 +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 +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/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 new file mode 100644 index 000000000..0ff41cdb0 --- /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 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 DATE)), + 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..4dcfc7b07 --- /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 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 DATE)) = 2023 +ORDER BY + 1 NULLS FIRST 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 new file mode 100644 index 000000000..6207119eb --- /dev/null +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql @@ -0,0 +1,12 @@ +SELECT + COALESCE("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_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 new file mode 100644 index 000000000..648838cd5 --- /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_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 new file mode 100644 index 000000000..8affdea49 --- /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_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 new file mode 100644 index 000000000..a8aa9e9fc --- /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, + COALESCE("_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_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 new file mode 100644 index 000000000..ff85e4c70 --- /dev/null +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql @@ -0,0 +1,12 @@ +SELECT + """," AS "dbl_quote_dot", + "." AS "dot", + "." + COALESCE("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_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 new file mode 100644 index 000000000..dcd4c1e88 --- /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_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/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..684779a0b --- /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..9bb8020d2 --- /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/menu_5556_oracle.sql b/tests/test_sql_refsols/menu_5556_oracle.sql new file mode 100644 index 000000000..7f2d4edbb --- /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/month_year_sliding_windows_oracle.sql b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql new file mode 100644 index 000000000..71f7f1ce5 --- /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 DATE)) AS YEAR_O_ORDERDATE, + SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM "_T7" + GROUP BY + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATE)) +), "_T4" AS ( + SELECT + SUM_O_TOTALPRICE, + YEAR_O_ORDERDATE, + 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 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 DATE)) + WHERE + "_T4".NEXT_YEAR_TOTAL_SPENT < COALESCE("_T4".SUM_O_TOTALPRICE, 0) + GROUP BY + 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(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 + YEAR_O_ORDERDATE AS year, + MONTH_O_ORDERDATE AS month +FROM "_T" +WHERE + "_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/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 new file mode 100644 index 000000000..d0adcdd69 --- /dev/null +++ b/tests/test_sql_refsols/movielens_2274_oracle.sql @@ -0,0 +1,22 @@ +WITH "_u_0" AS ( + SELECT + userid AS "_u_1" + FROM MAIN.U2BASE + WHERE + rating = 2 + GROUP BY + userid +) +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 +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/n_orders_first_day_oracle.sql b/tests/test_sql_refsols/n_orders_first_day_oracle.sql new file mode 100644 index 000000000..116e642b0 --- /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..ff3dab5ad --- /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..c6bb69c59 --- /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 DATE)) = 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/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/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..fda280f63 --- /dev/null +++ b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql @@ -0,0 +1,12 @@ +SELECT + AVG( + 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 + 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..61bb07464 --- /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 DATE)) = 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_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 new file mode 100644 index 000000000..9844cef4f --- /dev/null +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -0,0 +1,36 @@ +SELECT + o_orderdate AS order_date, + 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 TO_DATE('1995-01-01', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2000-01-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) + ) * 4 + ( + 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 +FROM TPCH.ORDERS +WHERE + 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/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 new file mode 100644 index 000000000..073c7a449 --- /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, + 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 +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..b5036247b --- /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, + COALESCE(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..868cf7abe --- /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 DATE)) = 2023 +), "_S1" AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS DATE), 'MONTH') AS MONTH + FROM "_T2" +), "_S3" AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS DATE), '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 DATE)) = 2023 + AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), '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(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" + 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..6a9bb0dee --- /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 DATE)) = 2023 +), "_S1" AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS DATE), 'MONTH') AS MONTH + FROM "_T2" +), "_S3" AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS DATE), '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 DATE)) = 2023 + AND "_S3".MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS DATE), '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(COALESCE("_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_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 new file mode 100644 index 000000000..bd9e8d9bb --- /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 + 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, + 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:MIAM') 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/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/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..4f946c5df --- /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 DATE)) = 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, + 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 DATE)) = 1996 + AND ORDERS.o_orderkey = "_T6".L_ORDERKEY +GROUP BY + "_T6".L_PARTKEY +ORDER BY + 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/percentile_customers_per_region_oracle.sql b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql new file mode 100644 index 000000000..239e53a08 --- /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..a999a326e --- /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 DATE)) = 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..e234b9091 --- /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 DATE)) = 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..e234b9091 --- /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 DATE)) = 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..84a3f2f3c --- /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..a999a326e --- /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 DATE)) = 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..e234b9091 --- /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 DATE)) = 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..b9a002183 --- /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(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 + AND "_S3".CA_DT = TRUNC(CAST(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') + GROUP BY + "_S3".CA_DT +), "_S22" AS ( + SELECT + 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(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 + GROUP BY + TRUNC(CAST(CAST("_S1".CA_DT AS DATE) AS DATE), 'Q') +), "_S13" AS ( + SELECT DISTINCT + TRUNC(CAST(CAST("_S11".CA_DT AS DATE) AS DATE), 'Q') AS QUARTER + FROM "_T2" "_T10" + JOIN "_S1" "_S11" + 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(ADD_MONTHS(CAST("_T11".PR_RELEASE AS DATE), 24), 'Q') + 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(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(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 + PRODUCTS.pr_name = 'RubyCopper-Star' + GROUP BY + "_S13".QUARTER +) +SELECT + "_S22".QUARTER AS quarter, + COALESCE("_S23".NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + COALESCE("_S22".SUM_N_ROWS, 0) AS n_sold, + ROUND( + 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" +LEFT JOIN "_S23" "_S23" + ON "_S22".QUARTER = "_S23".QUARTER +ORDER BY + 1 NULLS FIRST 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 new file mode 100644 index 000000000..ba224a5e3 --- /dev/null +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -0,0 +1,154 @@ +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, + 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, + 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, + 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, + ( + EXTRACT(YEAR FROM TO_DATE('2023-04-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2023-07-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2023-10-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2023-12-31', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2024-01-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2024-04-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2024-04-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2022-10-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2025-01-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2020-01-01', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2023-01-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-04-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2023-01-15', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2024-01-15', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2023-04-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-03-31', 'YYYY-MM-DD')) + ) * 4 + ( + 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 TO_DATE('2024-01-01', 'YYYY-MM-DD')) - EXTRACT(YEAR FROM TO_DATE('2023-12-31', 'YYYY-MM-DD')) + ) * 4 + ( + 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_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_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 new file mode 100644 index 000000000..c02cb1415 --- /dev/null +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql @@ -0,0 +1,17 @@ +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, NATION.n_name) AS rank +FROM TPCH.NATION NATION +JOIN "_S1" "_S1" + ON NATION.n_nationkey = "_S1".C_NATIONKEY +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/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..f119c68fd --- /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..f119c68fd --- /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..46a40cb73 --- /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/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_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 new file mode 100644 index 000000000..28f2159b4 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_not_on_singular_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..2727bab70 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_on_plural_lineitems_oracle.sql @@ -0,0 +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 +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 new file mode 100644 index 000000000..14ff43049 --- /dev/null +++ b/tests/test_sql_refsols/redundant_has_on_plural_oracle.sql @@ -0,0 +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 +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/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_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..e664803e5 --- /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_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/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..cde94b2e9 --- /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, + COALESCE("_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..7188b31dd --- /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 DATE)) = 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 DATE)) = 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..a6bb8b585 --- /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..03bd1de47 --- /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..29c6d2b5a --- /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_10_oracle.sql b/tests/test_sql_refsols/simple_cross_10_oracle.sql new file mode 100644 index 000000000..c52cf5d4b --- /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, + COALESCE("_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 new file mode 100644 index 000000000..bcff0304d --- /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..b2f248ad4 --- /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..73e3b545d --- /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_14_oracle.sql b/tests/test_sql_refsols/simple_cross_14_oracle.sql new file mode 100644 index 000000000..1d8cb983f --- /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, + COALESCE("_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_15_oracle.sql b/tests/test_sql_refsols/simple_cross_15_oracle.sql new file mode 100644 index 000000000..15bea6351 --- /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..2ef37b6cb --- /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..7177e4a39 --- /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..a12207aec --- /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..a383093a1 --- /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 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 + 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_4_oracle.sql b/tests/test_sql_refsols/simple_cross_4_oracle.sql new file mode 100644 index 000000000..5142d3964 --- /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, + COALESCE("_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 new file mode 100644 index 000000000..8ea9255bd --- /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 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 + 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 COALESCE(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 COALESCE(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..a3ab17391 --- /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..c1c93cb24 --- /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, + COALESCE("_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..006915d21 --- /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 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 +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..eb6916e36 --- /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_dataframe_collection_1_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql new file mode 100644 index 000000000..677068528 --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_1_oracle.sql @@ -0,0 +1,12 @@ +SELECT + RAINBOW.IDX AS idx, + RAINBOW.COLOR 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..921c1a653 --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_2_oracle.sql @@ -0,0 +1,8 @@ +SELECT + USERS.SIGNUP_DATE AS signup_date, + USERS.USER_ID AS user_id +FROM (VALUES + (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 new file mode 100644 index 000000000..9e681da2b --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + USERS.USER_ID AS user_id, + 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") 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/simple_dataframe_collection_4_oracle.sql b/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql new file mode 100644 index 000000000..746b2bde3 --- /dev/null +++ b/tests/test_sql_refsols/simple_dataframe_collection_4_oracle.sql @@ -0,0 +1,8 @@ +SELECT + USERS.USER_ID AS user_id, + USERS.COUNTRY 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_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..bb3b363f4 --- /dev/null +++ b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql @@ -0,0 +1,25 @@ +SELECT + 1 AS i1, + 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, + 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 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_range_1_oracle.sql b/tests/test_sql_refsols/simple_range_1_oracle.sql new file mode 100644 index 000000000..5665bd48b --- /dev/null +++ b/tests/test_sql_refsols/simple_range_1_oracle.sql @@ -0,0 +1,13 @@ +SELECT + SIMPLE_RANGE.VALUE 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..42d0ff393 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_2_oracle.sql @@ -0,0 +1,15 @@ +SELECT + SIMPLE_RANGE.VALUE 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..fa0dccb2c --- /dev/null +++ b/tests/test_sql_refsols/simple_range_3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + T1.FOO 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..12be18be2 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_4_oracle.sql @@ -0,0 +1,15 @@ +SELECT + T2.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_range_6_oracle.sql b/tests/test_sql_refsols/simple_range_6_oracle.sql new file mode 100644 index 000000000..1bc801a2c --- /dev/null +++ b/tests/test_sql_refsols/simple_range_6_oracle.sql @@ -0,0 +1,45 @@ +SELECT + TRUNC(CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS DOUBLE PRECISION), '0') 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 + TRUNC(CAST(SUBSTR(CAST(TBL.V AS VARCHAR2(4000)), 1, 1) AS DOUBLE PRECISION), '0') 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..c738d93f8 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_7_oracle.sql @@ -0,0 +1,20 @@ +SELECT + D1.X + D2.Y AS s, + COUNT(*) AS n, + AVG(CAST(D1.X * D2.Y 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 + 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 new file mode 100644 index 000000000..8f6bf1c02 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_8_oracle.sql @@ -0,0 +1,25 @@ +SELECT + ( + D1.X + D2.Y + ) + D3.Z AS s, + COUNT(*) AS n, + AVG(D1.X * D2.Y * D3.Z) 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 + ( + 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 new file mode 100644 index 000000000..ee28f1d4e --- /dev/null +++ b/tests/test_sql_refsols/simple_range_9_oracle.sql @@ -0,0 +1,8 @@ +SELECT + "quoted-name"."name space" +FROM (VALUES + (0), + (1), + (2), + (3), + (4)) AS "quoted-name"("name space") 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..7f73c9188 --- /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( + 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(NVL(NULL, CHR(0)), '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( + 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(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 new file mode 100644 index 000000000..f5a6ebd85 --- /dev/null +++ b/tests/test_sql_refsols/simple_var_std_oracle.sql @@ -0,0 +1,23 @@ +SELECT + ANY_VALUE(NATION.n_name) AS name, + VAR_POP(SUPPLIER.s_acctbal) AS var, + STDDEV_POP(SUPPLIER.s_acctbal) AS std, + 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 + 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..315959fff --- /dev/null +++ b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql @@ -0,0 +1,40 @@ +SELECT + 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 +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..295d976e7 --- /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(COALESCE(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..b4df6c451 --- /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, + 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 new file mode 100644 index 000000000..3da3a6bb4 --- /dev/null +++ b/tests/test_sql_refsols/simplification_3_oracle.sql @@ -0,0 +1,99 @@ +WITH "_T2" AS ( + SELECT + ABS(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0')) AS EXPR_13, + ROW_NUMBER() OVER (ORDER BY sbcustname) AS RANK, + AVG( + CAST(ABS(COALESCE(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0'), 0)) AS DOUBLE PRECISION) + ) OVER () AS RAVG1, + COALESCE( + 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(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0')) OVER () AS RCNT1, + COALESCE( + 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, + COALESCE( + COUNT(*) OVER (ORDER BY sbcustname ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING), + 0.1 + ) AS RSIZ2, + SUM(ABS(COALESCE(TRUNC(CAST(sbcustpostalcode AS DOUBLE PRECISION), '0'), 0))) OVER () AS RSUM1, + COALESCE( + 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 +), "_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..d5f7d3c97 --- /dev/null +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -0,0 +1,124 @@ +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" + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) = 2023 +) +SELECT + SBTXDATETIME AS date_time, + 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, + 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 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 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 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 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 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, + 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..ea9d1ce08 --- /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..f86a27fa3 --- /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..aeba1984f --- /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..a6f6d10f4 --- /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 + COALESCE("_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..933f4d53a --- /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..207c4b677 --- /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..9c3793635 --- /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 DATE)) = 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 COALESCE(COUNT_L_SUPPKEY, 0) DESC, ANYTHING_P_NAME) AS "_W" + FROM "_T4" +), "_S5" AS ( + SELECT + COALESCE(COUNT_L_SUPPKEY, 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_a_oracle.sql b/tests/test_sql_refsols/smoke_a_oracle.sql new file mode 100644 index 000000000..e6450edfe --- /dev/null +++ b/tests/test_sql_refsols/smoke_a_oracle.sql @@ -0,0 +1,97 @@ +SELECT + p_partkey AS key, + 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, + CASE + WHEN ABS(-2) > LENGTH(p_brand) + THEN LENGTH(p_brand) + -1 + ELSE GREATEST(1, 0) + END + ), + '' + ) AS DOUBLE PRECISION), + '0' + ) AS a, + UPPER( + LEAST( + 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, + 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) + ELSE SUBSTR(CONCAT('000', CAST(p_size AS VARCHAR2(4000))), -3) + END AS d, + 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 + WHEN LENGTH('o') IS NULL OR LENGTH(p_name) IS NULL + THEN 0 + ELSE CAST(( + LENGTH(p_name) - NVL(LENGTH(REPLACE(p_name, 'o', '')), 0) + ) / LENGTH('o') AS INT) + END + ( + ( + INSTR(p_name, 'o') - 1 + ) / 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_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql new file mode 100644 index 000000000..378b58d1b --- /dev/null +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -0,0 +1,89 @@ +SELECT + o_orderkey AS key, + 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, + 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 TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) + ) * 4 + ( + 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 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 TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS')) + ) AS k, + FLOOR( + ( + 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 + ), 7) + ) + ) / 7 + ) AS l, + 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(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(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) - TO_DATE('1993-05-25 12:45:36', 'YYYY-MM-DD HH24:MI:SS') + ) * 86400 AS p, + 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%' +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY 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 new file mode 100644 index 000000000..421ef44ff --- /dev/null +++ b/tests/test_sql_refsols/smoke_c_oracle.sql @@ -0,0 +1,59 @@ +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, + 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, + 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(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( + 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, + MAX(EXPR_30) AS q, + AVG(EXPR_31) AS r +FROM "_T1" 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..cffb7e85e --- /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, 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, + 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..8eeca96d1 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 1 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..a38426a61 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 1 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..f3c95a383 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 5 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..3c96ada60 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 5 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..fa14f366d --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 0 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..4d9044590 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 0 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..dc0d15ecf --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + -1 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..cdee8eab9 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + -1 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..5c4286e28 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 2 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..96fff6197 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 2 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..4cfd9c09a --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 4 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..6c9d16123 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 4 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..f92743508 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql @@ -0,0 +1,33 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 3 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..9149b4532 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql @@ -0,0 +1,31 @@ +SELECT + sbtxdatetime AS date_time, + 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' + WHEN TO_CHAR(sbtxdatetime, 'D') = 2 + THEN 'Monday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 3 + THEN 'Tuesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 4 + THEN 'Wednesday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 5 + THEN 'Thursday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 6 + THEN 'Friday' + WHEN TO_CHAR(sbtxdatetime, 'D') = 7 + THEN 'Saturday' + END AS dayname, + MOD(( + TO_CHAR(sbtxdatetime, 'D') + 3 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + 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 new file mode 100644 index 000000000..d924b9f85 --- /dev/null +++ b/tests/test_sql_refsols/string_format_specifiers_oracle.sql @@ -0,0 +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'), '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 new file mode 100644 index 000000000..7fb1d2d52 --- /dev/null +++ b/tests/test_sql_refsols/string_functions_oracle.sql @@ -0,0 +1,32 @@ +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, + 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, + 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') IS NULL OR LENGTH(CUSTOMER.c_name) IS NULL + THEN 0 + ELSE CAST(( + 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') - 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/supplier_best_part_oracle.sql b/tests/test_sql_refsols/supplier_best_part_oracle.sql new file mode 100644 index 000000000..e4aa338d3 --- /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 DATE)) = 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 COALESCE("_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, + COALESCE("_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..7f4286672 --- /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 DATE)) < 7 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)) = 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, + COALESCE(SUM_L_QUANTITY, 0) AS supplier_quantity, + ( + 100.0 * COALESCE(SUM_L_QUANTITY, 0) + ) / CASE + 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" +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..f9c6f0689 --- /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(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 +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..39824a9b5 --- /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..92a6af6a4 --- /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(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" + 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..50c3c7c31 --- /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(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 +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..c100f405b --- /dev/null +++ b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql @@ -0,0 +1,25 @@ +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 * 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 +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..2329068c1 --- /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 + COALESCE(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(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 +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..c6d1a9a99 --- /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..40c14ff5d --- /dev/null +++ b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql @@ -0,0 +1,19 @@ +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 < ( + CAST(CALENDAR.ca_dt AS DATE) + NUMTODSINTERVAL(5, 'day') + ) +JOIN MAIN.DEVICES DEVICES + 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 + 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..3f7c82d76 --- /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 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 DATE)) +), "_S7" AS ( + SELECT + EXTRACT(YEAR FROM CAST("_S3".PR_RELEASE AS DATE)) 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 DATE)) +) +SELECT + "_S6".YEAR_PR_RELEASE AS year, + 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 +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..f538b51e1 --- /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(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 +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..76e32ed07 --- /dev/null +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -0,0 +1,69 @@ +WITH "_T2" AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR + WHERE + EXTRACT(YEAR FROM CAST(ca_dt AS DATE)) 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 >= ADD_MONTHS(CAST("_T4".CA_DT AS DATE), -6) + JOIN MAIN.DEVICES DEVICES + 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 + "_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(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" + 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 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" + 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 DATE)), + EXTRACT(YEAR FROM CAST("_T2".CA_DT AS DATE)) +) +SELECT + 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) + ) / 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 new file mode 100644 index 000000000..32cef5abb --- /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(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 +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..82f42d1c0 --- /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(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" + 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(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') + 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 DATE)) 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 DATE)) +) +SELECT + "_S15".YEAR_CA_DT - EXTRACT(YEAR FROM CAST("_S14".ANYTHING_PR_RELEASE AS DATE)) AS years_since_release, + ROUND( + 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 * ( + COALESCE("_S15".SUM_N_ROWS, 0) - LAG(COALESCE("_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 * ( + COALESCE("_S15".SUM_EXPR_4, 0) - LAG(COALESCE("_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, + 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 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 new file mode 100644 index 000000000..9a9d71be2 --- /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(CAST(DEVICES.de_purchase_ts AS DATE) AS DATE), 'DD') + 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(CAST(INCIDENTS.in_error_report_ts AS DATE) AS DATE), 'DD') + GROUP BY + "_S4".CA_DT +), "_T1" AS ( + SELECT + 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" + 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 DATE)) +) +SELECT + YEAR_CA_DT AS yr, + ROUND( + 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( + ( + 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 * ( + COALESCE(SUM_N_ROWS, 0) - LAG(COALESCE(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, + COALESCE(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..b204f6a36 --- /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(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(CAST(SBTXDATETIME AS DATE) AS DATE), 'DD') 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..19e55025a --- /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, + COALESCE("_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..b76487781 --- /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..c5ac68ac1 --- /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..be6b050bf --- /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 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, + 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, + 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..eeacda21b --- /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, + COALESCE("_S9".SUM_EXPR, 0) AS VALUE +FROM "_S8" "_S8" +JOIN "_S9" "_S9" + ON ( + 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 new file mode 100644 index 000000000..b09952c84 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q12_oracle.sql @@ -0,0 +1,18 @@ +SELECT + LINEITEM.l_shipmode AS L_SHIPMODE, + 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 DATE)) = 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..a0eeea26c --- /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 + 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 + COALESCE("_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..72354ac01 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q14_oracle.sql @@ -0,0 +1,23 @@ +SELECT + ( + 100.0 * COALESCE( + SUM( + CASE + WHEN PART.p_type LIKE 'PROMO%' + THEN LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) + ELSE 0 + END + ), + 0 + ) + ) / 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 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 new file mode 100644 index 000000000..7ce7b99b3 --- /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(COALESCE(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, + 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 = COALESCE("_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..c42913705 --- /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 + COALESCE(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..cadd65a24 --- /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..cc0c13dfd --- /dev/null +++ b/tests/test_sql_refsols/tpch_q19_oracle.sql @@ -0,0 +1,36 @@ +SELECT + COALESCE(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..6f0434e3f --- /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, + 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, + COALESCE(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..cc634b80b --- /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 DATE)) = 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 * COALESCE("_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_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 new file mode 100644 index 000000000..e494d1ca8 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q21_oracle.sql @@ -0,0 +1,63 @@ +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 +), "_u_0" AS ( + SELECT + "_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' AND "_u_0"."_u_1" IS NULL +) +SELECT + ANY_VALUE(SUPPLIER.s_name) AS S_NAME, + 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 +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_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 new file mode 100644 index 000000000..9a2d9c134 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q22_oracle.sql @@ -0,0 +1,30 @@ +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') +), "_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, + COUNT(*) AS NUM_CUSTS, + COALESCE(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') +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 + 1 NULLS FIRST 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..41d3c710e --- /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..94a028a62 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q3_oracle.sql @@ -0,0 +1,24 @@ +SELECT + LINEITEM.l_orderkey AS L_ORDERKEY, + COALESCE(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_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 new file mode 100644 index 000000000..3fc76856a --- /dev/null +++ b/tests/test_sql_refsols/tpch_q4_oracle.sql @@ -0,0 +1,23 @@ +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 +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 + 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..79da8572b --- /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, + COALESCE(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..0c47af730 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + COALESCE(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..f7bcb74f7 --- /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 DATE)) AS L_YEAR, + COALESCE(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 DATE)) IN (1995, 1996) +GROUP BY + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATE)), + "_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..6902a4f52 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q8_oracle.sql @@ -0,0 +1,34 @@ +SELECT + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)) AS O_YEAR, + COALESCE( + SUM( + CASE + WHEN NATION_2.n_name = 'BRAZIL' + THEN LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) + ELSE 0 + END + ), + 0 + ) / 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 DATE)) 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 DATE)) 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..1950b391a --- /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 DATE)) AS O_YEAR, + COALESCE( + 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 DATE)), + 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..037dd6415 --- /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 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 + 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 DATE)) = 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/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 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..b444e8e30 --- /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 + SIZES.PART_SIZE AS part_size, + COALESCE("_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 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 new file mode 100644 index 000000000..0502eec48 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -0,0 +1,550 @@ +WITH "_S3" AS ( + SELECT + 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), + (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_2.X AS VARCHAR2(4000))) + OR CAST(B.Y AS VARCHAR2(4000)) LIKE CONCAT(CAST(A_2.X AS VARCHAR2(4000)), '%') + GROUP BY + A_2.X +) +SELECT + A.X 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 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 new file mode 100644 index 000000000..9664fe4eb --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -0,0 +1,1045 @@ +WITH "_S5" AS ( + SELECT + 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), + (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_2(Y) + ON CAST(B_2.Y AS VARCHAR2(4000)) LIKE CONCAT('%', CAST(A_2.X AS VARCHAR2(4000))) + GROUP BY + A_2.X +) +SELECT + A.X 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 (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 A.X = "_S5".X +GROUP BY + 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 new file mode 100644 index 000000000..797b0d4f5 --- /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, + SIZES.PART_SIZE, + ROW_NUMBER() OVER (PARTITION BY SIZES.PART_SIZE 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 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 + 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..fb0facca4 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -0,0 +1,44 @@ +WITH "_S3" AS ( + SELECT + SIZES_2.PART_SIZE, + COUNT(*) AS N_ROWS + FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56)) AS SIZES_2(PART_SIZE) + JOIN TPCH.PART PART + ON PART.p_name LIKE '%almond%' + AND PART.p_size <= ( + SIZES_2.PART_SIZE + 4 + ) + AND PART.p_size >= SIZES_2.PART_SIZE + GROUP BY + SIZES_2.PART_SIZE +) +SELECT + SIZES.PART_SIZE AS part_size, + COALESCE("_S3".N_ROWS, 0) AS n_parts +FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56)) AS SIZES(PART_SIZE) +LEFT JOIN "_S3" "_S3" + 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 new file mode 100644 index 000000000..8e2781f0b --- /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 DATE)) 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 DATE)) +) +SELECT + YEARS.YEAR AS year, + COALESCE("_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 YEARS.YEAR = "_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_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 new file mode 100644 index 000000000..b35630540 --- /dev/null +++ b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql @@ -0,0 +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 +LEFT JOIN "_u_0" "_u_0" + ON COUNTRY.countrycode = "_u_0"."_u_1" +WHERE + COUNTRY.incomegroup = 'Low income' AND NOT "_u_0"."_u_1" IS NULL 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..e134a6c91 --- /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..388e7c187 --- /dev/null +++ b/tests/test_sql_refsols/week_offset_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxdatetime AS date_time, + 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, + 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 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATE)) < 2025 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 new file mode 100644 index 000000000..cdab2ebcf --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_10_oracle.sql @@ -0,0 +1,25 @@ +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 + LEFT JOIN "_u_0" "_u_0" + ON ORDERS.o_custkey = "_u_0"."_u_1" + WHERE + ORDERS.o_clerk = 'Clerk#000000001' AND "_u_0"."_u_1" IS NULL +) +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..94011f3c1 --- /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 DATE)) = 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(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" > 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 new file mode 100644 index 000000000..94011f3c1 --- /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 DATE)) = 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(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" > 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 new file mode 100644 index 000000000..94011f3c1 --- /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 DATE)) = 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(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" > 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 new file mode 100644 index 000000000..5c98e40a9 --- /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 DATE)) = 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..e01d007ee --- /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(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 DATE)) = 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..e01d007ee --- /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(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 DATE)) = 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..7099f8330 --- /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 DATE)) = 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..23cf9f286 --- /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 DATE)) = 1 + AND EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) = 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(COALESCE(COUNT_O_CUSTKEY, 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..a12d765e4 --- /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, + COALESCE(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..6c7c1e353 --- /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 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 + 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 DATE)), + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATE)), + 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..9ec097740 --- /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 DATE)) AS YEAR_O_ORDERDATE, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATE)) +) +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 diff --git a/tests/testing_utilities.py b/tests/testing_utilities.py index 234903363..348161719 100644 --- a/tests/testing_utilities.py +++ b/tests/testing_utilities.py @@ -1423,6 +1423,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