diff --git a/demos/README.md b/demos/README.md index 5aa94a6d3..2b1b58fae 100644 --- a/demos/README.md +++ b/demos/README.md @@ -26,4 +26,5 @@ Once the introduction notebook is complete, you can explore the other notebooks: - [SF_TPCH_q1.ipynb](notebooks/SF_TPCH_q1.ipynb) demonstrates how to connect a Snowflake database with PyDough. - [MySQL_TPCH.ipynb](notebooks/MySQL_TPCH.ipynb) demonstrates how to connect a MySQL database with PyDough. - [PG_TPCH.ipynb](notebooks/PG_TPCH.ipynb) demonstrates how to connect a Postgres database with PyDough. +- [Oracle_TPCH.ipynb](notebooks/Oracle_TPCH.ipynb) demonstrates how to connect an Oracle database with PyDough. diff --git a/demos/notebooks/Oracle_TCPH.ipynb b/demos/notebooks/Oracle_TCPH.ipynb new file mode 100644 index 000000000..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 5f5894687..c082751d2 100644 --- a/documentation/usage.md +++ b/documentation/usage.md @@ -345,7 +345,9 @@ Below is a list of all supported values for the database name: - `snowflake`: uses a Snowflake database. [See here](https://docs.snowflake.com/en/user-guide/python-connector.html#connecting-to-snowflake) for details on the connection API and what keyword arguments can be passed in. -- `postgres` or `postgres`: uses a Postgres database. [See here](https://www.psycopg.org/docs/) for details on the connection API and what keyword arguments can be passed in. +- `postgres`: uses a Postgres database. [See here](https://www.psycopg.org/docs/) for details on the connection API and what keyword arguments can be passed in. + +- `oracle`: uses an Oracle database. [See here](https://python-oracledb.readthedocs.io/en/latest/user_guide/installation.html) for details on the connection API and what keyword arguments can be passed in. > Note: If you installed PyDough via pip, you can install optional connectors using pip extras: > @@ -364,6 +366,7 @@ Here’s a quick reference table showing which connector is needed for each dial | `mysql` | `mysql-connector-python` | | `snowflake` | `snowflake-connector-python[pandas]` | | `postgres` | `psycopg2-binary` | +| `oracle` | `python-oracledb` | Below are examples of how to access the context and switch it out for a newly created one, either by manually setting it or by using `session.load_database`. These examples assume that there are two different sqlite database files located at `db_files/education.db` and `db_files/shakespeare.db`. @@ -439,6 +442,34 @@ You can find a full example of using MySQL database with PyDough in [this usage ``` You can find a full example of using Postgres database with PyDough in [this usage guide](./../demos/notebooks/PG_TPCH.ipynb). +- Oracle: You can connect to an Oracle database using `load_metadata_graph` and `connect_database` APIs. For example: + ```py + pydough.active_session.load_metadata_graph("../../tests/test_metadata/sample_graphs.json", "TPCH") + pydough.active_session.connect_database("oracle", + user=oracle_user, + password=oracle_password, + host=oracle_host, + port=oracle_port + service_name=oracle_service_name, + ) + ``` + Also you can use `dsn` instead of `host`, `port` and `service_name`. + + Example with a connection object + ```py + pydough.active_session.load_metadata_graph("../../tests/test_metadata/sample_graphs.json", "TPCH") + oracle_conn: oracledb.connection = oracledb.connect( + dbname=oracle_db, + user=oracle_user, + password=oracle_password, + host=oracle_host, + port=oracle_port, + service_name=oracle_service_name, + ) + pydough.active_session.connect_database("oracle", connection=oracle_conn) + ``` +You can find a full example of using an Oracle database with PyDough in [this usage guide](./../demos/notebooks/Oracle_TPCH.ipynb). + ## Evaluation APIs diff --git a/pydough/database_connectors/README.md b/pydough/database_connectors/README.md index 0ef17e5b5..b19e27071 100644 --- a/pydough/database_connectors/README.md +++ b/pydough/database_connectors/README.md @@ -19,6 +19,7 @@ The database connectors module provides functionality to manage database connect - `SNOWFLAKE`: Represents the Snowflake SQL dialect. - `MYSQL`: Represents the MySQL dialect. - `POSTGRES`: Represents the Postgres dialect + - `ORACLE`: Represents the Oracle dialect - `DatabaseContext`: Dataclass that manages the database connection and the corresponding dialect. - Fields: - `connection`: The `DatabaseConnection` object. @@ -35,6 +36,7 @@ The database connectors module provides functionality to manage database connect - `load_snowflake_connection`: Loads a Snowflake connection. - `load_mysql_connection`: Loads a MySQL database connection. - `load_postgres_connection`: Loads a Postgres database connection. +- `load_oracle_connection`: Loads an Oracle database connection. ## Usage diff --git a/pydough/database_connectors/__init__.py b/pydough/database_connectors/__init__.py index e9e71103f..7664b381d 100644 --- a/pydough/database_connectors/__init__.py +++ b/pydough/database_connectors/__init__.py @@ -5,6 +5,7 @@ "empty_connection", "load_database_context", "load_mysql_connection", + "load_oracle_connection", "load_postgres_connection", "load_snowflake_connection", "load_sqlite_connection", @@ -13,6 +14,7 @@ from .builtin_databases import ( load_database_context, load_mysql_connection, + load_oracle_connection, load_postgres_connection, load_snowflake_connection, load_sqlite_connection, diff --git a/pydough/database_connectors/builtin_databases.py b/pydough/database_connectors/builtin_databases.py index 349acb49f..21dc5fa13 100644 --- a/pydough/database_connectors/builtin_databases.py +++ b/pydough/database_connectors/builtin_databases.py @@ -13,6 +13,7 @@ __all__ = [ "load_database_context", "load_mysql_connection", + "load_oracle_connection", "load_postgres_connection", "load_snowflake_connection", "load_sqlite_connection", @@ -32,7 +33,7 @@ def load_database_context(database_name: str, **kwargs) -> DatabaseContext: Returns: The database context object. """ - supported_databases = {"postgres", "mysql", "sqlite", "snowflake"} + supported_databases = {"postgres", "mysql", "sqlite", "snowflake", "oracle"} connection: DatabaseConnection dialect: DatabaseDialect match database_name.lower(): @@ -48,6 +49,9 @@ def load_database_context(database_name: str, **kwargs) -> DatabaseContext: case "postgres": connection = load_postgres_connection(**kwargs) dialect = DatabaseDialect.POSTGRES + case "oracle": + connection = load_oracle_connection(**kwargs) + dialect = DatabaseDialect.ORACLE case _: raise PyDoughSessionException( f"Unsupported database: {database_name}. The supported databases are: {supported_databases}." @@ -296,3 +300,95 @@ def load_postgres_connection(**kwargs) -> DatabaseConnection: attempt += 1 raise ValueError(f"Failed to connect to Postgres after {attempts} attempts") + + +def load_oracle_connection(**kwargs) -> DatabaseConnection: + """ + Loads an Oracle database connection. This is done by providing a wrapper + around the DB 2.0 connect API. + + Args: + **kwargs: Either an Oracle connection object (as `connection=`) + or the required connection parameters: + - `user`: Oracle username + - `password`: Oracle password for the specified user + - `service_name`: The database service name. + Optionally, you can provide: + - `host`: Oracle server host (default: "127.0.0.1"/"localhost"). + - `port`: Oracle server port (default: 1521). + - `tcp_connect_timeout`: Timeout for the connection (default: 3 seconds). + - `attempts` (not an Oralce connector parameter): Number of connection attempts (default: 3) + - `delay` (not an Oracle connector parameter): Delay between connection attempts (default: 2 seconds). + If a connection object is provided, it will be used directly. + All arguments must be accepted by the Oracle connector connect API. + + Raises: + ImportError: If the Oracle connector is not installed. + ValueError: If required connection parameters are missing. + + Returns: + A database connection object for Oracle. + """ + try: + import oracledb + except ImportError: + raise ImportError( + "Oracle connector oracledb is not installed. Please install it with" + " `python -m pip install oracledb --upgrade`." + ) + + # Oracle python connector + connection: oracledb.connection + if connection := kwargs.pop("connection", None): + # If a connection object is provided, return it wrapped in + # DatabaseConnection + return DatabaseConnection(connection) + + # Oracle connection requires specific parameters: + # user, password and dsn or host, port and service_name instead of dsn. + # Raise an error if any of these are missing. + # NOTE: host, port are optional and will default to the oracle defaults. + # See: https://python-oracledb.readthedocs.io/en/latest/user_guide/connection_handling.html + + required_keys = ["user", "password", "service_name"] + if not all(key in kwargs for key in required_keys): + raise ValueError( + "Oracle connection requires at least the following arguments: " + + ", ".join(required_keys) + ) + + # Host is required for oracledb connector, not required for PyDough + if "host" not in kwargs: + kwargs["host"] = "localhost" + + # Default timeout for connection + if "tcp_connect_timeout" not in kwargs or kwargs["tcp_connect_timeout"] <= 0: + kwargs["tcp_connect_timeout"] = 3 + + # Default attempts for connection if not given + if not (attempts := kwargs.pop("attempts", None)): + attempts = 1 + + # Default delay between attempts for connection if not given + if not (delay := kwargs.pop("delay", None)): + delay = 2.0 + + attempt: int = 1 + + # For each attempt a connection is tried + # If it fails, there is a delay before another attempt is executed + while attempt <= attempts: + try: + connection = oracledb.connect(**kwargs) + return DatabaseConnection(connection) + + except (OSError, oracledb.Error) as err: + if attempt >= attempts: + raise ValueError( + f"Failed to connect to Oracle after {attempt} attempts: {err}" + ) + # Delay for another attempt + time.sleep(delay) + attempt += 1 + + raise ValueError(f"Failed to connect to Oracle after {attempts} attempts") diff --git a/pydough/database_connectors/database_connector.py b/pydough/database_connectors/database_connector.py index b34189442..d31593a19 100644 --- a/pydough/database_connectors/database_connector.py +++ b/pydough/database_connectors/database_connector.py @@ -109,6 +109,7 @@ class DatabaseDialect(Enum): SNOWFLAKE = "snowflake" MYSQL = "mysql" POSTGRES = "postgres" + ORACLE = "oracle" @staticmethod def from_string(dialect: str) -> "DatabaseDialect": diff --git a/pydough/database_connectors/db_types.py b/pydough/database_connectors/db_types.py index 3abf347cd..9f8c3f645 100644 --- a/pydough/database_connectors/db_types.py +++ b/pydough/database_connectors/db_types.py @@ -35,6 +35,11 @@ PostgresConn: TypeAlias = psycopg2.connection # type: ignore PostgresCursor: TypeAlias = psycopg2.cursor # type: ignore + import oracledb + + OracleConn: TypeAlias = oracledb.connection + OracleCursor: TypeAlias = oracledb.cursor + # TBD: Placeholder lines to add other dialects. # 1. Replace with actual dialect module # import dialect1_module @@ -44,8 +49,12 @@ # Dialect1_Cursor: TypeAlias = dialect1_module.Cursor # 4. Define the type aliases for database connections and cursors - DBConnection: TypeAlias = SQLiteConn | SnowflakeConn | MySQLConn | PostgresConn - DBCursor: TypeAlias = SQLiteCursor | SnowflakeCursor | MySQLCursor | PostgresCursor + DBConnection: TypeAlias = ( + SQLiteConn | SnowflakeConn | MySQLConn | PostgresConn | OracleConn + ) # type: ignore + DBCursor: TypeAlias = ( + SQLiteCursor | SnowflakeCursor | MySQLCursor | PostgresCursor | OracleCursor + ) # type: ignore else: DBConnection: TypeAlias = Any @@ -58,6 +67,8 @@ MySQLCursor: TypeAlias = Any PostgresConn: TypeAlias = Any PostgresCursor: TypeAlias = Any + OracleConn: TypeAlias = Any + OracleCursor: TypeAlias = Any # This allows us to use these type aliases in the rest of the code # without worrying about whether the specific database modules are available. @@ -66,6 +77,8 @@ "DBCursor", "MySQLConn", "MySQLCursor", + "OracleConn", + "OracleCursor", "PostgresConn", "PostgresCursor", "SQLiteConn", diff --git a/pydough/sqlglot/execute_relational.py b/pydough/sqlglot/execute_relational.py index 6e75f5868..20981317e 100644 --- a/pydough/sqlglot/execute_relational.py +++ b/pydough/sqlglot/execute_relational.py @@ -11,6 +11,7 @@ from sqlglot import parse_one from sqlglot.dialects import Dialect as SQLGlotDialect from sqlglot.dialects import MySQL as MySQLDialect +from sqlglot.dialects import Oracle as OracleDialect from sqlglot.dialects import Postgres as PostgresDialect from sqlglot.dialects import Snowflake as SnowflakeDialect from sqlglot.dialects import SQLite as SQLiteDialect @@ -204,7 +205,7 @@ def apply_sqlglot_optimizer( # Replaces any grouping or ordering keys that point to a clause in the # SELECT with an index (e.g. ORDER BY 1, GROUP BY 1, 2) - replace_keys_with_indices(glot_expr) + replace_keys_with_indices(glot_expr, dialect) # Remove table aliases if there is only one Table source in the FROM clause. remove_table_aliases_conditional(glot_expr) @@ -217,7 +218,9 @@ def apply_sqlglot_optimizer( return glot_expr -def replace_keys_with_indices(glot_expr: SQLGlotExpression) -> None: +def replace_keys_with_indices( + glot_expr: SQLGlotExpression, dialect: SQLGlotDialect +) -> None: """ Runs a transformation postprocessing pass on the SQLGlot AST to make the following changes: @@ -293,7 +296,9 @@ def replace_keys_with_indices(glot_expr: SQLGlotExpression) -> None: expression.expressions[expr_idx] = collate # Replace GROUP BY keys that are in the select clause with indices. - if expression.args.get("group") is not None: + # Oracle does not support indices in the GROUP BY, for this dialect this + # step is skipped + if expression.args.get("group") is not None and dialect != OracleDialect: keys_list: list[SQLGlotExpression] = expression.args["group"].expressions for idx, key_expr in enumerate(keys_list): # Only replace with the index if the key expression appears in @@ -484,6 +489,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}") diff --git a/pydough/sqlglot/transform_bindings/__init__.py b/pydough/sqlglot/transform_bindings/__init__.py index d69a356df..594ec6d78 100644 --- a/pydough/sqlglot/transform_bindings/__init__.py +++ b/pydough/sqlglot/transform_bindings/__init__.py @@ -19,6 +19,7 @@ from .base_transform_bindings import BaseTransformBindings from .mysql_transform_bindings import MySQLTransformBindings +from .oracle_transform_bindings import OracleTransformBindings from .postgres_transform_bindings import PostgresTransformBindings from .sf_transform_bindings import SnowflakeTransformBindings from .sqlite_transform_bindings import SQLiteTransformBindings @@ -55,5 +56,7 @@ def bindings_from_dialect( return MySQLTransformBindings(configs, visitor) case DatabaseDialect.POSTGRES: return PostgresTransformBindings(configs, visitor) + case DatabaseDialect.ORACLE: + return OracleTransformBindings(configs, visitor) case _: raise NotImplementedError(f"Unsupported dialect: {dialect}") diff --git a/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py new file mode 100644 index 000000000..95174cc8c --- /dev/null +++ b/pydough/sqlglot/transform_bindings/oracle_transform_bindings.py @@ -0,0 +1,307 @@ +""" +Definition of SQLGlot transformation bindings for the Oracle dialect. +""" + +__all__ = ["OracleTransformBindings"] + + +import sqlglot.expressions as sqlglot_expressions +from sqlglot.expressions import Expression as SQLGlotExpression + +import pydough.pydough_operators as pydop +from pydough.types import PyDoughType + +from .base_transform_bindings import BaseTransformBindings + + +class OracleTransformBindings(BaseTransformBindings): + """ + Subclass of BaseTransformBindings for the Oracle dialect. + """ + + PYDOP_TO_ORACLE_FUNC: dict[pydop.PyDoughExpressionOperator, str] = { + pydop.ABS: "ABS", + pydop.DEFAULT_TO: "NVL", + pydop.LARGEST: "GREATEST", + pydop.SMALLEST: "LEAST", + pydop.STRIP: "TRIM", + pydop.FIND: "INSTR", + pydop.JOIN_STRINGS: "LISTAGG", + pydop.PERCENTILE: "PERCENTILE_CONT", + } + + """ + Mapping of PyDough operators to equivalent Oracle function names + These are used to generate anonymous function calls in SQLGlot + """ + + def convert_call_to_sqlglot( + self, + operator: pydop.PyDoughExpressionOperator, + args: list[SQLGlotExpression], + types: list[PyDoughType], + ) -> SQLGlotExpression: + if operator in self.PYDOP_TO_ORACLE_FUNC: + return sqlglot_expressions.Anonymous( + this=self.PYDOP_TO_ORACLE_FUNC[operator], expressions=args + ) + return super().convert_call_to_sqlglot(operator, args, types) + + def convert_slice( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + """ + Convert a PyDough slice operation to a SQLGlot expression. + MySQL uses the SUBSTRING function for slicing. + + Outline of the logic: + - If the start index is None, it defaults to 1 (1-based indexing). + - If the stop index is None, it defaults to the length of the string. + - a = start index + - b = stop index + match (a, b): + case (None, None): + return SUBSTRING(x, 1) + case (+a, None): + return SUBSTRING(x, a + 1) + case (-a, None): + return SUBSTRING(x, a) + case (None, +b): + return SUBSTRING(x, 1, b) + case (None, -b): + return SUBSTRING(x, 1, LENGTH(x) + b) + case (+a, +b): + return SUBSTRING(x, a + 1, GREATEST(b - a, 0)) + case (-a, -b): + return SUBSTRING(x, a, GREATEST(b - a, 0)) + case (+a, -b): + return SUBSTRING(x, a + 1, GREATEST(LENGTH(x) + b - a, 0)) + case (-a, +b): + return SUBSTRING(x, a, b - GREATEST(LENGTH(x) + a, 0)) + """ + + assert len(args) == 4 + string_expr, start, stop, step = args + + start_idx: int | None = None + if not isinstance(start, sqlglot_expressions.Null): + if isinstance(start, sqlglot_expressions.Literal): + try: + start_idx = int(start.this) + except ValueError: + raise ValueError( + "SLICE function currently only supports the start index being integer literal or absent." + ) + else: + raise ValueError( + "SLICE function currently only supports the start index being integer literal or absent." + ) + + stop_idx: int | None = None + if not isinstance(stop, sqlglot_expressions.Null): + if isinstance(stop, sqlglot_expressions.Literal): + try: + stop_idx = int(stop.this) + except ValueError: + raise ValueError( + "SLICE function currently only supports the stop index being integer literal or absent." + ) + else: + raise ValueError( + "SLICE function currently only supports the stop index being integer literal or absent." + ) + + step_idx: int | None = None + if not isinstance(step, sqlglot_expressions.Null): + if isinstance(step, sqlglot_expressions.Literal): + try: + step_idx = int(step.this) + if step_idx != 1: + raise ValueError( + "SLICE function currently only supports the step being integer literal 1 or absent." + ) + except ValueError: + raise ValueError( + "SLICE function currently only supports the step being integer literal 1 or absent." + ) + else: + raise ValueError( + "SLICE function currently only supports the step being integer literal 1 or absent." + ) + + # SQLGlot expressions for 0 and 1 and empty string + sql_one: SQLGlotExpression = sqlglot_expressions.Literal.number(1) + sql_zero: SQLGlotExpression = sqlglot_expressions.Literal.number(0) + expr_length: SQLGlotExpression = sqlglot_expressions.Length(this=string_expr) + one_index_start: SQLGlotExpression = sqlglot_expressions.Add( + this=start, expression=sql_one + ) + # length adjustment + length: SQLGlotExpression = None + + match (start_idx, stop_idx): + case (None, end_idx) if end_idx is not None and end_idx >= 0: + length = stop + + case (None, end_idx) if end_idx is not None and end_idx < 0: + length = sqlglot_expressions.Add(this=expr_length, expression=stop) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx >= 0 + and end_idx >= 0 + ): + length = sqlglot_expressions.Greatest( + this=sqlglot_expressions.Sub(this=stop, expression=start), + expressions=[sql_zero], + ) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx < 0 + and end_idx < 0 + ): + length = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.LT( + this=expr_length, + expression=sqlglot_expressions.Abs(this=start), + ), + true=sqlglot_expressions.Add( + this=expr_length, expression=stop + ), + ) + ], + default=sqlglot_expressions.Greatest( + this=sqlglot_expressions.Sub(this=stop, expression=start), + expressions=[sql_zero], + ), + ) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx >= 0 + and end_idx < 0 + ): + length = sqlglot_expressions.Greatest( + this=sqlglot_expressions.Sub( + this=sqlglot_expressions.Add(this=expr_length, expression=stop), + expression=start, + ), + expressions=[sql_zero], + ) + + case (begin_idx, end_idx) if ( + begin_idx is not None + and end_idx is not None + and begin_idx < 0 + and end_idx >= 0 + ): + length = sqlglot_expressions.Sub( + this=stop, + expression=sqlglot_expressions.Greatest( + this=sqlglot_expressions.Add( + this=expr_length, expression=start + ), + expressions=[sql_zero], + ), + ) + + # start adjustment + if start_idx is not None and start_idx >= 0: + start = one_index_start + elif start_idx is not None and start_idx < 0: + start = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.GT( + this=expr_length, + expression=sqlglot_expressions.Abs(this=start), + ), + true=start, + ) + ], + default=sql_one, + ) + + elif start_idx is None: + start = sql_one + + result: SQLGlotExpression = sqlglot_expressions.Substring( + this=string_expr, start=start, length=length + ) + return result + + def convert_get_part( + self, args: list[SQLGlotExpression], types: list[PyDoughType] + ) -> SQLGlotExpression: + """ + GETPART(str, delim, idx) -> + REGEXP_SUBSTR( + str, + '[^' || delim || ']+', + 1, + CASE + WHEN idx = 0 THEN 1 + WHEN idx > 0 THEN idx + ELSE (REGEXP_COUNT(str, delim) + 1) + idx + 1 + END + ) + """ + + assert len(args) == 3 + + string_expr, delimiter_expr, index_expr = args + literal_0: SQLGlotExpression = sqlglot_expressions.Literal.number(0) + literal_1: SQLGlotExpression = sqlglot_expressions.Literal.number(1) + regex_1: SQLGlotExpression = sqlglot_expressions.Literal.string("[^") + regex_2: SQLGlotExpression = sqlglot_expressions.Literal.string("]+") + + case_expr: SQLGlotExpression = sqlglot_expressions.Case( + ifs=[ + sqlglot_expressions.If( + this=sqlglot_expressions.EQ(this=index_expr, expression=literal_0), + true=literal_1, + ), + sqlglot_expressions.If( + this=sqlglot_expressions.GT(this=index_expr, expression=literal_0), + true=index_expr, + ), + ], + default=sqlglot_expressions.Add( + this=sqlglot_expressions.Add( + this=sqlglot_expressions.Paren( + this=sqlglot_expressions.Add( + this=sqlglot_expressions.Anonymous( + this="REGEXP_COUNT", + expressions=[string_expr, delimiter_expr], + ), + expression=literal_1, + ) + ), + expression=index_expr, + ), + expression=literal_1, + ), + ) + + result: SQLGlotExpression = sqlglot_expressions.Anonymous( + this="REGEXP_SUBSTR", + expressions=[ + string_expr, + sqlglot_expressions.DPipe( + this=sqlglot_expressions.DPipe( + this=regex_1, expression=delimiter_expr, safe=True + ), + expression=regex_2, + safe=True, + ), + literal_1, + case_expr, + ], + ) + return result diff --git a/tests/conftest.py b/tests/conftest.py index a3389f7c1..115ac62b1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -33,6 +33,7 @@ from pydough.qdag import AstNodeBuilder from tests.test_pydough_functions.simple_pydough_functions import ( string_format_specifiers_mysql, + string_format_specifiers_oracle, string_format_specifiers_postgres, string_format_specifiers_snowflake, ) @@ -238,6 +239,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, @@ -407,6 +424,7 @@ def sqlite_dialects(request) -> DatabaseDialect: pytest.param(DatabaseDialect.SNOWFLAKE, id="snowflake"), pytest.param(DatabaseDialect.MYSQL, id="mysql"), pytest.param(DatabaseDialect.POSTGRES, id="postgres"), + pytest.param(DatabaseDialect.ORACLE, id="oracle"), ] ) def empty_context_database(request) -> DatabaseContext: @@ -1285,6 +1303,160 @@ def postgres_params_tpch_db_context( ) +ORACLE_ENVS = ["ORACLE_PASSWORD"] +""" + Oracle environment variables required for connection. + `ORACLE_PASSWORD`: The password for Oracle. +""" + + +@pytest.fixture(scope="session") +def require_oracle_env() -> None: + """ + Check if the Oracle environment variables are set. Allowing empty strings. + Returns: + bool: True if all required Oracle environment variables are set, False otherwise. + """ + if not all(os.getenv(var) is not None for var in ORACLE_ENVS): + pytest.skip("Skipping Oracle tests: environment variables not set.") + + +ORACLE_DOCKER_CONTAINER = "oracle_tpch_test" +ORACLE_DOCKER_IMAGE = "bodoai1/pydough-oracle-tpch:latest" +ORACLE_HOST = "127.0.0.1" +ORACLE_PORT = 1521 +""" + CONSTANTS for the Oracle Docker container setup. + - ORACLE_DOCKER_CONTAINER: The name of the Docker container. + - ORACLE_DOCKER_IMAGE: The Docker image to use for the Oracle container. + - ORACLE_HOST: The host address for Oracle. + - ORACLE_PORT: The port on which Oracle is exposed. +""" + + +@pytest.fixture(scope="session") +def oracle_docker_setup() -> None: + """Set up the Oracle Docker container for testing.""" + try: + if not is_ci(): + if container_exists(ORACLE_DOCKER_CONTAINER): + if not container_is_running(ORACLE_DOCKER_CONTAINER): + subprocess.run( + ["docker", "start", ORACLE_DOCKER_CONTAINER], check=True + ) + else: + subprocess.run( + [ + "docker", + "run", + "-d", + "--name", + ORACLE_DOCKER_CONTAINER, + "--platform", + "linux/amd64", + "-p", + f"{ORACLE_PORT}:{ORACLE_PORT}", + "-e", + f"ORACLE_PWD={os.getenv('ORACLE_PASSWORD')}", + ORACLE_DOCKER_IMAGE, + ], + check=True, + ) + except subprocess.CalledProcessError as e: + pytest.fail(f"Failed to set up Oracle Docker container: {e}") + + # Check import is successful + try: + import oracledb + except ImportError as e: + raise RuntimeError("python-oracledb is not installed") from e + + # Wait for Oracle to be ready for 3 minutes max + # Check for keywords (last created schema) + conn: oracledb.Connection | None = None + for _ in range(180): + try: + if not conn: + conn = oracledb.connect( + user="tpch", + password=os.getenv("ORACLE_PASSWORD"), + host=ORACLE_HOST, + port=ORACLE_PORT, + service_name="FREEPDB1", + ) + + # Checking the last last table of keywords was loaded correctly + # before running the test + cur = conn.cursor() + cur.execute("SELECT COUNT(*) FROM lineitem") + row = cur.fetchone() + if row and row[0] == 6001215: + conn.close() + break + else: + print(f"Waiting {_ + 1}/180 seconds for data to be load...") + time.sleep(1) + + except oracledb.Error as e: + print("Error occurred while connecting to Oracle:", e) + print(f"Waiting {_ + 1}/180 seconds for Oracle to be ready...") + time.sleep(1) + else: + subprocess.run(["docker", "rm", "-f", ORACLE_DOCKER_CONTAINER]) + pytest.fail("Oracle container did not become ready in time.") + + +@pytest.fixture(scope="session") +def oracle_conn_db_context( + require_oracle_env, oracle_docker_setup +) -> Callable[[str], DatabaseContext]: + """ + This fixture is used to connect to the Oracle TPCH/Defog database using + a connection object. + Returns a DatabaseContext for the Oracle TPCH/Defog database. + """ + import oracledb + + @cache + def _impl(oracle_user: str) -> DatabaseContext: + oracle_password = os.getenv("ORACLE_PASSWORD") + + connection: oracledb.Connection = oracledb.connect( + user=oracle_user, + password=oracle_password, + host=ORACLE_HOST, + port=ORACLE_PORT, + service_name="FREEPDB1", + ) + return load_database_context( + "oracle", + connection=connection, + ) + + return _impl + + +@pytest.fixture +def oracle_params_tpch_db_context( + require_oracle_env, oracle_docker_setup +) -> DatabaseContext: + """ + This fixture is used to connect to the oracle TPCH database using + parameters instead of a connection object. + Returns a DatabaseContext for the oracle TPCH database. + """ + oracle_password: str | None = os.getenv("ORACLE_PASSWORD") + + return load_database_context( + "oracle", + user="tpch", + password=oracle_password, + host=ORACLE_HOST, + port=ORACLE_PORT, + service_name="FREEPDB1", + ) + + @pytest.fixture(scope="session") def get_pagerank_graph() -> graph_fetcher: """ @@ -2023,154 +2195,185 @@ def tpch_custom_test_data_dialect_replacements( Replace specific TPC-H custom test data with dialect-specific versions. """ if test.test_name == "string_format_specifiers": - if dialect == DatabaseDialect.MYSQL: - return PyDoughPandasTest( - string_format_specifiers_mysql, - "TPCH", - lambda: pd.DataFrame( - { - "d1": ["Sat"], - "d2": ["Jul"], - "d3": ["7"], - "d4": ["15th"], - "d5": ["15"], - "d6": ["15"], - "d7": ["000000"], - "d8": ["14"], - "d9": ["02"], - "d10": ["02"], - "d11": ["30"], - "d12": ["196"], - "d13": ["14"], - "d14": ["2"], - "d15": ["30"], - "d16": ["07"], - "d17": ["PM"], - "d18": ["02:30:45 PM"], - "d19": ["45"], - "d20": ["45"], - "d21": ["14:30:45"], - "d22": ["28"], - "d23": ["28"], - "d24": ["28"], - "d25": ["28"], - "d26": ["28"], - "d27": ["6"], - "d28": ["2023"], - "d29": ["2023"], - "d30": ["2023"], - "d31": ["23"], - "d32": ["2023-07-15"], - "d33": ["14:30"], - } - ), - "string_format_specifiers", - ) - elif dialect == DatabaseDialect.POSTGRES: - return PyDoughPandasTest( - string_format_specifiers_postgres, - "TPCH", - lambda: pd.DataFrame( - { - # HOURS / MINUTES / SECONDS - "h1": ["02"], # HH - "h2": ["02"], # HH12 - "h3": ["14"], # HH24 - "m1": ["30"], # MI - "s1": ["45"], # SS - "ms1": ["000"], # MS - "us1": ["000000"], # US - "ff1": ["0"], # FF1 - "ff2": ["00"], # FF2 - "ff3": ["000"], # FF3 - "ff4": ["0000"], # FF4 - "ff5": ["00000"], # FF5 - "ff6": ["000000"], # FF6 - "ssss1": ["52245"], # SSSS - "ssss2": ["52245"], # SSSSS - # MERIDIEM - "am1": ["PM"], # AM - "am2": ["pm"], # am - "am3": ["P.M."], # A.M. - "am4": ["p.m."], # a.m. - # YEAR FORMATS - "y1": ["2,023"], # Y,YYY - "y2": ["2023"], # YYYY - "y3": ["023"], # YYY - "y4": ["23"], # YY - "y5": ["3"], # Y - "iy1": ["2023"], # IYYY - "iy2": ["023"], # IYY - "iy3": ["23"], # IY - "iy4": ["3"], # I - # ERA - "era1": ["AD"], # AD - "era2": ["A.D."], # A.D. - # MONTH NAMES - "mon1": ["JULY "], # MONTH (blank-padded) - "mon2": ["July "], # Month - "mon3": ["july "], # month - "mon4": ["JUL"], # MON - "mon5": ["Jul"], # Mon - "mon6": ["jul"], # mon - "mon7": ["07"], # MM - # DAY NAMES - "day1": ["SATURDAY "], # DAY (blank-padded) - "day2": ["Saturday "], # Day - "day3": ["saturday "], # day - "day4": ["SAT"], # DY - "day5": ["Sat"], # Dy - "day6": ["sat"], # dy - # DAY / WEEK / YEAR METRICS - "doy1": ["196"], # DDD - "doy2": ["195"], # IDDD - "dom1": ["15"], # DD - "dow1": ["7"], # D (Sunday=1) - "dow2": ["6"], # ID (Monday=1) - "wom1": ["3"], # W - "woy1": ["28"], # WW - "woy2": ["28"], # IW - # OTHER DATE COMPONENTS - "c1": ["21"], # CC - "j1": ["2460141"], # J (Julian day number) - "q1": ["3"], # Q - "rm1": ["VII "], # RM - "rm2": ["vii "], # rm - # TIME ZONE (timestamp without time zone β†’ empty) - "tz1": [""], # TZ - "tz2": [""], # tz - "tz3": ["+00"], # TZH - "tz4": ["00"], # TZM - "tz5": ["+00"], # OF - } - ), - "string_format_specifiers", - ) - elif dialect == DatabaseDialect.SNOWFLAKE: - return PyDoughPandasTest( - string_format_specifiers_snowflake, - "TPCH", - lambda: pd.DataFrame( - { - "d1": ["2023"], # YYYY - "d2": ["23"], # YY - "d3": ["07"], # MM - "d4": ["Jul"], # Mon - "d5": ["July"], # MMMM - "d6": ["15"], # DD - "d7": ["Sat"], # DY - "d8": ["Saturday"], # DYDY - "d9": ["14"], # HH24 - "d10": ["02"], # HH12 - "d11": ["30"], # MI - "d12": ["45"], # SS - "d13": ["PM"], # AM / PM - "d14": [".000000000"], # .FF - "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) - } - ), - "string_format_specifiers", - ) + match dialect: + case DatabaseDialect.MYSQL: + return PyDoughPandasTest( + string_format_specifiers_mysql, + "TPCH", + lambda: pd.DataFrame( + { + "d1": ["Sat"], + "d2": ["Jul"], + "d3": ["7"], + "d4": ["15th"], + "d5": ["15"], + "d6": ["15"], + "d7": ["000000"], + "d8": ["14"], + "d9": ["02"], + "d10": ["02"], + "d11": ["30"], + "d12": ["196"], + "d13": ["14"], + "d14": ["2"], + "d15": ["30"], + "d16": ["07"], + "d17": ["PM"], + "d18": ["02:30:45 PM"], + "d19": ["45"], + "d20": ["45"], + "d21": ["14:30:45"], + "d22": ["28"], + "d23": ["28"], + "d24": ["28"], + "d25": ["28"], + "d26": ["28"], + "d27": ["6"], + "d28": ["2023"], + "d29": ["2023"], + "d30": ["2023"], + "d31": ["23"], + "d32": ["2023-07-15"], + "d33": ["14:30"], + } + ), + "string_format_specifiers", + ) + + case DatabaseDialect.POSTGRES: + return PyDoughPandasTest( + string_format_specifiers_postgres, + "TPCH", + lambda: pd.DataFrame( + { + # HOURS / MINUTES / SECONDS + "h1": ["02"], # HH + "h2": ["02"], # HH12 + "h3": ["14"], # HH24 + "m1": ["30"], # MI + "s1": ["45"], # SS + "ms1": ["000"], # MS + "us1": ["000000"], # US + "ff1": ["0"], # FF1 + "ff2": ["00"], # FF2 + "ff3": ["000"], # FF3 + "ff4": ["0000"], # FF4 + "ff5": ["00000"], # FF5 + "ff6": ["000000"], # FF6 + "ssss1": ["52245"], # SSSS + "ssss2": ["52245"], # SSSSS + # MERIDIEM + "am1": ["PM"], # AM + "am2": ["pm"], # am + "am3": ["P.M."], # A.M. + "am4": ["p.m."], # a.m. + # YEAR FORMATS + "y1": ["2,023"], # Y,YYY + "y2": ["2023"], # YYYY + "y3": ["023"], # YYY + "y4": ["23"], # YY + "y5": ["3"], # Y + "iy1": ["2023"], # IYYY + "iy2": ["023"], # IYY + "iy3": ["23"], # IY + "iy4": ["3"], # I + # ERA + "era1": ["AD"], # AD + "era2": ["A.D."], # A.D. + # MONTH NAMES + "mon1": ["JULY "], # MONTH (blank-padded) + "mon2": ["July "], # Month + "mon3": ["july "], # month + "mon4": ["JUL"], # MON + "mon5": ["Jul"], # Mon + "mon6": ["jul"], # mon + "mon7": ["07"], # MM + # DAY NAMES + "day1": ["SATURDAY "], # DAY (blank-padded) + "day2": ["Saturday "], # Day + "day3": ["saturday "], # day + "day4": ["SAT"], # DY + "day5": ["Sat"], # Dy + "day6": ["sat"], # dy + # DAY / WEEK / YEAR METRICS + "doy1": ["196"], # DDD + "doy2": ["195"], # IDDD + "dom1": ["15"], # DD + "dow1": ["7"], # D (Sunday=1) + "dow2": ["6"], # ID (Monday=1) + "wom1": ["3"], # W + "woy1": ["28"], # WW + "woy2": ["28"], # IW + # OTHER DATE COMPONENTS + "c1": ["21"], # CC + "j1": ["2460141"], # J (Julian day number) + "q1": ["3"], # Q + "rm1": ["VII "], # RM + "rm2": ["vii "], # rm + # TIME ZONE (timestamp without time zone β†’ empty) + "tz1": [""], # TZ + "tz2": [""], # tz + "tz3": ["+00"], # TZH + "tz4": ["00"], # TZM + "tz5": ["+00"], # OF + } + ), + "string_format_specifiers", + ) + + case DatabaseDialect.SNOWFLAKE: + return PyDoughPandasTest( + string_format_specifiers_snowflake, + "TPCH", + lambda: pd.DataFrame( + { + "d1": ["2023"], # YYYY + "d2": ["23"], # YY + "d3": ["07"], # MM + "d4": ["Jul"], # Mon + "d5": ["July"], # MMMM + "d6": ["15"], # DD + "d7": ["Sat"], # DY + "d8": ["Saturday"], # DYDY + "d9": ["14"], # HH24 + "d10": ["02"], # HH12 + "d11": ["30"], # MI + "d12": ["45"], # SS + "d13": ["PM"], # AM / PM + "d14": [".000000000"], # .FF + "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) + } + ), + "string_format_specifiers", + ) + case DatabaseDialect.ORACLE: + return PyDoughPandasTest( + string_format_specifiers_oracle, + "TPCH", + lambda: pd.DataFrame( + { + "d1": ["2023"], # YYYY + "d2": ["23"], # YY + "d3": ["07"], # MM + "d4": ["Jul"], # Mon + "d5": ["July"], # MMMM + "d6": ["15"], # DD + "d7": ["Sat"], # DY + "d8": ["Saturday"], # DYDY + "d9": ["14"], # HH24 + "d10": ["02"], # HH12 + "d11": ["30"], # MI + "d12": ["45"], # SS + "d13": ["PM"], # AM / PM + "d14": [".000000000"], # .FF + "d15": ["Z"], # TZH:TZM (NTZ β†’ empty) + } + ), + "string_format_specifiers", + ) + case _: + pytest.skip("Skipping test: Unsupported dialect for test replacement") + return test diff --git a/tests/test_metadata/oracle_defog_graphs.json b/tests/test_metadata/oracle_defog_graphs.json new file mode 100644 index 000000000..5ae1d3fed --- /dev/null +++ b/tests/test_metadata/oracle_defog_graphs.json @@ -0,0 +1,4663 @@ +[ + { + "name": "Broker", + "version": "V2", + "collections": [ + { + "name": "customers", + "type": "simple table", + "table path": "sbCustomer", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "sbCustId", + "data type": "string", + "description": "The unique identifying string for the customer", + "sample values": ["C001", "C005", "C014"], + "synonyms": ["customer key"] + }, + { + "name": "name", + "type": "table column", + "column name": "sbCustName", + "data type": "string", + "description": "The name of the customer", + "sample values": ["Ava Wilson", "Bob Johnson", "David Kim", "Emily Davis"], + "synonyms": ["customer name", "first and last name"] + }, + { + "name": "email", + "type": "table column", + "column name": "sbCustEmail", + "data type": "string", + "description": "The email of the customer", + "sample values": ["alex.rodriguez@email.com", "ava.wilson@email.com", "arah.nguyen@email.com", "samantha.lee@email.com"], + "synonyms": ["email address", "customer email"] + }, + { + "name": "phone", + "type": "table column", + "column name": "sbCustPhone", + "data type": "string", + "description": "The phone number of the customer", + "sample values": ["555-123-4567", "555-623-7419", "555-135-7902"], + "synonyms": ["phone number", "customer phone"] + }, + { + "name": "address1", + "type": "table column", + "column name": "sbCustAddress1", + "data type": "string", + "description": "The address of the customer", + "sample values": ["123 Main St", "951 Pine Rd", "246 Elm St", "258 Elm Ave"], + "synonyms": ["first address line", "street address"] + }, + { + "name": "address2", + "type": "table column", + "column name": "sbCustAddress2", + "data type": "string", + "description": "The second address of the customer, if one exists", + "synonyms": ["second address line"] + }, + { + "name": "city", + "type": "table column", + "column name": "sbCustCity", + "data type": "string", + "description": "The city the customer lives in", + "sample values": ["Anytown", "Yourtown", "Someville", "Mytown"], + "synonyms": ["customer address city"] + }, + { + "name": "state", + "type": "table column", + "column name": "sbCustState", + "data type": "string", + "description": "The state the customer lives in, by its capitalized two-letter abbreviation", + "sample values": ["CA", "NY", "TX", "FL", "NJ"], + "synonyms": ["customer address state"] + }, + { + "name": "country", + "type": "table column", + "column name": "sbCustCountry", + "data type": "string", + "description": "The country the customer lives in", + "sample values": ["USA"], + "synonyms": ["customer address country"] + }, + { + "name": "postal_code", + "type": "table column", + "column name": "sbCustPostalCode", + "data type": "string", + "description": "The postal/zip code of the customer's address", + "sample values": ["90001", "10002", "08801"], + "synonyms": ["zip code", "customer address postal code"] + }, + { + "name": "join_date", + "type": "table column", + "column name": "sbCustJoinDate", + "data type": "datetime", + "description": "The date the customer joined the brokerage", + "synonyms": ["signup date", "customer join date", "account creation date"] + }, + { + "name": "status", + "type": "table column", + "column name": "sbCustStatus", + "data type": "string", + "description": "The state of the customer's account, which is either 'active', 'inactive', or 'suspended'", + "sample values": ["active", "inactive", "suspended"], + "synonyms": ["customer account status", "activity state"] + } + ], + "description": "The customers who have accounts with the the brokerage", + "synonyms": ["users", "clients", "members", "subscribers"] + }, + { + "name": "tickers", + "type": "simple table", + "table path": "sbTicker", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "sbTickerId", + "data type": "string", + "description": "The unique identifying string for each ticker", + "sample values": ["T001", "T003", "T007", "T0018"], + "synonyms": ["ticker key"] + }, + { + "name": "symbol", + "type": "table column", + "column name": "sbTickerSymbol", + "data type": "string", + "description": "The symbol used to abbreviate the ticker name in a recognizable manner, e.g. APPL for Apple, or GOOG for Google", + "sample values": ["APPL", "AMZN", "BRK.B", "FB", "GOOG", "NFLX", "MSFT"], + "synonyms": ["ticker symbol", "ticker abbreviation"] + }, + { + "name": "name", + "type": "table column", + "column name": "sbTickerName", + "data type": "string", + "description": "The full name of the ticker, e.g. the company name", + "sample values": ["Berkshire Hathaway Inc.", "Alphabet Inc.", "Apple Inc.", "Microsoft Corporation"], + "synonyms": ["company name", "business name"] + }, + { + "name": "ticker_type", + "type": "table column", + "column name": "sbTickerType", + "data type": "string", + "description": "The category of ticker, which is either 'stock', 'etf', or 'mutual fund'", + "sample values": ["stock", "etf", "mutual fund"], + "synonyms": ["category", "classification"] + }, + { + "name": "exchange", + "type": "table column", + "column name": "sbTickerExchange", + "data type": "string", + "description": "The exchange that the ticker is listed on, which is either 'NASDAQ', 'NYSE', 'NYSE Arca', or 'Vanguard'", + "sample values": ["NASDAQ", "NYSE", "NYSE Arca", "Vanguard"], + "synonyms": [] + }, + { + "name": "currency", + "type": "table column", + "column name": "sbTickerCurrency", + "data type": "string", + "description": "The currency that the ticker is traded in, which is always 'USD'", + "sample values": ["USD"] + }, + { + "name": "db2x", + "type": "table column", + "column name": "sbTickerDb2x", + "data type": "string", + "description": "The two-letter exchange code corresponding to the ticker's exchange, which is either 'NQ' for NASDAQ, 'NY' for NYSE, 'NX' for 'NYSE Arca', or 'VA' for Vanguard", + "sample values": ["NQ", "NY", "NX", "VG"], + "synonyms": ["exchange code"] + }, + { + "name": "is_active", + "type": "table column", + "column name": "sbTickerIsActive", + "data type": "bool", + "description": "Whether the ticker is still active", + "synonyms": ["ticker in use"] + } + ], + "description": "All of the tickers that the brokerage trades", + "synonyms": ["stocks", "etfs", "mutual funds"] + }, + { + "name": "daily_prices", + "type": "simple table", + "table path": "sbDailyPrice", + "unique properties": [["ticker_id", "date"]], + "properties": [ + { + "name": "ticker_id", + "type": "table column", + "column name": "sbDpTickerId", + "data type": "string", + "description": "The ticker id from the ticker whose price is being record", + "sample values": ["T002", "T003", "T005", "T007", "T011"], + "synonyms": ["ticker key"] + }, + { + "name": "date", + "type": "table column", + "column name": "sbDpDate", + "data type": "datetime", + "description": "The date of the price record", + "synonyms": ["record datetime", "price update date"] + }, + { + "name": "_open", + "type": "table column", + "column name": "sbDpOpen", + "data type": "numeric", + "description": "The opening price of the ticker on the day of the record", + "sample values": [150, 3200, 2500, 280], + "synonyms": ["opening price"] + }, + { + "name": "high", + "type": "table column", + "column name": "sbDpHigh", + "data type": "numeric", + "description": "The highest price of the ticker during the day of the record", + "sample values": [152.5, 282.75, 3225, 185, 2525], + "synonyms": ["high price", "high-point", "maximum price during day"] + }, + { + "name": "low", + "type": "table column", + "column name": "sbDpLow", + "data type": "numeric", + "description": "The lowest price of the ticker during the day of the record", + "sample values": [148.75, 279.5, 3180, 178.5, 2475], + "synonyms": ["low price", "low-point", "minimum price during day"] + }, + { + "name": "close", + "type": "table column", + "column name": "sbDpClose", + "data type": "numeric", + "description": "The close price of the ticker on the day of the record", + "sample values": [151.25, 281, 3210, 184.25, 2510], + "synonyms": ["closing price"] + }, + { + "name": "volume", + "type": "table column", + "column name": "sbDpVolume", + "data type": "numeric", + "description": "The total number of shares of the ticker traded during the day", + "sample values": [75000000, 4000000, 1500000, 35000000], + "synonyms": ["daily trading volume"] + }, + { + "name": "epoch_ms", + "type": "table column", + "column name": "sbDpEpochMs", + "data type": "numeric", + "description": "The number of milliseconds since the epoch (January 1, 1970) that the record was created", + "sample values": [1680336000000, 1680336000000, 1680336000000], + "synonyms": ["created timestamp in epoch milliseconds"] + }, + { + "name": "source", + "type": "table column", + "column name": "sbDpSource", + "data type": "string", + "description": "The exchange where the price record originated from, which is either 'NASDAQ', 'NYSE' or 'Vanguard'", + "sample values": ["NYSE", "NASDAQ", "Vanguard"], + "synonyms": ["price record origin"] + } + ], + "description": "The daily updates on tickers including their price information within a single day", + "synonyms": ["historical stock prices", "daily ticker price data"] + }, + { + "name": "transactions", + "type": "simple table", + "table path": "sbTransaction", + "unique properties": ["transaction_id", "kpx"], + "properties": [ + { + "name": "transaction_id", + "type": "table column", + "column name": "sbTxId", + "data type": "string", + "description": "The unique identifying string for each transaction", + "sample values": ["TX035", "TX001", "TX008", "TX033"], + "synonyms": ["transaction key"] + }, + { + "name": "customer_id", + "type": "table column", + "column name": "sbTxCustId", + "data type": "string", + "description": "The id of the customer who made the transaction", + "sample values": ["C003", "C005", "C007", "C001", "C008"], + "synonyms": ["customer key"] + }, + { + "name": "ticker_id", + "type": "table column", + "column name": "sbTxTickerId", + "data type": "string", + "description": "The id of the ticker being bought/sold in the transaction", + "sample values": ["T001", "T007", "T008"], + "synonyms": ["ticker key"] + }, + { + "name": "date_time", + "type": "table column", + "column name": "sbTxDateTime", + "data type": "datetime", + "description": "The timestamp that the transaction was made at", + "synonyms": ["transaction timestamp", "buy/sell datetime"] + }, + { + "name": "transaction_type", + "type": "table column", + "column name": "sbTxType", + "data type": "string", + "description": "The type of transaction, which is either 'buy' or 'sell'", + "sample values": ["buy", "sell"], + "synonyms": ["category", "classification"] + }, + { + "name": "shares", + "type": "table column", + "column name": "sbTxShares", + "data type": "numeric", + "description": "The number of shares being bought/sold in the transaction", + "sample values": [150, 120, 110], + "synonyms": ["volume traded", "transaction size"] + }, + { + "name": "price", + "type": "table column", + "column name": "sbTxPrice", + "data type": "numeric", + "description": "The price that the ticker was bought/sold at in the transaction", + "sample values": [180, 200, 220, 150, 130], + "synonyms": ["buy price", "sell price", "cost", "per-share value"] + }, + { + "name": "amount", + "type": "table column", + "column name": "sbTxAmount", + "data type": "numeric", + "description": "The total monetary value of the transaction (cost for buy, revenue for sell), which is the price multiplied by the number of shares", + "sample values": [27000, 24000, 24200, 15000, 13000], + "synonyms": ["total cost", "total revenue", "transaction value"] + }, + { + "name": "currency", + "type": "table column", + "column name": "sbTxCcy", + "data type": "string", + "description": "The currency that the transaction was made in, which is always 'USD'", + "sample values": ["USD"] + }, + { + "name": "tax", + "type": "table column", + "column name": "sbTxTax", + "data type": "numeric", + "description": "The tax applied by the brokerage onto the transaction", + "sample values": [135, 120, 121, 75, 65], + "synonyms": ["levy", "duty", "tariff"] + }, + { + "name": "commission", + "type": "table column", + "column name": "sbTxCommission", + "data type": "numeric", + "description": "The commission taken by the brokerage for the transaction", + "sample values": [20, 15, 10], + "synonyms": ["brokerage fee", "transaction fee"] + }, + { + "name": "kpx", + "type": "table column", + "column name": "sbTxKpx", + "data type": "string", + "description": "The internal code used for the transaction, which corresponds to the transaction id", + "sample values": ["KP056", "KP053", "KP011"], + "synonyms": [] + }, + { + "name": "settlement_date_str", + "type": "table column", + "column name": "sbTxSettlementDateStr", + "data type": "string", + "description": "The date the transaction was settled, which is a string in the form YYYYMMDD HH:MM:SS, or null if not settled yet", + "sample values": ["20230401 09:30:00", "20230401 10:15:00", "20230401 11:00:00"], + "synonyms": ["settlement timestamp", "datetime of transaction finalization"] + }, + { + "name": "status", + "type": "table column", + "column name": "sbTxStatus", + "data type": "string", + "description": "The status of the transaction, which is either 'success', 'fail', or 'pending'", + "sample values": ["success", "fail", "pending"], + "synonyms": ["transaction state"] + } + ], + "description": "All transactions made through the brokerage", + "synonyms": ["exchanges", "trades", "buy/sell orders"] + } + ], + "relationships": [ + { + "name": "transactions_made", + "type": "simple join", + "parent collection": "customers", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "customer_id" + ] + }, + "description": "All of the transactions made by the customer, including both buys and sells", + "synonyms": ["exchanges made", "trades made", "stock purchases and sales"] + }, + { + "name": "customer", + "type": "reverse", + "original parent": "customers", + "original property": "transactions_made", + "singular": true, + "always matches": true, + "description": "The customer who made the transaction", + "synonyms": ["user", "client", "stock buyer/seller"] + }, + { + "name": "transactions_of", + "type": "simple join", + "parent collection": "tickers", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "ticker_id" + ] + }, + "description": "The transactions made of a ticker, including both buys and sells of the ticker", + "synonyms": ["purchases", "sales", "exchanges", "trades of ticker"] + }, + { + "name": "ticker", + "type": "reverse", + "original parent": "tickers", + "original property": "transactions_of", + "singular": true, + "always matches": true, + "description": "The ticker that the transaction was made of", + "synonyms": ["stock", "etf", "fund", "company"] + }, + { + "name": "ticker", + "type": "simple join", + "parent collection": "daily_prices", + "child collection": "tickers", + "singular": true, + "always matches": true, + "keys": { + "ticker_id": [ + "_id" + ] + }, + "description": "The ticker that the daily price record corresponds to", + "synonyms": ["stock", "etf", "fund", "company"] + }, + { + "name": "daily_prices", + "type": "reverse", + "original parent": "daily_prices", + "original property": "ticker", + "singular": false, + "always matches": false, + "description": "The daily price records for the ticker", + "synonyms": ["historical prices", "price updates"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "Dealership", + "version": "V2", + "collections": [ + { + "name": "cars", + "type": "simple table", + "table path": "cars", + "unique properties": ["_id", "vin_number"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each car", + "sample values": [1, 3, 5, 6, 18], + "synonyms": ["car key", "car id"] + }, + { + "name": "make", + "type": "table column", + "column name": "make", + "data type": "string", + "description": "The make of the car, e.g. Ford, Toyota, etc.", + "sample values": ["Toyota", "Honda", "Ford", "Tesla", "Nissan"], + "synonyms": ["car brand", "car manufacturer"] + }, + { + "name": "model", + "type": "table column", + "column name": "model", + "data type": "string", + "description": "The model name of the car, e..g Civic, Model 3, A4, RX350, Equinox, etc.", + "sample values": ["Camry", "Accord", "Mustang", "Civic", "Altima", "Tiguan"], + "synonyms": ["car model", "car type"] + }, + { + "name": "year", + "type": "table column", + "column name": "year", + "data type": "numeric", + "description": "Year the car was manufactured", + "sample values": [2021, 2022, 2023], + "synonyms": ["year of production", "manufacturing year"] + }, + { + "name": "color", + "type": "table column", + "column name": "color", + "data type": "string", + "description": "Color of the car", + "sample values": ["Silver", "platinum/grey", "blue", "Titan Silver", "black", "ebony black", "baby blue", "Black", "Jade", "Fiery red"], + "synonyms": ["paint color"] + }, + { + "name": "vin_number", + "type": "table column", + "column name": "vin_number", + "data type": "string", + "description": "Vehicle identification number, a unique code used to identify individual motor vehicles", + "sample values": ["1C4HJXDG3NW123456", "1C6SRFFT3NN123456", "3VV2B7AX1NM123456"], + "synonyms": ["VIN", "vehicle ID"] + }, + { + "name": "engine_type", + "type": "table column", + "column name": "engine_type", + "data type": "string", + "description": "Type of engine (e.g., V6, V8, Electric)", + "sample values": [ + "Boxer 4", + "Electric", + "Flat 6", + "Inline 4", + "Inline 6", + "V6", + "V8" + ], + "synonyms": ["motor", "engine model"] + }, + { + "name": "transmission", + "type": "table column", + "column name": "transmission", + "data type": "string", + "description": "Type of transmission, which is always either 'Automatic', 'Manual', or 'CVT'", + "sample values": ["Automatic", "Manual", "CVT"], + "synonyms": ["gearbox", "transmission type"] + }, + { + "name": "cost", + "type": "table column", + "column name": "cost", + "data type": "numeric", + "description": "Cost of the car", + "sample values": [38000.0, 45000.0, 22000.0, 32000.0], + "synonyms": ["value"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the car was added to the system", + "synonyms": ["created timestamp", "system entry date"] + } + ], + "description": "All cars recorded in the dealership system", + "synonyms": ["vehicles", "automobiles"] + }, + { + "name": "salespeople", + "type": "simple table", + "table path": "salespersons", + "unique properties": ["_id", "email"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each salesperson in the dealership", + "sample values": [1, 5, 10, 13], + "synonyms": ["salesperson key", "salesperson id", "salesperson number"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the salesperson", + "sample values": ["John", "Jane", "David", "Sarah"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the salesperson", + "sample values": ["Doe", "Smith", "Taylor", "Thomas"], + "synonyms": ["surname"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "Work email of the salesperson", + "sample values": ["john.doe@autonation.com", "michael.johnson@autonation.com", "jennifer.davis@directauto.com"], + "synonyms": ["email address", "work email"] + }, + { + "name": "phone", + "type": "table column", + "column name": "phone", + "data type": "string", + "description": "Contact phone number of the salesperson, where tte first 3 digits are the area code. Format: (123)-456-7890", + "sample values": ["(555)-123-4567", "(444)-333-4444", "(001)-415-5678", "(555)-789-0123"], + "synonyms": ["phone number", "contact information"] + }, + { + "name": "hire_date", + "type": "table column", + "column name": "hire_date", + "data type": "datetime", + "description": "The date the salesperson was hired", + "synonyms": ["employment date", "start date"] + }, + { + "name": "termination_date", + "type": "table column", + "column name": "termination_date", + "data type": "datetime", + "description": "The date the salesperson left the dealership, if applicable (null if still working there)", + "synonyms": ["firing date", "exit date", "quitting date", "end date"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the salesperson record was created", + "synonyms": ["created timestamp", "system entry date"] + } + ], + "description": "The salespeople working at the dealership, current and former", + "synonyms": ["dealership employees", "sales staff", "sales associates"] + }, + { + "name": "customers", + "type": "simple table", + "table path": "customers", + "unique properties": ["_id", "email"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each customer", + "sample values": [1, 5, 9, 12], + "synonyms": ["customer key", "customer id"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the customer", + "sample values": ["William", "Ava", "Sophia", "Mia"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the customer", + "sample values": ["Davis", "Miller", "Jackson", "Lee"], + "synonyms": ["surname"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "The email address of the customer", + "sample values": ["william.davis@example.com", "charlotte.anderson@example.com", "sophia.lee@microsoft.com", "christopher.brown@ai.com", "abigail.harris@company.io"], + "synonyms": ["contact email", "email address"] + }, + { + "name": "phone", + "type": "table column", + "column name": "phone", + "data type": "string", + "description": "The phone number of the customer listed with the dealership", + "sample values": ["555-888-9999", "555-666-5555", "555-456-7890", "555-444-3333"], + "synonyms": ["contact information", "phone number"] + }, + { + "name": "address", + "type": "table column", + "column name": "address", + "data type": "string", + "description": "The home address of the customer given to the dealership", + "sample values": ["123 Main St", "456 Oak Ave", "987 Birch Dr", "951 Oak Ln"], + "synonyms": ["street address", "home address", "street name and street number"] + }, + { + "name": "city", + "type": "table column", + "column name": "city", + "data type": "string", + "description": "The city of the customer's home address", + "sample values": ["New York", "Los Angeles", "Chicago", "Dallas"] + }, + { + "name": "state", + "type": "table column", + "column name": "state", + "data type": "string", + "description": "The state of the customer's home address, by its capitalized two-letter abbreviation", + "sample values": ["NY", "CA", "TX", "IL"] + }, + { + "name": "zip_code", + "type": "table column", + "column name": "zip_code", + "data type": "string", + "description": "The zip-code of the customer's home address", + "sample values": ["10001", "60007", "95101", "94101"], + "synonyms": [] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the customer record was created", + "synonyms": ["created timestamp", "system entry date"] + } + ], + "description": "All the customers who are registered with the dealership", + "synonyms": ["clients", "users", "buyers", "consumers"] + }, + { + "name": "payments_made", + "type": "simple table", + "table path": "payments_made", + "unique properties": ["_id", "invoice_number"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each payment made", + "sample values": [1, 11, 16, 17], + "synonyms": ["payment key", "payment id"] + }, + { + "name": "vendor_name", + "type": "table column", + "column name": "vendor_name", + "data type": "string", + "description": "Name of the vendor to whom the payment was made", + "sample values": ["Chevrolet Auto", "Marketing Agency", "Car Manufacturer Inc"], + "synonyms": ["payment recipient", "vendor"] + }, + { + "name": "payment_date", + "type": "table column", + "column name": "payment_date", + "data type": "datetime", + "description": "Date that the payment was made" + }, + { + "name": "payment_amount", + "type": "table column", + "column name": "payment_amount", + "data type": "numeric", + "description": "The amount that was paid in the payment in USD", + "sample values": [150000.0, 1500.0, 22000.0], + "synonyms": ["payment sum", "dollar value"] + }, + { + "name": "payment_method", + "type": "table column", + "column name": "payment_method", + "data type": "string", + "description": "Method of payment, which is either 'bank_transfer', 'credit_card', 'check', or 'credit_card'", + "sample values": ["bank_transfer", "credit_card", "check", "credit_card"], + "synonyms": ["transfer medium", "payment type"] + }, + { + "name": "invoice_number", + "type": "table column", + "column name": "invoice_number", + "data type": "string", + "description": "Invoice number associated with the payment", + "sample values": ["INV-001", "INV-017", "INV-008"], + "synonyms": ["invoice id", "invoice key", "invoice serial"] + }, + { + "name": "invoice_date", + "type": "table column", + "column name": "invoice_date", + "data type": "datetime", + "description": "Date of the invoice", + "synonyms": ["date of payment"] + }, + { + "name": "due_date", + "type": "table column", + "column name": "due_date", + "data type": "datetime", + "description": "Due date of the invoice", + "synonyms": ["deadline", "expected payment date"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the payment made record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of payments made by the dealership to vendors", + "synonyms": ["vendor payments", "vendor transactions", "vendor expenditures"] + }, + { + "name": "payments_received", + "type": "simple table", + "table path": "payments_received", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each payment received record", + "sample values": [1, 2, 10, 19, 23], + "synonyms": ["payment key", "payment id"] + }, + { + "name": "sale_id", + "type": "table column", + "column name": "sale_id", + "data type": "numeric", + "description": "The id of the sale that the payment is associated with", + "sample values": [1, 5, 9, 20, 21], + "synonyms": ["sale key", "sale id"] + }, + { + "name": "payment_date", + "type": "table column", + "column name": "payment_date", + "data type": "datetime", + "description": "Date when the payment was received. Can take place after the sale date, or in installments.", + "synonyms": ["transaction date", "installment date"] + }, + { + "name": "payment_amount", + "type": "table column", + "column name": "payment_amount", + "data type": "numeric", + "description": "Amount of the payment received. Can be less than the sale price if the payment is made in installments.", + "sample values": [115000.0, 5000.0, 44000.0, 26000.0], + "synonyms": ["cash received", "payment sum"] + }, + { + "name": "payment_method", + "type": "table column", + "column name": "payment_method", + "data type": "string", + "description": "Method used to make the payment, which can be 'check', 'financing', 'credit_card', 'debit_card', or 'cash'", + "sample values": ["check", "financing", "credit_card", "debit_card", "cash"], + "synonyms": ["transfer method", "payment type"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the payment received record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of payments received by the dealership from customers as part of a sale", + "synonyms": ["car purchase payments", "customer payments", "customer transactions", "car purchase installments"] + }, + { + "name": "sales", + "type": "simple table", + "table path": "sales", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each car sale", + "sample values": [5, 11, 12, 18, 22], + "synonyms": ["sale key", "sale id"] + }, + { + "name": "car_id", + "type": "table column", + "column name": "car_id", + "data type": "numeric", + "description": "The id of the car being purchased in the sale", + "sample values": [1, 3, 5, 6, 18], + "synonyms": ["car key", "car id"] + }, + { + "name": "salesperson_id", + "type": "table column", + "column name": "salesperson_id", + "data type": "numeric", + "description": "The id of the salesperson who brokered the sale", + "sample values": [1, 5, 10, 13], + "synonyms": ["salesperson key", "salesperson id"] + }, + { + "name": "customer_id", + "type": "table column", + "column name": "customer_id", + "data type": "numeric", + "description": "The id of the customer who purchased the car in the sale", + "sample values": [1, 5, 9, 12], + "synonyms": ["customer key", "customer id"] + }, + { + "name": "sale_price", + "type": "table column", + "column name": "sale_price", + "data type": "numeric", + "description": "Price at which the car was sold", + "sample values": [43500.0, 30500.0, 38000.0, 49000.0, 26500.0], + "synonyms": ["purchase cost", "sale amount", "dollar value"] + }, + { + "name": "sale_date", + "type": "table column", + "column name": "sale_date", + "data type": "datetime", + "description": "Date when the car was sold", + "synonyms": ["purchase date", "transaction date"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the sale record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of cars being purchased from the dealership from a customer via one of the salespeople", + "synonyms": ["car purchases", "sale records", "vehicle sale transactions"] + }, + { + "name": "inventory_snapshots", + "type": "simple table", + "table path": "inventory_snapshots", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each inventory snapshot entry", + "sample values": [1, 4, 13, 19, 23], + "synonyms": ["inventory snapshot key", "snapshot id"] + }, + { + "name": "snapshot_date", + "type": "table column", + "column name": "snapshot_date", + "data type": "datetime", + "description": "Date of the inventory snapshot", + "synonyms": ["date of snapshot", "inventory date"] + }, + { + "name": "car_id", + "type": "table column", + "column name": "car_id", + "data type": "numeric", + "description": "The key of the car that the inventory snapshot is for", + "sample values": [2, 10, 1, 4, 9], + "synonyms": ["car key", "car id"] + }, + { + "name": "is_in_inventory", + "type": "table column", + "column name": "is_in_inventory", + "data type": "bool", + "description": "Whether that specific car was in the dealership's inventory at the time of the snapshot", + "synonyms": ["car in inventory", "car availability"] + }, + { + "name": "crtd_ts", + "type": "table column", + "column name": "crtd_ts", + "data type": "datetime", + "description": "Timestamp when the inventory snapshot record was created", + "synonyms": ["system entry date", "created timestamp"] + } + ], + "description": "Records of whether specific individual cars were in the dealership's inventory as of specific dates", + "synonyms": ["inventory records", "stock records", "car availability manifest"] + } + ], + "relationships": [ + { + "name": "sale_records", + "type": "simple join", + "parent collection": "cars", + "child collection": "sales", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "car_id" + ] + }, + "description": "All sales made where the car was sold", + "synonyms": ["purchases of vehicle", "car sales", "vehicle transactions"] + }, + { + "name": "car", + "type": "reverse", + "original parent": "cars", + "original property": "sale_records", + "singular": true, + "always matches": true, + "description": "The car being purchased in the sale", + "synonyms": ["vehicle", "automobile"] + }, + { + "name": "inventory_snapshots", + "type": "simple join", + "parent collection": "cars", + "child collection": "inventory_snapshots", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "car_id" + ] + }, + "description": "The inventory snapshots for the car, which show whether it was in the dealership's inventory at specific dates", + "synonyms": ["availability records", "inventory history"] + }, + { + "name": "car", + "type": "reverse", + "original parent": "cars", + "original property": "inventory_snapshots", + "singular": true, + "always matches": true, + "description": "The car that the inventory snapshot belongs to", + "synonyms": ["vehicle", "automobile"] + }, + { + "name": "sales_made", + "type": "simple join", + "parent collection": "salespeople", + "child collection": "sales", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "salesperson_id" + ] + }, + "description": "All the sales brokered by the salesperson", + "synonyms": ["sales records", "transactions made", "deals closed"] + }, + { + "name": "salesperson", + "type": "reverse", + "original parent": "salespeople", + "original property": "sales_made", + "singular": true, + "always matches": true, + "description": "The salesperson who brokered the car purchase deal", + "synonyms": ["broker", "sales associate", "sales staff", "dealer"] + }, + { + "name": "car_purchases", + "type": "simple join", + "parent collection": "customers", + "child collection": "sales", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "customer_id" + ] + }, + "description": "All car purchases made by the customer", + "synonyms": ["vehicle purchase records", "car transactions", "automobile purchases"] + }, + { + "name": "customer", + "type": "reverse", + "original parent": "customers", + "original property": "car_purchases", + "singular": true, + "always matches": true, + "description": "The customer who purchased the car", + "synonyms": ["client", "buyer", "purchaser", "consumer", "user"] + }, + { + "name": "payment", + "type": "simple join", + "parent collection": "sales", + "child collection": "payments_received", + "singular": false, + "always matches": false, + "keys": { + "_id": [ + "sale_id" + ] + }, + "description": "The payment installments made for the sale, which can be one or multiple installments for a single sale", + "synonyms": ["sale purchase installments", "payment records"] + }, + { + "name": "sale_record", + "type": "reverse", + "original parent": "sales", + "original property": "payment", + "singular": true, + "always matches": true, + "description": "The sale that the payment is a part of", + "synonyms": ["purchase record", "vehicle sale", "car purchase"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "DermTreatment", + "version": "V2", + "collections": [ + { + "name": "doctors", + "type": "simple table", + "table path": "doctors", + "unique properties": ["doc_id"], + "properties": [ + { + "name": "doc_id", + "type": "table column", + "column name": "doc_id", + "data type": "numeric", + "description": "Unique identifier for each doctor in the system", + "sample values": [1, 2, 4, 8, 10], + "synonyms": ["doctor key", "doctor id"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the doctor", + "sample values": ["John", "Michael", "Daniel", "Olivia"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the doctor", + "sample values": ["Smith", "Brown", "Wilson", "Garcia"], + "synonyms": ["surname"] + }, + { + "name": "specialty", + "type": "table column", + "column name": "specialty", + "data type": "string", + "description": "The specialty of the doctor, which can be one of the following: dermatology, immunology, general, or oncology", + "sample values": ["dermatology", "immunology", "general", "oncology"], + "synonyms": ["focus", "area", "specialization", "expertise", "type of doctor"] + }, + { + "name": "year_reg", + "type": "table column", + "column name": "year_reg", + "data type": "numeric", + "description": "Year the doctor was registered and obtained license", + "sample values": [1998, 2006, 2012, 2015, 2018], + "synonyms": ["registration year", "year received license"] + }, + { + "name": "med_school_name", + "type": "table column", + "column name": "med_school_name", + "data type": "string", + "description": "The name of the medical school where the doctor graduated", + "sample values": ["University of Pennsylvania", "Johns Hopkins University", "Columbia University"], + "synonyms": ["alma matter", "medical school", "graduated from"] + }, + { + "name": "city", + "type": "table column", + "column name": "loc_city", + "data type": "string", + "description": "The city where the doctor is located", + "sample values": ["San Francisco", "Durham", "Ann Arbour", "New York"], + "synonyms": ["city of practice", "city of work", "location city", "city of residence"] + }, + { + "name": "state", + "type": "table column", + "column name": "loc_state", + "data type": "string", + "description": "The state where the doctor is located, by its capitalized two-letter abbreviation", + "sample values": ["CA", "NC", "NY", "MI"], + "synonyms": ["state of practice", "state of work", "location state", "state of residence"] + }, + { + "name": "zip_code", + "type": "table column", + "column name": "loc_zip", + "data type": "string", + "description": "The zip code where the doctor is located", + "sample values": ["21201", "02115", "94304", "10027"], + "synonyms": ["zip code of practice", "zip code of work", "location zip code", "zip code of residence"] + }, + { + "name": "board_certification_number", + "type": "table column", + "column name": "bd_cert_num", + "data type": "string", + "description": "The board certification number of the doctor", + "sample values": ["YZA890", "ABC123", "GHI012", "JKL345"], + "synonyms": ["board certification number", "certification number"] + } + ], + "description": "All the doctors registered in the system", + "synonyms": ["practitioners", "physicians", "medical professionals"] + }, + { + "name": "patients", + "type": "simple table", + "table path": "patients", + "unique properties": ["patient_id", "email", "phone"], + "properties": [ + { + "name": "patient_id", + "type": "table column", + "column name": "patient_id", + "data type": "numeric", + "description": "The unique identifier for each patient in the system", + "sample values": [1, 3, 5, 7, 9], + "synonyms": ["patient key", "patient id"] + }, + { + "name": "first_name", + "type": "table column", + "column name": "first_name", + "data type": "string", + "description": "The first name of the patient", + "sample values": ["Alice", "Bob", "Carol", "David", "Eve"] + }, + { + "name": "last_name", + "type": "table column", + "column name": "last_name", + "data type": "string", + "description": "The last name of the patient", + "sample values": ["Smith", "Richter", "Martinez", "Taylor"], + "synonyms": ["surname"] + }, + { + "name": "date_of_birth", + "type": "table column", + "column name": "date_of_birth", + "data type": "datetime", + "description": "The date the patient was born", + "synonyms": ["birthday"] + }, + { + "name": "date_of_registration", + "type": "table column", + "column name": "date_of_registration", + "data type": "datetime", + "description": "The date the patient was registered in the system", + "synonyms": ["registration date", "system entry date"] + }, + { + "name": "gender", + "type": "table column", + "column name": "gender", + "data type": "string", + "description": "The gender of the patient, which can either 'Male', 'Female', or 'Others'", + "sample values": ["Male", "Female", "Others"], + "synonyms": ["sex"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "The email of the patient used for contact information", + "sample values": ["alice@email.com", "eve@email.com", "frank@email.com", "john@qwik.com'"], + "synonyms": ["email address", "contact email"] + }, + { + "name": "phone", + "type": "table column", + "column name": "phone", + "data type": "string", + "description": "The phone number of the patient used for contact information", + "sample values": ["555-123-4567", "555-987-6543", "555-123-4567"], + "synonyms": ["contact phone", "phone number"] + }, + { + "name": "street_address", + "type": "table column", + "column name": "addr_city", + "data type": "string", + "description": "The street address of the patient's home, including street name and number", + "sample values": ["987 Birch Dr", "753 Walnut Ave", "951 Spruce Blvd"], + "synonyms": ["street name and number", "home address"] + }, + { + "name": "city", + "type": "table column", + "column name": "addr_city", + "data type": "string", + "description": "The city of the patient's address", + "sample values": ["Anytown", "Somecity", "Somewhere", "Somewhere"], + "synonyms": ["home city", "town", "city of residence"] + }, + { + "name": "state", + "type": "table column", + "column name": "addr_state", + "data type": "string", + "description": "The state of the patient's address, by its capitalized two-letter abbreviation", + "sample values": ["CA", "TX", "FL", "OH"], + "synonyms": ["home state", "state of residence"] + }, + { + "name": "zip_code", + "type": "table column", + "column name": "addr_zip", + "data type": "string", + "description": "The zip code of the patient's address", + "sample values": ["12345", "54321", "86420"], + "synonyms": ["home zip code", "postal code", "zip code of residence"] + }, + { + "name": "insurance_type", + "type": "table column", + "column name": "ins_type", + "data type": "string", + "description": "The type of insurance the patient has, which can be one of the following: private, medicare, medicaid, or uninsured", + "sample values": ["private", "medicare", "medicaid", "uninsured"], + "synonyms": [] + }, + { + "name": "insurance_policy_number", + "type": "table column", + "column name": "ins_policy_num", + "data type": "string", + "description": "The policy number of the patient's insurance (null if uninsured)", + "sample values": ["ABC123456", "XYZ789012", "JKL567890", "PQR135790"], + "synonyms": ["policy number"] + }, + { + "name": "height", + "type": "table column", + "column name": "height_cm", + "data type": "numeric", + "description": "The height of the patient in centimeters", + "sample values": [165, 180, 160, 178], + "synonyms": ["centimeter height"] + }, + { + "name": "weight", + "type": "table column", + "column name": "weight_kg", + "data type": "numeric", + "description": "The weight of the patient in kilograms", + "sample values": [60, 78, 90, 60], + "synonyms": ["kilogram weight"] + } + ], + "description": "The personal & registration information about every patient registered in the system", + "synonyms": ["patient records", "patient information", "patient data", "clients", "trial subjects", "participants"] + }, + { + "name": "drugs", + "type": "simple table", + "table path": "drugs", + "unique properties": ["drug_id", "national_drug_code"], + "properties": [ + { + "name": "drug_id", + "type": "table column", + "column name": "drug_id", + "data type": "numeric", + "description": "The unique identifier for each drug in the system", + "sample values": [1, 2, 4, 8], + "synonyms": ["drug key", "drug id"] + }, + { + "name": "drug_name", + "type": "table column", + "column name": "drug_name", + "data type": "string", + "description": "The brand name of the drug", + "sample values": ["Drugalin", "Topizol", "Biologic-X", "Topicalin"], + "synonyms": ["brand name", "pharmaceutical name", "medication name"] + }, + { + "name": "manufacturer", + "type": "table column", + "column name": "manufacturer", + "data type": "string", + "description": "The name of the company who produces the drug", + "sample values": ["Pharma Inc", "Acme Pharma", "Derma Rx", "BioMed Ltd"], + "synonyms": ["producer", "drug manufacturer", "pharmaceutical company", "drug company"] + }, + { + "name": "drug_type", + "type": "table column", + "column name": "drug_type", + "data type": "string", + "description": "The category of drug, which can be one of the following: 'biologic', 'small molecule', or 'topical'", + "sample values": ["biologic", "small molecule", "topical"], + "synonyms": ["category", "classification", "type of drug"] + }, + { + "name": "mechanism_of_activation", + "type": "table column", + "column name": "moa", + "data type": "string", + "description": "The mechanism of activation of the drug", + "sample values": ["TNF-alpha inhibitor", "PDE4 inhibitor", "IL-12/23 inhibitor"], + "synonyms": ["moa"] + }, + { + "name": "fda_approval_date", + "type": "table column", + "column name": "fda_appr_dt", + "data type": "datetime", + "description": "The date the drug was approved by the FDA (null if not approved because it is still under trial)", + "synonyms": ["approval date"] + }, + { + "name": "administration_route", + "type": "table column", + "column name": "admin_route", + "data type": "string", + "description": "The means used to administer the drug, which can be one of the following: 'oral', 'injection' or 'topical'", + "sample values": ["oral", "injection", "topical"], + "synonyms": ["method of procedure", "administration method", "delivery means"] + }, + { + "name": "recommended_dosage_amount", + "type": "table column", + "column name": "dos_amt", + "data type": "numeric", + "description": "The recommended amount of the drug to be taken per dose, where the unit is specified in the dosage_units property", + "sample values": [40, 30, 15, 5], + "synonyms": ["dose size", "quantity per dose", "amount taken per administration"] + }, + { + "name": "dosage_units", + "type": "table column", + "column name": "dos_unit", + "data type": "string", + "description": "The unit used by recommended_dosage_amount, which is either `mg` (for milligrams) or `g` (for grams)", + "sample values": ["mg", "g"], + "synonyms": ["units of measurement", "dosage unit", "dose quantity scale factor"] + }, + { + "name": "dose_frequency_hours", + "type": "table column", + "column name": "dos_freq_hrs", + "data type": "numeric", + "description": "The recommended number of hours between dosages", + "sample values": [336, 24, 12, 672], + "synonyms": ["gap between doses", "administration hour intervals", "time between doses"] + }, + { + "name": "national_drug_code", + "type": "table column", + "column name": "ndc", + "data type": "string", + "description": "The national drug code of the drug, which is a unique identifier assigned to each drug by the FDA", + "sample values": ["12345-678-90", "13579-246-80", "95146-753-19"], + "synonyms": [] + } + ], + "description": "The drugs listed in the system, which are used for treatment of patients", + "synonyms": ["medications", "pharmaceuticals"] + }, + { + "name": "diagnoses", + "type": "simple table", + "table path": "diagnoses", + "unique properties": ["_id", "code", "name"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "DIAG_ID", + "data type": "numeric", + "description": "The unique identifier for each diagnosis in the system", + "sample values": [1, 3, 5, 7, 9], + "synonyms": ["diagnosis key", "diagnosis id"] + }, + { + "name": "code", + "type": "table column", + "column name": "diag_code", + "data type": "string", + "description": "The code of the diagnosis, which is a unique identifier assigned to each diagnosis by the ICD-10 system", + "sample values": ["L40.0", "L40.59", "F40.8", "L40.50"], + "synonyms": ["diagnosis code", "ICD-10 code"] + }, + { + "name": "name", + "type": "table column", + "column name": "diag_name", + "data type": "string", + "description": "Name of the diagnosis, in medical terms", + "sample values": ["Psoriasis vulgaris", "Generalized pustular psoriasis", "Psoriasis, unspecified", "Other psoriatic arthropathy", "Psoriatic arthritis mutilans"], + "synonyms": ["title"] + }, + { + "name": "description", + "type": "table column", + "column name": "diag_desc", + "data type": "string", + "description": "An elaboration of the diagnosis, in more layman's terms and/or with some symptoms included", + "sample values": ["Plaque psoriasis, the most common form", "Psoriasis not further specified", "Includes flexural, erythrodermic, and other rare types", "Small, teardrop-shaped lesions", "Widespread pustules on top of red skin"], + "synonyms": ["details", "symptoms", "explanation"] + } + ], + "description": "Records of each diagnosis in the system, which are identified when treating patients", + "synonyms": ["medical conditions", "diagnostic codes"] + }, + { + "name": "treatments", + "type": "simple table", + "table path": "treatments", + "unique properties": ["treatment_id"], + "properties": [ + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "Unique identifier for each treatment record in the system", + "sample values": [1, 4, 7, 16, 26], + "synonyms": ["treatment id", "treatment key"] + }, + { + "name": "patient_id", + "type": "table column", + "column name": "patient_id", + "data type": "numeric", + "description": "The id of the patient who is receiving the treatment", + "sample values": [1, 3, 5, 7, 9], + "synonyms": ["patient key", "patient id"] + }, + { + "name": "doc_id", + "type": "table column", + "column name": "doc_id", + "data type": "numeric", + "description": "The id of the doctor who is administering the treatment", + "sample values": [1, 2, 4, 8], + "synonyms": ["doctor key", "doctor id"] + }, + { + "name": "drug_id", + "type": "table column", + "column name": "drug_id", + "data type": "numeric", + "description": "The id of the drug being used in the treatment", + "sample values": [1, 2, 3, 5], + "synonyms": ["drug key", "drug id"] + }, + { + "name": "diagnosis_id", + "type": "table column", + "column name": "diag_id", + "data type": "numeric", + "description": "The id of the diagnosis the patient is being treated for", + "sample values": [2, 4, 5, 6, 8], + "synonyms": ["diagnosis key", "diagnosis id"] + }, + { + "name": "start_date", + "type": "table column", + "column name": "start_dt", + "data type": "datetime", + "description": "The date the treatment began", + "synonyms": ["treatment start date", "treatment initiation date"] + }, + { + "name": "end_date", + "type": "table column", + "column name": "end_dt", + "data type": "datetime", + "description": "The date the treatment ended (null if ongoing)", + "synonyms": ["treatment end date", "treatment completion date"] + }, + { + "name": "is_placebo", + "type": "table column", + "column name": "is_placebo", + "data type": "bool", + "description": "True if the treatment is a placebo, false otherwise", + "synonyms": ["placebo treatment", "dummy treatment"] + }, + { + "name": "total_drug_amount", + "type": "table column", + "column name": "tot_drug_amt", + "data type": "numeric", + "description": "The total quantity of the drug used in the treatment, where the unit is specified in the drug_unit property", + "sample values": [240, 180, 720, 360], + "synonyms": ["amount of drug used", "total drug quantity", "total dosage"] + }, + { + "name": "drug_unit", + "type": "table column", + "column name": "drug_unit", + "data type": "string", + "description": "The unit used by total_drug_amount, which is either `mg` (for milligrams) or `g` (for grams)", + "sample values": ["mg", "g"], + "synonyms": ["dosage unit", "unit of measurement", "drug quantity scale factor"] + } + ], + "description": "The records of each treatment administered to patients in the system, which can be either a drug or a placebo", + "synonyms": ["treatment records", "medical treatments", "therapies"] + }, + { + "name": "outcomes", + "type": "simple table", + "table path": "outcomes", + "unique properties": ["outcome_id"], + "properties": [ + { + "name": "outcome_id", + "type": "table column", + "column name": "outcome_id", + "data type": "numeric", + "description": "The unique identifier for each treatment outcome in the system", + "sample values": [1, 5, 16, 20, 21], + "synonyms": ["outcome key", "outcome id"] + }, + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "The id for the treatment that the outcome is related to", + "sample values": [3, 5, 9, 25, 26], + "synonyms": ["treatment key", "treatment id"] + }, + { + "name": "assessment_date", + "type": "table column", + "column name": "assess_dt", + "data type": "datetime", + "description": "The date when the outcome assessment was made", + "synonyms": ["date of assessment", "evaluation date"] + }, + { + "name": "day7_lesion_count", + "type": "table column", + "column name": "day7_lesion_cnt", + "data type": "numeric", + "description": "The number of lesions counted on the patient's skin at day 7 after treatment started", + "sample values": [20, 25, 18, 30, 22], + "synonyms": ["lesions observed on day 7"] + }, + { + "name": "day30_lesion_count", + "type": "table column", + "column name": "day30_lesion_cnt", + "data type": "numeric", + "description": "The number of lesions counted on the patient's skin at day 30 after treatment started (null if not enough time has passed)", + "sample values": [15, 18, 12, 25, 16], + "synonyms": ["lesions observed on day 30"] + }, + { + "name": "day100_lesion_count", + "type": "table column", + "column name": "day100_lesion_cnt", + "data type": "numeric", + "description": "The number of lesions counted on the patient's skin at day 100 after treatment started (null if not enough time has passed)", + "sample values": [5, 8, 3, 12, 6], + "synonyms": ["lesions observed on day 100"] + }, + { + "name": "day7_pasi_score", + "type": "table column", + "column name": "day7_pasi_score", + "data type": "numeric", + "description": "The PASI score calculated at day 7 after treatment started, (Psoriasis Area and Severity Index) which is a measure of the severity of psoriasis from 0 to 72", + "sample values": [12.5, 15.0, 10.8, 18.2, 13.1], + "synonyms": ["PASI on day 7"] + }, + { + "name": "day30_pasi_score", + "type": "table column", + "column name": "day30_pasi_score", + "data type": "numeric", + "description": "The PASI score calculated at day 30 after treatment started, (Psoriasis Area and Severity Index) which is a measure of the severity of psoriasis from 0 to 72 (null if not enough time has passed)", + "sample values": [8.2, 10.1, 6.4, 18.2, 13.1], + "synonyms": ["PASI on day 30"] + }, + { + "name": "day100_pasi_score", + "type": "table column", + "column name": "day100_pasi_score", + "data type": "numeric", + "description": "The PASI score calculated at day 100 after treatment started, (Psoriasis Area and Severity Index) which is a measure of the severity of psoriasis from 0 to 72 (null if not enough time has passed)", + "sample values": [2.1, 3.5, 1.2, 5.8, 2.6], + "synonyms": ["PASI on day 100"] + }, + { + "name": "day7_tewl", + "type": "table column", + "column name": "day7_tewl", + "data type": "numeric", + "description": "TEWL score (Transepidermal Water Loss) calculated at day 7 after treatment started, which is a measure of skin hydration", + "sample values": [18.2, 20.1, 16.5, 22.4], + "synonyms": ["TEWL on day 7"] + }, + { + "name": "day30_tewl", + "type": "table column", + "column name": "day30_tewl", + "data type": "numeric", + "description": "TEWL score (Transepidermal Water Loss) calculated at day 30 after treatment started, which is a measure of skin hydration, in n g/m^2/h (null if not enough time has passed)", + "sample values": [15.6, 17.2, 14.0, 19.1], + "synonyms": ["TEWL on day 30"] + }, + { + "name": "day100_tewl", + "type": "table column", + "column name": "day100_tewl", + "data type": "numeric", + "description": "TEWL score (Transepidermal Water Loss) calculated at day 100 after treatment started, which is a measure of skin hydration, in n g/m^2/h (null if not enough time has passed)", + "sample values": [12.1, 13.5, 10.8, 15.2], + "synonyms": ["TEWL on day 100"] + }, + { + "name": "day7_itch_vas", + "type": "table column", + "column name": "day7_itch_vas", + "data type": "numeric", + "description": "The itch visual analog scale (VAS) score at day 7 after treatment started, which is a measure of itch severity from 0 to 100", + "sample values": [60, 70, 55, 80, 65], + "synonyms": ["VAS on day 7"] + }, + { + "name": "day30_itch_vas", + "type": "table column", + "column name": "day30_itch_vas", + "data type": "numeric", + "description": "The itch visual analog scale (VAS) score at day 30 after treatment started, which is a measure of itch severity from 0 to 100 (null if not enough time has passed)", + "sample values": [40, 50, 35, 60, 45], + "synonyms": ["VAS on day 30"] + }, + { + "name": "day100_itch_vas", + "type": "table column", + "column name": "day100_itch_vas", + "data type": "numeric", + "description": "The itch visual analog scale (VAS) score at day 100 after treatment started, which is a measure of itch severity from 0 to 100 (null if not enough time has passed)", + "sample values": [20, 30, 15, 40, 25], + "synonyms": ["VAS on day 100"] + }, + { + "name": "day7_hfg", + "type": "table column", + "column name": "day7_hfg", + "data type": "numeric", + "description": "Hair growth factor (HGF) score at day 7 after treatment started, on a scale from 0 to 5", + "sample values": [1.5, 1.0, 2.0, 0.5, 1.2], + "synonyms": ["HFG on day 7"] + }, + { + "name": "day30_hfg", + "type": "table column", + "column name": "day30_hfg", + "data type": "numeric", + "description": "Hair growth factor (HGF) score at day 30 after treatment started, on a scale from 0 to 5 (null if not enough time has passed)", + "sample values": [2.5, 2.0, 3.0, 1.5, 2.2], + "synonyms": ["HFG on day 30"] + }, + { + "name": "day100_hfg", + "type": "table column", + "column name": "day100_hfg", + "data type": "numeric", + "description": "Hair growth factor (HGF) score at day 100 after treatment started, on a scale from 0 to 5 (null if not enough time has passed)", + "sample values": [4.0, 3.5, 4.5, 3.0, 3.8], + "synonyms": ["HFG on day 100"] + } + ], + "description": "The recorded outcomes of treatments, which can include the same treatment at different points in time if not enough time has elapsed to record the complete outcome for a treatment", + "synonyms": ["results", "treatment evaluations", "assessments"] + }, + { + "name": "concomitant_meds", + "type": "simple table", + "table path": "concomitant_meds", + "unique properties": ["_id", ["treatment_id", "medicine_name"]], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "The unique identifier for each concomitant medication record in the system", + "sample values": [1, 5, 12, 14, 15], + "synonyms": ["concomitant drug key", "concomitant drug id"] + }, + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "The id of the treatment that the concomitant medication record is related to", + "sample values": [1, 4, 8, 11, 13, 14], + "synonyms": [] + }, + { + "name": "medicine_name", + "type": "table column", + "column name": "med_name", + "data type": "string", + "description": "The name of the medicine being taken by the patient as a concomitant drug", + "sample values": ["Acetaminophen", "Ibuprofen", "Loratadine", "Multivitamin", "Calcium supplement", "Vitamin D", "Hydrocortisone cream"], + "synonyms": ["concomitant drug name"] + }, + { + "name": "start_date", + "type": "table column", + "column name": "start_dt", + "data type": "string", + "description": "Date the concomitant drug treatment was started", + "synonyms": ["concomitant drug start date", "first date"] + }, + { + "name": "end_date", + "type": "table column", + "column name": "end_dt", + "data type": "string", + "description": "Date the concomitant drug treatment finished (null if ongoing)", + "synonyms": ["last date", "concomitant drug end date"] + }, + { + "name": "dose_amount", + "type": "table column", + "column name": "dose_amt", + "data type": "numeric", + "description": "The amount of the medicine taken per dose, where the unit is specified in the dose_unit property", + "sample values": [500, 200, 10, 1, 50], + "synonyms": ["amount of dose", "quantity per dose", "dose size"] + }, + { + "name": "dose_unit", + "type": "table column", + "column name": "dose_unit", + "data type": "string", + "description": "The unit used by dose_amount", + "sample values": ["mg", "g", "tablet", "IU"], + "synonyms": [] + }, + { + "name": "dose_frequency", + "type": "table column", + "column name": "freq_hrs", + "data type": "numeric", + "description": "The frequency of the dose in hours (null if one-time use)", + "sample values": [6, 24, 8, 12], + "synonyms": ["gap between doses", "administration hour intervals", "time between doses"] + } + ], + "description": "Records of medications that are taken by patients in addition to the treatment they are receiving during their treatment", + "synonyms": ["additional drugs", "ancillary medications", "concomitant drugs", "accompanying medications", "concurrent drugs"] + }, + { + "name": "adverse_events", + "type": "simple table", + "table path": "adverse_events", + "unique properties": ["_id"], + "properties": [ + { + "name": "_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "The unique identifier for each adverse event record in the system", + "sample values": [1, 3, 5, 7, 8], + "synonyms": ["adverse event key", "adverse event id"] + }, + { + "name": "treatment_id", + "type": "table column", + "column name": "treatment_id", + "data type": "numeric", + "description": "The id for the treatment that the adverse event occurred during", + "sample values": [2, 5, 9, 11, 14], + "synonyms": ["treatment key", "treatment id"] + }, + { + "name": "reported_date", + "type": "table column", + "column name": "reported_dt", + "data type": "datetime", + "description": "The date the adverse event was reported", + "synonyms": ["incident date", "date of reaction"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "Descriptor of the adverse event, which can be a single word or a phrase", + "sample values": ["Mild injection site reaction", "Headache, nausea", "Severe allergic reaction, hospitalization required", "Diarrhea"], + "synonyms": [] + } + ], + "description": "All records of adverse events that have been reported in the system related to a treatment", + "synonyms": ["incidents during treatment", "adverse reactions", "side effects"] + } + ], + "relationships": [ + { + "name": "doctor", + "type": "simple join", + "parent collection": "treatments", + "child collection": "doctors", + "singular": true, + "always matches": true, + "keys": { + "doc_id": [ + "doc_id" + ] + }, + "description": "The doctor who administered the treatment", + "synonyms": ["medical professional", "treatment administrator", "prescribing doctor"] + }, + { + "name": "prescribed_treatments", + "type": "reverse", + "original parent": "treatments", + "original property": "doctor", + "singular": false, + "always matches": false, + "description": "The treatments prescribed/administered by the doctor", + "synonyms": ["regimens", "treatment plans", "medical prescriptions"] + }, + { + "name": "patient", + "type": "simple join", + "parent collection": "treatments", + "child collection": "patients", + "singular": true, + "always matches": true, + "keys": { + "patient_id": [ + "patient_id" + ] + }, + "description": "The patient who the treatment was administered to", + "synonyms": ["trial subject", "participant", "client", "drug recipient"] + }, + { + "name": "treatments_received", + "type": "reverse", + "original parent": "treatments", + "original property": "patient", + "singular": false, + "always matches": false, + "description": "The drug treatment regimens the patient has been a part of", + "synonyms": ["Drug regimens", "medical treatments", "therapies", "treatment history"] + }, + { + "name": "drug", + "type": "simple join", + "parent collection": "treatments", + "child collection": "drugs", + "singular": true, + "always matches": true, + "keys": { + "drug_id": [ + "drug_id" + ] + }, + "description": "The drug being used as part of the treatment", + "synonyms": ["medication", "pharmaceutical", "drug product", "therapy"] + }, + { + "name": "treatments_used_in", + "type": "reverse", + "original parent": "treatments", + "original property": "drug", + "singular": false, + "always matches": false, + "description": "The treatments the drug was used in", + "synonyms": ["therapies", "uses", "regimens", "prescriptions"] + }, + { + "name": "diagnosis", + "type": "simple join", + "parent collection": "treatments", + "child collection": "diagnoses", + "singular": true, + "always matches": true, + "keys": { + "diagnosis_id": [ + "_id" + ] + }, + "description": "The diagnosis associated with the treatment which the drug is treating", + "synonyms": ["medical condition", "associated condition", "cause of treatment"] + }, + { + "name": "treatments_for", + "type": "reverse", + "original parent": "treatments", + "original property": "diagnosis", + "singular": false, + "always matches": false, + "description": "The drug treatment regimens targeted at a patient with this diagnosis", + "synonyms": [] + }, + { + "name": "outcome_records", + "type": "simple join", + "parent collection": "treatments", + "child collection": "outcomes", + "singular": false, + "always matches": false, + "keys": { + "treatment_id": [ + "treatment_id" + ] + }, + "description": "The reported outcomes of the treatment, which can include the same treatment at different points in time if not enough time has elapsed to record the complete outcome for a treatment", + "synonyms": ["quality reports", "evaluations", "assessments"] + }, + { + "name": "treatment", + "type": "reverse", + "original parent": "treatments", + "original property": "outcome_records", + "singular": true, + "always matches": true, + "description": "The treatment that the outcome record is reporting on", + "synonyms": ["regimen", "prescription", "medical trial"] + }, + { + "name": "concomitant_meds", + "type": "simple join", + "parent collection": "treatments", + "child collection": "concomitant_meds", + "singular": false, + "always matches": false, + "keys": { + "treatment_id": [ + "treatment_id" + ] + }, + "description": "The ancillary medications that were taken by a patient in addition to the treatment they are receiving during their treatment", + "synonyms": ["additional drugs", "ancillary medications", "concomitant drugs", "accompanying medications", "concurrent drugs"] + }, + { + "name": "treatment", + "type": "reverse", + "original parent": "treatments", + "original property": "concomitant_meds", + "singular": true, + "always matches": true, + "description": "The treatment that the administration of the concomitant medication was related to", + "synonyms": ["medical trial", "regimen", "main prescription"] + }, + { + "name": "adverse_events", + "type": "simple join", + "parent collection": "treatments", + "child collection": "adverse_events", + "singular": false, + "always matches": false, + "keys": { + "treatment_id": [ + "treatment_id" + ] + }, + "description": "Any incident events recorded in association with the treatment", + "synonyms": ["side effects", "medical incidents"] + }, + { + "name": "treatment", + "type": "reverse", + "original parent": "treatments", + "original property": "adverse_events", + "singular": true, + "always matches": true, + "description": "The treatment that the adverse event occurred during", + "synonyms": ["regimen", "medical trial", "prescription"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "Ewallet", + "version": "V2", + "collections": [ + { + "name": "users", + "type": "simple table", + "table path": "users", + "unique properties": ["uid", "username"], + "properties": [ + { + "name": "uid", + "type": "table column", + "column name": "uid", + "data type": "numeric", + "description": "The unique identifier for each user in the system", + "sample values": [1, 3, 5, 10, 11], + "synonyms": ["user id", "user key"] + }, + { + "name": "username", + "type": "table column", + "column name": "username", + "data type": "string", + "description": "The username for the user", + "sample values": ["john_doe", "michael_brown", "bizuser", "huang2143"], + "synonyms": ["name", "account profile"] + }, + { + "name": "email", + "type": "table column", + "column name": "email", + "data type": "string", + "description": "The email for the user", + "sample values": ["john.doe@email.com", "lisa.jones@email.com", "customerserv@shopsmart.biz", "huang2143@example.com", "contact@business.co"], + "synonyms": ["email address", "contact email"] + }, + { + "name": "phone_number", + "type": "table column", + "column name": "phone_number", + "data type": "string", + "description": "The phone number for the user (null if not provided), which always starts with a `+` and the country code and does not have dashes", + "sample values": ["+1234567890", "+9876543210", "+8091017161", "+8612345678901", "+6123456789"], + "synonyms": ["phone", "mobile number", "contact number"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the user account was created", + "synonyms": ["account creation date", "registration datetime"] + }, + { + "name": "last_login_at", + "type": "table column", + "column name": "last_login_at", + "data type": "datetime", + "description": "The last time the user logged into their account (null if never logged in)", + "synonyms": ["most recent login datetime", "latest access timestmap"] + }, + { + "name": "user_type", + "type": "table column", + "column name": "user_type", + "data type": "string", + "description": "The type of user, which can be either `individual` or `business`", + "sample values": ["individual", "business"], + "synonyms": ["category", "classification"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the user account, which can be either `active`, `inactive`, `deleted` or `suspended`", + "sample values": ["active", "inactive", "suspended", "deleted"], + "synonyms": ["account state", "activity", "user status"] + }, + { + "name": "country", + "type": "table column", + "column name": "country", + "data type": "string", + "description": "The two-letter country code for the country of the user", + "sample values": ["US", "CA", "FR", "GB", "AU"], + "synonyms": ["nation"] + }, + { + "name": "address_billing", + "type": "table column", + "column name": "address_billing", + "data type": "string", + "description": "The billing address for the user, including street address, city, sometimes province/country, and postal code", + "sample values": ["123 Main St, Anytown US 12345", "456 Oak Rd, Toronto ON M1M2M2", "12 Rue Baptiste, Paris 75001", "12 Mardon Rd, Wellington 6012"], + "synonyms": ["billing location", "billing street address"] + }, + { + "name": "address_delivery", + "type": "table column", + "column name": "address_delivery", + "data type": "string", + "description": "The delivery address for the user, including street address, city, sometimes province/country, and postal code, or null if not provided", + "sample values": ["123 Main St, Anytown US 12345", "25 London Road, Manchester M12 4XY", "19 Smith St, Brunswick VIC 3056"], + "synonyms": [] + }, + { + "name": "kyc_status", + "type": "table column", + "column name": "kyc_status", + "data type": "string", + "description": "The KYC status, which can be either `approved`, `pending`, or `rejected`", + "sample values": ["approved", "pending", "rejected"], + "synonyms": ["approval status", "verification status"] + }, + { + "name": "kyc_verified_at", + "type": "table column", + "column name": "kyc_verified_at", + "data type": "datetime", + "description": "The date when the kyc status became verified (null if not provided)", + "synonyms": ["date of approval", "date of verification"] + } + ], + "description": "Every user in the system, which can be either an individual or a business", + "synonyms": ["accounts", "user profiles", "user accounts", "clients", "consumers"] + }, + { + "name": "merchants", + "type": "simple table", + "table path": "merchants", + "unique properties": ["mid", "name"], + "properties": [ + { + "name": "mid", + "type": "table column", + "column name": "mid", + "data type": "numeric", + "description": "Unique identifier for each merchant in the system", + "sample values": [1, 5, 10, 12, 15], + "synonyms": ["merchant key", "merchant id"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the merchant", + "sample values": ["TechMart", "FitLifeGear", "UrbanDining", "KidzPlayhouse", "GameRush"], + "synonyms": ["merchant name", "business name", "company name"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "The detailed description of what the merchant does or sells", + "sample values": ["Leading electronics retailer", "SaaS productivity tools for developers", "Cosmetics and beauty supplies", "Books and reading accessories"], + "synonyms": ["business industry description", "merchant product types", "market segment description", "company description"] + }, + { + "name": "website_url", + "type": "table column", + "column name": "website_url", + "data type": "string", + "description": "The URL to the merchant's website", + "sample values": ["https://fitlifegear.com", "https://hometechsolutions.net", "https://bookworms.co.uk", "https://www.zenhomegoods.com'"], + "synonyms": ["website link", "web address"] + }, + { + "name": "logo_url", + "type": "table column", + "column name": "logo_url", + "data type": "string", + "description": "The URL to the merchant's logo image", + "sample values": ["https://www.techmart.com/logo.png", "https://www.fashiontrend.com/logo.png", "https://gamerush.co/gr-logo.png", "https://kidzplayhouse.com/logo.png"], + "synonyms": ["image link", "logo image address"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the merchant was registered in the system", + "synonyms": ["merchant registration date", "merchant creation date"] + }, + { + "name": "country", + "type": "table column", + "column name": "country", + "data type": "string", + "description": "The two-letter capitalized country code for the country of the merchant", + "sample values": ["US", "CA", "IT", "FR", "UK"], + "synonyms": ["nation"] + }, + { + "name": "state", + "type": "table column", + "column name": "state", + "data type": "string", + "description": "The state for the merchant within the country, or null if not applicable", + "sample values": ["California", "Ontario", "Catalonia", "New South Wales", "British Columbia"], + "synonyms": ["province"] + }, + { + "name": "city", + "type": "table column", + "column name": "city", + "data type": "string", + "description": "The city for the merchant's location within the country", + "sample values": ["Los Angeles", "Berlin", "Rome", "Vancouver", "Sydney"] + }, + { + "name": "postal_code", + "type": "table column", + "column name": "postal_code", + "data type": "string", + "description": "The postal/zip code of the merchant's location within the city", + "sample values": ["90011", "M5V2J2", "1010", "94105"], + "synonyms": ["zip code"] + }, + { + "name": "address", + "type": "table column", + "column name": "address", + "data type": "string", + "description": "The full address of the merchant, including street address, city, sometimes province, and postal code", + "sample values": ["645 Wilshire Blvd, Los Angeles CA 90011", "159 Franklin St, Melbourne VIC 3004", "350 Mission St, San Francisco CA 94105", "35 Rue du Faubourg Saint-Antoine, 75011 Paris", "Passeig de Gracia 35, Barcelona 08003"], + "synonyms": ["street address", "full location"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the merchant account, which can be either `active`, `inactive` or `suspended`", + "sample values": ["active", "inactive", "suspended"], + "synonyms": ["account state", "activity", "merchant status"] + }, + { + "name": "category", + "type": "table column", + "column name": "category", + "data type": "string", + "description": "The blanket category/industry/market segment that the merchant is in", + "sample values": ["retail (hardware)", "Food & Dining", "Travel & Hospitality", "Retail", "Business Services"], + "synonyms": ["industry", "high-level market segment"] + }, + { + "name": "sub_category", + "type": "table column", + "column name": "sub_category", + "data type": "string", + "description": "The more specific category/industry/market segment that the merchant is in within the category", + "sample values": ["Electronics", "Sporting GOods", "Restaurants", "Accommodation", "Toys & Games", "Books", "Pets", "Groceries"], + "synonyms": ["sub-industry", "specific market segment"] + }, + { + "name": "merchant_category_code", + "type": "table column", + "column name": "mcc", + "data type": "numeric", + "description": "The category code for the merchant, which is a 4-digit number that identifies the type of business", + "sample values": [5734, 5977, 7011, 5719, 5732], + "synonyms": [] + }, + { + "name": "contact_name", + "type": "table column", + "column name": "contact_name", + "data type": "string", + "description": "The full name of the individual who is the primary contact for the merchant", + "sample values": ["John Jacobs", "Daniel Lee", "Marco Rossi", "Sophia Turner"], + "synonyms": ["contact person", "contact individual"] + }, + { + "name": "contact_email", + "type": "table column", + "column name": "contact_email", + "data type": "string", + "description": "The email of the contact person for the merchant", + "sample values": ["jjacobs@techmart.com", "dlee@greengourmet.com", "ebrown@hometechsolutions.net", "sturner@bookworms.co.uk", "mschmidt@codesuite.io", "agarcia@handycraft.store"], + "synonyms": ["contact email", "contact person email"] + }, + { + "name": "contact_phone", + "type": "table column", + "column name": "contact_phone", + "data type": "string", + "description": "The phone number of the contact person, which always starts with a `+` and the country code and does not have dashes", + "sample values": ["+15551234567", "+49301234567", "+441612345678", "+61298765432", "+442078912345"], + "synonyms": ["contact phone number", "contact person phone"] + } + ], + "description": "The merchant accounts registered in the system", + "synonyms": ["companies", "businesses", "vendors", "retailers", "stores"] + }, + { + "name": "coupons", + "type": "simple table", + "table path": "coupons", + "unique properties": ["cid"], + "properties": [ + { + "name": "cid", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "The unique identifier for each coupon in the system", + "sample values": [1, 4, 5, 7, 10], + "synonyms": ["coupon key", "coupon id"] + }, + { + "name": "merchant_id", + "type": "table column", + "column name": "merchant_id", + "data type": "numeric", + "description": "The id of the merchant who issues the coupon", + "sample values": [2, 5, 7, 8, 9], + "synonyms": ["merchant key", "merchant id", "issuing business id"] + }, + { + "name": "code", + "type": "table column", + "column name": "code", + "data type": "string", + "description": "The code used to enter the coupon", + "sample values": ["TECH20", "DINEDISCOUNT", "HOME15", "GLOWUP", "GAMERALERT"], + "synonyms": ["coupon code", "discount code", "promo code"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "A verbal description of what hte coupon is for", + "sample values": ["20% off tech and electronics", "Buy 2 get 1 free on cosmetics'", "Get 25% off accessories", "$10 off $75+ purchase"], + "synonyms": [] + }, + { + "name": "start_date", + "type": "table column", + "column name": "start_date", + "data type": "datetime", + "description": "The date when the coupon first became valid", + "synonyms": ["available since", "valid from"] + }, + { + "name": "end_date", + "type": "table column", + "column name": "end_date", + "data type": "datetime", + "description": "The date when the coupon is no longer valid", + "synonyms": ["available until", "valid until", "expiration date"] + }, + { + "name": "discount_type", + "type": "table column", + "column name": "discount_type", + "data type": "string", + "description": "The category of the coupon, which can be either `percentage` or `fixed_amount`", + "sample values": ["percentage", "fixed_amount"], + "synonyms": ["classification", "category"] + }, + { + "name": "discount_value", + "type": "table column", + "column name": "discount_value", + "data type": "numeric", + "description": "The value of the discount, which is the percentage off if the discount type is `percentage`, or the number of dollars off if `fixed_amount`", + "sample values": [20.0, 30.0, 10.0, 15.0, 25.0], + "synonyms": ["dollars off", "percentage off", "amount", "size"] + }, + { + "name": "min_purchase_amount", + "type": "table column", + "column name": "min_purchase_amount", + "data type": "numeric", + "description": "The minimum amount of money that must be spent on a purchase in USD to be eligible for the coupon (null if not applicable)", + "sample values": [100.0, 50.0, 1000.0, 150.0], + "synonyms": ["minimum spend", "minimum purchase", "minimum order price"] + }, + { + "name": "max_discount_amount", + "type": "table column", + "column name": "max_discount_amount", + "data type": "numeric", + "description": "The maximum amount of money that can be saved using the coupon in USD (null if not applicable)", + "sample values": [50.0, 300.0, 10.0, 15.0], + "synonyms": ["promotion limit", "discount cap", "maximum savings"] + }, + { + "name": "redemption_limit", + "type": "table column", + "column name": "redemption_limit", + "data type": "numeric", + "description": "The maximum number of times the coupon can be redeemed before expiring/becoming invalid (null if not applicable)", + "sample values": [500, 1000, 200, 300, 750], + "synonyms": ["maximum number of uses", "redemption cap", "usage limit"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the coupon, which can be either `active`, `inactive`, or `expired`", + "sample values": ["active", "inactive", "expired"], + "synonyms": ["availability", "usability", "activity state"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "Timestamp when the coupon record was created in the system", + "synonyms": ["creation datetime"] + }, + { + "name": "updated_at", + "type": "table column", + "column name": "updated_at", + "data type": "datetime", + "description": "Timestamp when the coupon record was last updated in the system (null if never updated after creation)", + "synonyms": ["update datetime"] + } + ], + "description": "The records of coupons that have been issued by merchants in the system", + "synonyms": ["discounts", "promotions", "special offers"] + }, + { + "name": "transactions", + "type": "simple table", + "table path": "wallet_transactions_daily", + "unique properties": ["txid", "transaction_ref"], + "properties": [ + { + "name": "txid", + "type": "table column", + "column name": "txid", + "data type": "numeric", + "description": "The unique identifier for each transaction in the system (the original transaction & coupon applied are different rows with different values of this key)", + "sample values": [1, 3, 17, 21, 26], + "synonyms": ["transaction key", "transaction id"] + }, + { + "name": "sender_id", + "type": "table column", + "column name": "sender_id", + "data type": "numeric", + "description": "The id of the key of the individual who sent the transaction, which is either the id of a user or a merchant, depending on sender_type", + "sample values": [1, 3, 8, 4, 10], + "synonyms": [] + }, + { + "name": "sender_type", + "type": "table column", + "column name": "sender_type", + "data type": "numeric", + "description": "Which type of individual sent the transaction: 0 for user (meaning sender_id is a uid from users) or 1 for merchant (meaning sender_id is a mid from merchants)", + "sample values": [0, 1], + "synonyms": ["sent by merchant"] + }, + { + "name": "receiver_id", + "type": "table column", + "column name": "receiver_id", + "data type": "numeric", + "description": "The id of the key of the individual who received the transaction, which is either the id of a user or a merchant, depending on receiver_type", + "sample values": [1, 9, 10, 2, 5], + "synonyms": [] + }, + { + "name": "receiver_type", + "type": "table column", + "column name": "receiver_type", + "data type": "numeric", + "description": "Which type of individual received the transaction: 0 for user (meaning receiver_id is a uid from users) or 1 for merchant (meaning receiver_id is a mid from merchants)", + "sample values": [0, 1], + "synonyms": ["received by merchant"] + }, + { + "name": "amount", + "type": "table column", + "column name": "amount", + "data type": "numeric", + "description": "The dollar amount of the transaction, which is the total amount for a record without a coupon applied, or the amount saved/rebated when the coupon is applied", + "sample values": [99.99, 20.0, 16.0, 125.50, 10.0], + "synonyms": [] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the transaction, which can be either `success`, `failed`, `refunded`, or `pending`", + "sample values": ["success", "failed", "pending", "refunded"], + "synonyms": ["outcome", "result", "transaction status"] + }, + { + "name": "transaction_type", + "type": "table column", + "column name": "type", + "data type": "string", + "description": "The means the transaction was made, which can be either `credit` or `debit", + "sample values": ["credit", "debit"], + "synonyms": ["payment method", "credit or debit"] + }, + { + "name": "description", + "type": "table column", + "column name": "description", + "data type": "string", + "description": "The category of transaction, which either says what was purchased or 'Coupon discount' if the transaction is a coupon discount being applied to a previous transaction in the system", + "sample values": ["Online purchase", "Coupon discount", "Product purchase", "Order #438721", "Villa rental deposit", "Refund on order #1234"], + "synonyms": ["description of purchase", "purchase subject"] + }, + { + "name": "coupon_id", + "type": "table column", + "column name": "coupon_id", + "data type": "numeric", + "description": "The id of the coupon being used in the transaction, or null if the transaction is not a coupon discount", + "sample values": [1, 3, 9, 10], + "synonyms": ["coupon key", "coupon id"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the transfer was created in the system", + "synonyms": ["creation datetime"] + }, + { + "name": "completed_at", + "type": "table column", + "column name": "completed_at", + "data type": "datetime", + "description": "The timestamp when the transfer was completed (null if not completed yet)", + "synonyms": ["completion datetime"] + }, + { + "name": "transaction_ref", + "type": "table column", + "column name": "transaction_ref", + "data type": "string", + "description": "Randomly generated uuid4 for users' reference", + "sample values": ["ad154bf7-8185-4230-a8d8-3ef59b4e0012", "kd454bf7-428d-eig2-a8d8-3ef59b4e0012", "a7659c81-0cd0-4635-af6c-cf68d2c15ab2'"], + "synonyms": ["transaction uuid", "reference number"] + }, + { + "name": "gateway_name", + "type": "table column", + "column name": "gateway_name", + "data type": "string", + "description": "The portal through which the transaction was made, which can be either 'Stripe', 'PayPal', 'Checkout.com', 'Braintree' or 'Adyen'", + "sample values": ["Stripe", "PayPal", "Checkout.com", "Braintree", "Adyen"], + "synonyms": ["payment gateway", "payment processor", "payment portal"] + }, + { + "name": "gateway_ref", + "type": "table column", + "column name": "gateway_ref", + "data type": "string", + "description": "A reference number generated by the payment gateway for the transaction, which is used to track the transaction in the payment processor's system", + "sample values": ["tx_123abc456def", "rfnd_xkt521", "sub_pjj908", "stripe_ref_11_1", "paypal_ref_12_1"], + "synonyms": ["gateway reference number", "payment processor reference"] + }, + { + "name": "device_id", + "type": "table column", + "column name": "device_id", + "data type": "string", + "description": "The unique identifier for the device used to make the transaction", + "sample values": ["mobile_8fh2k1", "web_8902wknz", "web_zld22f", "device_11_1", "mobile_1av8p0"], + "synonyms": ["device key", "device identifier", "device number"] + }, + { + "name": "ip_address", + "type": "table column", + "column name": "ip_address", + "data type": "string", + "description": "The IP address of the device used to make the transaction", + "sample values": ["199.59.148.201", "199.59.148.201", "70.121.39.25", "8.26.53.165"], + "synonyms": ["IP"] + }, + { + "name": "user_agent", + "type": "table column", + "column name": "user_agent", + "data type": "string", + "description": "The user agent used to make the transaction, which is a string that identifies the browser, operating system, and device type of the device used to make the transaction", + "sample values": ["Mozilla/5.0 (iPhone; CPU iPhone OS 16_3_1 like Mac OS X) ...", "Mozilla/5.0 (Linux; Android 13; SM-S901B) ...", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ..."], + "synonyms": ["device information", "browser information", "device details"] + } + ], + "description": "Every transaction that has occurred in the system, where the source can be either a user or a merchant and the destination can be either a user or a merchant. If a coupon is used, there will be two identical transaction records, one for the original transaction (where the coupon id is null) and one for the coupon discount applied (where the coupon id is provided)", + "synonyms": ["transfers", "payments", "purchases"] + }, + { + "name": "user_balances", + "type": "simple table", + "table path": "wallet_user_balance_daily", + "unique properties": [["user_id", "updated_at"]], + "properties": [ + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id of the user whose account balance is being recorded", + "sample values": [1, 4, 9, 10, 5], + "synonyms": ["user id", "user key"] + }, + { + "name": "balance", + "type": "table column", + "column name": "balance", + "data type": "numeric", + "description": "The balance of the user's account in USD on the date of the record", + "sample values": [525.80, -725.55, -55.99, -559.98, 0.00, 2733.92], + "synonyms": ["amount in account", "user balance", "account value"] + }, + { + "name": "updated_at", + "type": "table column", + "column name": "updated_at", + "data type": "datetime", + "description": "The timestamp when the user's balance was recorded", + "synonyms": ["update datetime", "balance record date"] + } + ], + "description": "The records of users' account balances in the system, which can include negative balances and multiple records for the same user made at different points in time", + "synonyms": ["user balance histories", "user balance records", "user account balances"] + }, + { + "name": "merchant_balances", + "type": "simple table", + "table path": "wallet_merchant_balance_daily", + "unique properties": [["merchant_id", "updated_at"]], + "properties": [ + { + "name": "merchant_id", + "type": "table column", + "column name": "merchant_id", + "data type": "numeric", + "description": "The id of the merchant whose account balance is being recorded", + "sample values": [2, 4, 5, 9, 1], + "synonyms": ["merchant key", "merchant id"] + }, + { + "name": "balance", + "type": "table column", + "column name": "balance", + "data type": "numeric", + "description": "The balance of the user's account in USD on the date of the record", + "sample values": [3897.99, 29.95, 0.00, 89.99], + "synonyms": ["amount in account", "merchant balance", "account value"] + }, + { + "name": "updated_at", + "type": "table column", + "column name": "updated_at", + "data type": "datetime", + "description": "The timestamp when the merchant's balance was recorded", + "synonyms": ["update datetime", "balance record date"] + } + ], + "description": "The records of merchants' account balances in the system, which can include negative balances and multiple records for the same merchant made at different points in time", + "synonyms": ["merchant balance histories", "merchant balance records", "merchant account balances"] + }, + { + "name": "notifications", + "type": "simple table", + "table path": "notifications", + "unique properties": ["notif_id"], + "properties": [ + { + "name": "notif_id", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "The unique identifier for each notification in the system", + "sample values": [1, 5, 10, 14, 16], + "synonyms": ["notification key", "notification id"] + }, + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id for the user who received the notification", + "sample values": [3, 5, 9, 10], + "synonyms": ["user key", "user id"] + }, + { + "name": "message", + "type": "table column", + "column name": "message", + "data type": "string", + "description": "The message contained in the notification sent to the user", + "sample values": ["Your order #123abc has been shipped!", "Your CodeSuite subscription will renew on 7/1", "Here''s $10 to start your glow up!'", "Reminder: Your FitLife membership expires in 7 days", "An order from UrbanDining was unsuccessful", "Weekend Flash Sale: 25% off all activewear!"], + "synonyms": ["contents", "text", "description"] + }, + { + "name": "notification_type", + "type": "table column", + "column name": "type", + "data type": "string", + "description": "The type of notification message, which can be either `transaction`, `promotion`, or `general`", + "sample values": ["transaction", "promotion", "general"], + "synonyms": ["message category", "alert classification"] + }, + { + "name": "status", + "type": "table column", + "column name": "status", + "data type": "string", + "description": "The status of the notification, which can be either `read`, `unread`, or `archived`", + "sample values": ["read", "unread", "archived"], + "synonyms": ["has been read"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the notification was created", + "synonyms": ["creation datetime", "notification creation date"] + }, + { + "name": "read_at", + "type": "table column", + "column name": "read_at", + "data type": "datetime", + "description": "The timestamp when the notification was read (null if not read yet)", + "synonyms": ["datetime read"] + }, + { + "name": "device_type", + "type": "table column", + "column name": "device_type", + "data type": "string", + "description": "The type of device/medium the notification was sent through, which can be either `mobile_app`, `email`, `sms`, or `web_app`", + "sample values": ["mobile_app", "email", "sms", "web_app"], + "synonyms": [] + }, + { + "name": "device_id", + "type": "table column", + "column name": "device_id", + "data type": "string", + "description": "The id of the device the notification was sent to, or null if the device type does not have device ids", + "sample values": ["mobile_8fh2k1", "web_d8180kaf", "mobile_8fh2k1"], + "synonyms": [] + }, + { + "name": "action_url", + "type": "table column", + "column name": "action_url", + "data type": "string", + "description": "The URL included in hte notification that the user can click on to take action; can be external https or deeplink url within the app", + "sample values": ["app://orders/123abc", "https://zenhomesurvey.com/order/c51e10d1", "https://kidzplayhouse.com/new-arrivals", "https://techmart.com/promo/TECH20"], + "synonyms": ["link", "notification hyperlink"] + } + ], + "description": "All notifications sent to users in the system, such as alerts, reminders, and promotional messages", + "synonyms": ["alerts", "messages"] + }, + { + "name": "user_sessions", + "type": "simple table", + "table path": "user_sessions", + "unique properties": [["user_id", "session_start"], ["user_id", "session_end"]], + "properties": [ + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id of the user who the session belongs to", + "sample values": [1, 2, 3, 8, 10], + "synonyms": ["user id", "user key"] + }, + { + "name": "session_start", + "type": "table column", + "column name": "session_start_ts", + "data type": "datetime", + "description": "The timestamp when the user session started", + "synonyms": ["beginning timestamp", "session initialization datetime"] + }, + { + "name": "session_end", + "type": "table column", + "column name": "session_end_ts", + "data type": "datetime", + "description": "The timestamp when the user session ended", + "synonyms": ["ending timestamp", "session termination datetime"] + }, + { + "name": "device_type", + "type": "table column", + "column name": "device_type", + "data type": "string", + "description": "The type of device the session was made with, which can be either `web_app` or `mobile_app`", + "sample values": ["web_app", "mobile_app"], + "synonyms": ["session device", "web or mobile"] + }, + { + "name": "device_id", + "type": "table column", + "column name": "device_id", + "data type": "string", + "description": "The id of the device the session was made with", + "sample values": ["web_d8180kaf", "mobile_g3mjfz", "web_zz91p44l", "web_8902wknz"], + "synonyms": [] + } + ], + "description": "The records of user sessions in the system, which can include multiple sessions for the same user made at different points in time, each session with a start/end timestamp", + "synonyms": ["system logs", "user activity logs", "user session records"] + }, + { + "name": "user_setting_snapshots", + "type": "simple table", + "table path": "user_setting_snapshot", + "unique properties": [["user_id", "snapshot_date"]], + "properties": [ + { + "name": "user_id", + "type": "table column", + "column name": "user_id", + "data type": "numeric", + "description": "The id for the user whose settings are being recorded", + "sample values": [1, 2, 3, 5, 9], + "synonyms": ["user key", "user id"] + }, + { + "name": "snapshot_date", + "type": "table column", + "column name": "snapshot_date", + "data type": "datetime", + "description": "The date when the setting snapshot was taken", + "synonyms": ["date of setting update", "recorded date"] + }, + { + "name": "daily_transaction_limit", + "type": "table column", + "column name": "tx_limit_daily", + "data type": "numeric", + "description": "The cap in settings of how much the user account allows to be spent in a single day", + "sample values": [1000.0, 500.0, 50.0, 250.0], + "synonyms": ["daily spending cap"] + }, + { + "name": "monthly_transaction_limit", + "type": "table column", + "column name": "tx_limit_monthly", + "data type": "numeric", + "description": "The cap in settings of how much the user account allows to be spent in a single month", + "sample values": [5000.0, 500.0, 2000.0, 1000.0], + "synonyms": ["monthly spending cap"] + }, + { + "name": "membership_status", + "type": "table column", + "column name": "membership_status", + "data type": "numeric", + "description": "The member's status level within the system: 0 for bronze, 1 for silver, 2 for gold, 3 for platinum, 4 for VIP", + "sample values": [0, 1, 2, 3, 4], + "synonyms": ["rank", "membership level", "membership tier"] + }, + { + "name": "password_hash", + "type": "table column", + "column name": "password_hash", + "data type": "string", + "description": "The hashed password of the user, which is used to verify the user's identity when they log in", + "sample values": ["bcryptHash($2yz9!&ka1)", "bcryptHash($2yz9!&ka1)", "bcryptHash(C0d3Rul3z!99)"], + "synonyms": [] + }, + { + "name": "api_key", + "type": "table column", + "column name": "api_key", + "data type": "string", + "description": "The user's API key, which is used to authenticate the user when they make API requests (null if not provided)", + "sample values": ["9d61c49b-8977-4914-a36b-80d1445e38fa", "6c03c175-9ac9-4854-b064-a3fff2c62e31"], + "synonyms": ["api token", "application programming interface key"] + }, + { + "name": "verified_devices", + "type": "table column", + "column name": "verified_devices", + "data type": "string", + "description": "A comma-separated list of the ids of the devices that have been verified for the user (null if not provided)", + "sample values": ["mobile_8fh2k1", "mobile_yjp08q, mobile_1av8p0", "web_k29qjd, mobile_x28qlj", "web_d8180kaf, mobile_q3mz8n"], + "synonyms": ["device list", "device ids"] + }, + { + "name": "verified_ips", + "type": "table column", + "column name": "verified_ips", + "data type": "string", + "description": "A comma-sparated list of the IP addresses that have been verified for the user (null if not provided)", + "sample values": ["8.26.53.165, 68.85.32.201", "203.96.81.36", "192.168.0.1", "198.51.100.233, 70.121.39.25"], + "synonyms": ["IP addresses", "IP list"] + }, + { + "name": "mfa_enabled", + "type": "table column", + "column name": "mfa_enabled", + "data type": "bool", + "description": "Whether the user has enabled multi-factor authentication (MFA) for their account", + "synonyms": ["has mfa"] + }, + { + "name": "marketing_opt_in", + "type": "table column", + "column name": "marketing_opt_in", + "data type": "bool", + "description": "Whether the user has opted in to receive marketing communications", + "synonyms": ["allowed marketing"] + }, + { + "name": "created_at", + "type": "table column", + "column name": "created_at", + "data type": "datetime", + "description": "The timestamp when the record was added to the system", + "synonyms": ["system entry date"] + } + ], + "description": "The records of user settings in the system, which can include multiple updates for the same user made at different points in time", + "synonyms": ["user settings history", "user settings records"] + } + ], + "relationships": [ + { + "name": "transactions_sent", + "type": "simple join", + "parent collection": "users", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "sender_id" + ] + }, + "description": "All transactions made where the user is the sender", + "synonyms": ["transactions from user"] + }, + { + "name": "sending_user", + "type": "reverse", + "original parent": "users", + "original property": "transactions_sent", + "singular": true, + "always matches": false, + "description": "The user who sent the transaction, if it was sent by a user (not found if it was sent by a merchant)", + "synonyms": ["source user", "originating user"] + }, + { + "name": "transactions_received", + "type": "simple join", + "parent collection": "users", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "receiver_id" + ] + }, + "description": "The transactions where the user was the recipient", + "synonyms": ["transactions to user"] + }, + { + "name": "receiving_user", + "type": "reverse", + "original parent": "users", + "original property": "transactions_received", + "singular": true, + "always matches": false, + "description": "The user who received the transaction, if it was received by a user (not found if it was received by a merchant)", + "synonyms": ["destination user", "receiving user account"] + }, + { + "name": "balances", + "type": "simple join", + "parent collection": "users", + "child collection": "user_balances", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The historical account balance for the user, which can include multiple updates over time", + "synonyms": ["historical account balance", "user balance history"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "balances", + "singular": true, + "always matches": true, + "description": "The user who the account balance belongs to", + "synonyms": ["customer"] + }, + { + "name": "notifications", + "type": "simple join", + "parent collection": "users", + "child collection": "notifications", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The notifications that have been sent to the user", + "synonyms": ["user notifications", "user alerts"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "notifications", + "singular": true, + "always matches": true, + "description": "The user who received the notification", + "synonyms": ["customer", "client", "user account"] + }, + { + "name": "sessions", + "type": "simple join", + "parent collection": "users", + "child collection": "user_sessions", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The login sessions by the user", + "synonyms": ["user login sessions", "session history"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "sessions", + "singular": true, + "description": "The user who the login session information belongs to", + "synonyms": ["customer", "client", "user account"] + }, + { + "name": "setting_snapshots", + "type": "simple join", + "parent collection": "users", + "child collection": "user_setting_snapshots", + "singular": false, + "always matches": false, + "keys": { + "uid": [ + "user_id" + ] + }, + "description": "The setting snapshot history for the user, which can include multiple updates over time", + "synonyms": ["setting history", "user setting snapshots"] + }, + { + "name": "user", + "type": "reverse", + "original parent": "users", + "original property": "setting_snapshots", + "singular": true, + "description": "The user who the setting snapshot belongs to", + "synonyms": ["customer", "client", "user account"] + }, + { + "name": "transactions_sent", + "type": "simple join", + "parent collection": "merchants", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "sender_id" + ] + }, + "description": "The transactions sent by the merchant", + "synonyms": ["merchant transactions sent", "merchant outgoing transactions"] + }, + { + "name": "sending_merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "transactions_sent", + "singular": true, + "always matches": false, + "description": "The merchant who sent the transaction, if it was sent by a merchant (not found if it was sent by a user)", + "synonyms": ["merchant source", "merchant origin"] + }, + { + "name": "transactions_received", + "type": "simple join", + "parent collection": "merchants", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "receiver_id" + ] + }, + "description": "The transactions received by the merchant", + "synonyms": ["merchant transactions received", "merchant incoming transactions"] + }, + { + "name": "receiving_merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "transactions_received", + "singular": true, + "always matches": false, + "description": "The merchant who received the transaction, if it was received by a merchant (not found if it was received by a user)", + "synonyms": ["merchant destination", "merchant recipient"] + }, + { + "name": "balances", + "type": "simple join", + "parent collection": "merchants", + "child collection": "merchant_balances", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "merchant_id" + ] + }, + "description": "The historical account balance for the merchant, which can include multiple updates over time", + "synonyms": ["historical account balance", "merchant balance history"] + }, + { + "name": "merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "balances", + "singular": true, + "always matches": true, + "description": "The merchant who the account balance information belongs to", + "synonyms": ["business", "company", "merchant account"] + }, + { + "name": "coupons", + "type": "simple join", + "parent collection": "merchants", + "child collection": "coupons", + "singular": false, + "always matches": false, + "keys": { + "mid": [ + "merchant_id" + ] + }, + "description": "The coupons issued by the merchant", + "synonyms": ["merchant coupons", "merchant discount codes"] + }, + { + "name": "merchant", + "type": "reverse", + "original parent": "merchants", + "original property": "coupons", + "singular": true, + "always matches": true, + "description": "The merchant who issued the coupon", + "synonyms": ["issuing company", "business"] + }, + { + "name": "transaction_used_in", + "type": "simple join", + "parent collection": "coupons", + "child collection": "transactions", + "singular": false, + "always matches": false, + "keys": { + "cid": [ + "coupon_id" + ] + }, + "description": "The transactions that the coupon was used in", + "synonyms": ["uses", "transactions with coupon"] + }, + { + "name": "coupon", + "type": "reverse", + "original parent": "coupons", + "original property": "transaction_used_in", + "singular": true, + "always matches": false, + "description": "The coupon that was used in the transaction, if one exists", + "synonyms": ["coupon used", "discount used"] + } + ], + "additional definitions": [], + "verified pydough analysis": [], + "extra semantic info": {} + }, + { + "name": "Academic", + "version": "V2", + "collections": [ + { + "name": "authors", + "type": "simple table", + "table path": "author", + "unique properties": [ + "author_id" + ], + "properties": [ + { + "name": "author_id", + "type": "table column", + "column name": "aid", + "data type": "numeric", + "description": "Unique identifier for each author", + "sample values": [1, 3, 5], + "synonyms": ["author id", "author identification"] + }, + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The hostname used for the author's website", + "sample values": ["www.larry.com", "www.noam.com"], + "synonyms": ["author url", "author website"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name and lastname of the author", + "sample values": ["Larry Summers", "Noam Shazeer"], + "synonyms": ["full name"] + }, + { + "name": "organization_id", + "type": "table column", + "column name": "oid", + "data type": "numeric", + "description": "The id of the organization the author is related to", + "sample values": [1, 2, 5], + "synonyms": ["oid", "org_id"] + } + ], + "description": "Contains details about the authors, including their id, name, homepage, and organization id.", + "synonyms": [] + }, + { + "name": "citations", + "type": "simple table", + "table path": "cite", + "unique properties": [ + ["cited", + "citing"] + ], + "properties": [ + { + "name": "cited", + "type": "table column", + "column name": "cited", + "data type": "numeric", + "description": "The id of the publication being referenced or cited.", + "sample values": [1, 2, 4], + "synonyms": [] + }, + { + "name": "citing", + "type": "table column", + "column name": "citing", + "data type": "numeric", + "description": "The id of the publication that is doing the referencing (the source paper that contains the citation).", + "sample values": [1, 2, 3], + "synonyms": [] + } + ], + "description": "Records of citation relationships between publications.", + "synonyms": [] + }, + { + "name": "conferences", + "type": "simple table", + "table path": "conference", + "unique properties": [ + "conference_id" + ], + "properties": [ + { + "name": "conference_id", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "Unique identifier for the conference.", + "sample values": [1, 2, 3], + "synonyms": ["conference id"] + }, + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The URL or homepage of the conference.", + "sample values": ["www.isa.com", "www.icml.com"], + "synonyms": ["conference website"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The full name or abbreviation of the conference.", + "sample values": ["ISA", "ICML"], + "synonyms": [] + } + ], + "description": "Contains details about academic conferences.", + "synonyms": ["meeting", "symposium"] + }, + { + "name": "domains", + "type": "simple table", + "table path": "domain", + "unique properties": [ + "domain_id" + ], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "Unique identifier for the academic domain or field.", + "sample values": [1, 3, 5], + "synonyms": [] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the academic domain", + "sample values": ["Data Science", "Computer Science"], + "synonyms": ["field name", "subject"] + } + ], + "description": "Records of different academic domains or areas of study", + "synonyms": ["field", "subject"] + }, + { + "name": "domains_authors", + "type": "simple table", + "table path": "domain_author", + "unique properties": [ + ["author_id", + "domain_id"] + ], + "properties": [ + { + "name": "author_id", + "type": "table column", + "column name": "aid", + "data type": "numeric", + "description": "The id of the author related to this domain", + "sample values": [1, 3, 5], + "synonyms": [] + }, + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain related to the author", + "sample values": [1, 3, 5], + "synonyms": [] + } + ], + "description": "The records of each author being associated with domains", + "synonyms": [] + }, + { + "name": "domains_conferences", + "type": "simple table", + "table path": "domain_conference", + "unique properties": [ + ["conference_id", + "domain_id"] + ], + "properties": [ + { + "name": "conference_id", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "The id for the conference related to this domain", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id for the domain related to the conference.", + "sample values": [2, 4, 5], + "synonyms": [] + } + ], + "description": "Describes the domains related to the different conferences", + "synonyms": ["conference subject"] + }, + { + "name": "domains_journals", + "type": "simple table", + "table path": "domain_journal", + "unique properties": [ + ["domain_id", + "journal_id"] + ], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain realated to this journal", + "sample values": [1,2,5], + "synonyms": [] + }, + { + "name": "journal_id", + "type": "table column", + "column name": "jid", + "data type": "numeric", + "description": "The id of the jornal that published about this domain", + "sample values": [2, 3, 4], + "synonyms": [] + } + ], + "description": "Records of domains being used by a journal", + "synonyms": ["journal domain", "journal field"] + }, + { + "name": "domains_keywords", + "type": "simple table", + "table path": "domain_keyword", + "unique properties": [ + ["domain_id", + "keyword_id"] + ], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain which is related to this keyword", + "sample values": [1, 2], + "synonyms": [] + }, + { + "name": "keyword_id", + "type": "table column", + "column name": "kid", + "data type": "numeric", + "description": "The id of the keyword used or connected to this domain or field", + "sample values": [2, 3], + "synonyms": [] + } + ], + "description": "Contains records of keywords that is related to a domain", + "synonyms": ["keyword domain"] + }, + { + "name": "domains_publications", + "type": "simple table", + "table path": "domain_publication", + "unique properties": [["domain_id", "publication_id"]], + "properties": [ + { + "name": "domain_id", + "type": "table column", + "column name": "did", + "data type": "numeric", + "description": "The id of the domain related to this publication", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The id of the publication about this domain", + "sample values": [2, 4, 5], + "synonyms": [] + } + ], + "description": "Records of the publication and its related domain or field", + "synonyms": ["publication field"] + }, + { + "name": "journals", + "type": "simple table", + "table path": "journal", + "unique properties": [ + "journal_id" + ], + "properties": [ + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The url of the journal", + "sample values": ["www.aijournal.com", "www.ml.com"], + "synonyms": ["website", "url"] + }, + { + "name": "journal_id", + "type": "table column", + "column name": "jid", + "data type": "numeric", + "description": "The id of the journal", + "sample values": [1, 2, 3], + "synonyms": ["journal id", "identification"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the journal", + "sample values": ["Nature", "Journal of Machine Learning Research"], + "synonyms": [] + } + ], + "description": "Contains details about the journals", + "synonyms": ["magazines", "newspapers"] + }, + { + "name": "keywords", + "type": "simple table", + "table path": "keyword", + "unique properties": [ + "keyword_id" + ], + "properties": [ + { + "name": "keyword", + "type": "table column", + "column name": "keyword", + "data type": "string", + "description": "The keyword itself", + "sample values": ["Neuroscience", "AI"], + "synonyms": [] + }, + { + "name": "keyword_id", + "type": "table column", + "column name": "kid", + "data type": "numeric", + "description": "The identificator of the keyword", + "sample values": [1, 2, 4], + "synonyms": ["keyword id"] + } + ], + "description": "Collection of keywords used in publications and domains", + "synonyms": [] + }, + { + "name": "organizations", + "type": "simple table", + "table path": "organization", + "unique properties": [ + "organization_id" + ], + "properties": [ + { + "name": "continent", + "type": "table column", + "column name": "continent", + "data type": "string", + "description": "The continent where the organization resides", + "sample values": ["North America", "Asia"], + "synonyms": ["location"] + }, + { + "name": "homepage", + "type": "table column", + "column name": "homepage", + "data type": "string", + "description": "The url of the organization's website", + "sample values": ["www.organization2.com", "www.epfl.com"], + "synonyms": ["website link"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the organization", + "sample values": ["Γ‰cole Polytechnique FΓ©dΓ©rale de Lausanne 4", "Organization 2"], + "synonyms": ["oranization name"] + }, + { + "name": "organization_id", + "type": "table column", + "column name": "oid", + "data type": "numeric", + "description": "The identifier for the organization", + "sample values": [1, 3, 5], + "synonyms": ["id", "oid"] + } + ], + "description": "Records of the existing organizations, including continent, name, homepage and id", + "synonyms": ["institutions"] + }, + { + "name": "publications", + "type": "simple table", + "table path": "publication", + "unique properties": [ + "publication_id" + ], + "properties": [ + { + "name": "abstract", + "type": "table column", + "column name": "abstract", + "data type": "string", + "description": "Summary of the publication", + "sample values": ["Abstract 1", "Abstract 2"], + "synonyms": ["summary"] + }, + { + "name": "conference_id", + "type": "table column", + "column name": "cid", + "data type": "numeric", + "description": "The id of the conference related to this publication", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "citation_num", + "type": "table column", + "column name": "citation_num", + "data type": "numeric", + "description": "The number of times this publication was cited", + "sample values": [4, 2, 0], + "synonyms": [] + }, + { + "name": "journal_id", + "type": "table column", + "column name": "jid", + "data type": "numeric", + "description": "The id of the journal that publish this publication", + "sample values": [1, 2, 4], + "synonyms": [] + }, + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The unique idetifier for the publication", + "sample values": [1, 2, 5], + "synonyms": [] + }, + { + "name": "reference_num", + "type": "table column", + "column name": "reference_num", + "data type": "numeric", + "description": "The total number of external references made by this publication.", + "sample values": [0, 1, 4], + "synonyms": [] + }, + { + "name": "title", + "type": "table column", + "column name": "title", + "data type": "string", + "description": "The title of the paper or article.", + "sample values": ["Attention is all you need", "Optimizing GPU Throughput"], + "synonyms": [] + }, + { + "name": "year", + "type": "table column", + "column name": "year", + "data type": "numeric", + "description": "The year when the publication was published", + "sample values": [2021, 2020], + "synonyms": [] + } + ], + "description": "Stores core information about academic papers, articles, or other publications.", + "synonyms": [] + }, + { + "name": "publications_keywords", + "type": "simple table", + "table path": "publication_keyword", + "unique properties": [["publication_id", "keyword_id"]], + "properties": [ + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The id of the publication related to the keyword", + "sample values": [1, 2], + "synonyms": [] + }, + { + "name": "keyword_id", + "type": "table column", + "column name": "kid", + "data type": "numeric", + "description": "The id of the keyword used in the publication", + "sample values": [2, 3], + "synonyms": [] + } + ], + "description": "Records of keyword used in publication", + "synonyms": [] + }, + { + "name": "writes", + "type": "simple table", + "table path": "writes", + "unique properties": [["author_id", "publication_id"]], + "properties": [ + { + "name": "author_id", + "type": "table column", + "column name": "aid", + "data type": "numeric", + "description": "The author or co-author of the publication", + "sample values": [1, 2, 3], + "synonyms": [] + }, + { + "name": "publication_id", + "type": "table column", + "column name": "pid", + "data type": "numeric", + "description": "The publication related to the author", + "sample values": [1, 2, 3], + "synonyms": [] + } + ], + "description": "Records of authors and its publications", + "synonyms": [] + } + ], + "relationships": [ + { + "type": "simple join", + "name": "authors", + "parent collection": "organizations", + "child collection": "authors", + "singular": false, + "always matches": false, + "keys": { + "organization_id": [ + "organization_id" + ] + }, + "description": "All authors that belongs to this organization", + "synonyms": [] + }, + { + "type": "reverse", + "name": "organization", + "original parent": "organizations", + "original property": "authors", + "singular": true, + "always matches": false, + "description": "The oranization that the author belongs to", + "synonyms": [] + }, + { + "type": "simple join", + "name": "references", + "parent collection": "publications", + "child collection": "citations", + "singular": true, + "always matches": false, + "keys": { + "publication_id": [ + "citing" + ] + }, + "description": "All the citations this publication contains", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication_citing", + "original parent": "publications", + "original property": "references", + "singular": true, + "always matches": true, + "description": "The publication citing", + "synonyms": [] + }, + { + "type": "simple join", + "name": "cited_by", + "parent collection": "publications", + "child collection": "citations", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "cited" + ] + }, + "description": "All citations of the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication_cited", + "original parent": "publications", + "original property": "cited_by", + "singular": true, + "always matches": true, + "description": "The publication cited", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_authors", + "parent collection": "domains", + "child collection": "domains_authors", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The id of the authors related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_authors", + "singular": true, + "always matches": true, + "description": "The domain related to the author id", + "synonyms": [] + }, + { + "type": "simple join", + "name": "author_domains", + "parent collection": "authors", + "child collection": "domains_authors", + "singular": false, + "always matches": false, + "keys": { + "author_id": [ + "author_id" + ] + }, + "description": "The domains id for this author", + "synonyms": [] + }, + { + "type": "reverse", + "name": "author", + "original parent": "authors", + "original property": "author_domains", + "singular": true, + "always matches": true, + "description": "The author related to this domain_author", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_conferences", + "parent collection": "domains", + "child collection": "domains_conferences", + "singular": false, + "always matches": true, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_conferences related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_conferences", + "singular": true, + "always matches": true, + "description": "The domain related to the domain_conference", + "synonyms": [] + }, + { + "type": "simple join", + "name": "conference_domains", + "parent collection": "conferences", + "child collection": "domains_conferences", + "singular": false, + "always matches": false, + "keys": { + "conference_id": [ + "conference_id" + ] + }, + "description": "The domain_conference related to the conference", + "synonyms": [] + }, + { + "type": "reverse", + "name": "conference", + "original parent": "conferences", + "original property": "conference_domains", + "singular": true, + "always matches": true, + "description": "The conference related to the domain_conference", + "synonyms": [] + }, + { + "type": "simple join", + "name": "journal_domains", + "parent collection": "journals", + "child collection": "domains_journals", + "singular": false, + "always matches": false, + "keys": { + "journal_id": [ + "journal_id" + ] + }, + "description": "The domains_journal related to the journal", + "synonyms": [] + }, + { + "type": "reverse", + "name": "journal", + "original parent": "journals", + "original property": "journal_domains", + "singular": true, + "always matches": true, + "description": "The journal related to the domain_journal", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_journals", + "parent collection": "domains", + "child collection": "domains_journals", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_journal related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_journals", + "singular": true, + "always matches": true, + "description": "The domain linked with the domain_journal", + "synonyms": [] + }, + { + "type": "simple join", + "name": "keyword_domains", + "parent collection": "keywords", + "child collection": "domains_keywords", + "singular": false, + "always matches": false, + "keys": { + "keyword_id": [ + "keyword_id" + ] + }, + "description": "The domain_keywords related to the keyword", + "synonyms": [] + }, + { + "type": "reverse", + "name": "keyword", + "original parent": "keywords", + "original property": "keyword_domains", + "singular": true, + "always matches": true, + "description": "The keyword related to the domain_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_keywords", + "parent collection": "domains", + "child collection": "domains_keywords", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_keywords related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_keywords", + "singular": true, + "always matches": true, + "description": "The keyword linked to the domain_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "publication_domains", + "parent collection": "publications", + "child collection": "domains_publications", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "publication_id" + ] + }, + "description": "The domain_publications related to the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication", + "original parent": "publications", + "original property": "publication_domains", + "singular": true, + "always matches": true, + "description": "The publication related to the domain_publication", + "synonyms": [] + }, + { + "type": "simple join", + "name": "domain_publications", + "parent collection": "domains", + "child collection": "domains_publications", + "singular": false, + "always matches": false, + "keys": { + "domain_id": [ + "domain_id" + ] + }, + "description": "The domain_publications related to the domain", + "synonyms": [] + }, + { + "type": "reverse", + "name": "domain", + "original parent": "domains", + "original property": "domain_publications", + "singular": true, + "always matches": true, + "description": "The domain related to the domain_publication", + "synonyms": [] + }, + { + "type": "simple join", + "name": "archives", + "parent collection": "journals", + "child collection": "publications", + "singular": false, + "always matches": false, + "keys": { + "journal_id": [ + "journal_id" + ] + }, + "description": "The publications related to the journal", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publisher", + "original parent": "journals", + "original property": "archives", + "singular": true, + "always matches": true, + "description": "The journal the published the publication", + "synonyms": [] + }, + { + "type": "simple join", + "name": "proceedings", + "parent collection": "conferences", + "child collection": "publications", + "singular": false, + "always matches": false, + "keys": { + "conference_id": [ + "conference_id" + ] + }, + "description": "The publications presented in the conference", + "synonyms": [] + }, + { + "type": "reverse", + "name": "conference", + "original parent": "conferences", + "original property": "proceedings", + "singular": true, + "always matches": false, + "description": "The conference where the publication was presented", + "synonyms": [] + }, + { + "type": "simple join", + "name": "keyword_publications", + "parent collection": "keywords", + "child collection": "publications_keywords", + "singular": false, + "always matches": false, + "keys": { + "keyword_id": [ + "keyword_id" + ] + }, + "description": "All publication_keywords related to the keyword", + "synonyms": [] + }, + { + "type": "reverse", + "name": "keyword", + "original parent": "keywords", + "original property": "keyword_publications", + "singular": true, + "always matches": true, + "description": "The keyword linked to the publication_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "publication_keywords", + "parent collection": "publications", + "child collection": "publications_keywords", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "publication_id" + ] + }, + "description": "All publication_keywords related to the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication", + "original parent": "publications", + "original property": "publication_keywords", + "singular": true, + "always matches": true, + "description": "The publication linked to the publication_keyword", + "synonyms": [] + }, + { + "type": "simple join", + "name": "publication_authors", + "parent collection": "publications", + "child collection": "writes", + "singular": false, + "always matches": false, + "keys": { + "publication_id": [ + "publication_id" + ] + }, + "description": "All authors id related to the publication", + "synonyms": [] + }, + { + "type": "reverse", + "name": "publication", + "original parent": "publications", + "original property": "publication_authors", + "singular": true, + "always matches": true, + "description": "The publication linked to the writes", + "synonyms": [] + }, + { + "type": "simple join", + "name": "author_publications", + "parent collection": "authors", + "child collection": "writes", + "singular": false, + "always matches": false, + "keys": { + "author_id": [ + "author_id" + ] + }, + "description": "The publications' id of the write related to the author", + "synonyms": [] + }, + { + "type": "reverse", + "name": "author", + "original parent": "authors", + "original property": "author_publications", + "singular": true, + "always matches": true, + "description": "The author related to the written", + "synonyms": [] + } + ] + }, + { + "name": "Restaurants", + "version": "V2", + "collections": [ + { + "name": "cities", + "type": "simple table", + "table path": "geographic", + "unique properties": [ + "city_name" + ], + "properties": [ + { + "name": "city_name", + "type": "table column", + "column name": "city_name", + "data type": "string", + "description": "The name of the city", + "sample values": ["Los Angeles", "Miami"], + "synonyms": ["city"] + }, + { + "name": "county", + "type": "table column", + "column name": "county", + "data type": "string", + "description": "The name of the county", + "sample values": ["Miami-Dade", "Cook", "New York"], + "synonyms": ["division"] + }, + { + "name": "region", + "type": "table column", + "column name": "region", + "data type": "string", + "description": "The name of the region", + "sample values": ["California", "New York"], + "synonyms": ["territory"] + } + ], + "description": "Contains records of cities locations including its name, county and region", + "synonyms": ["locations", "places"] + }, + { + "name": "locations", + "type": "simple table", + "table path": "location", + "unique properties": [ + ["restaurant_id", "house_number", "street_name","city_name"] + ], + "properties": [ + { + "name": "restaurant_id", + "type": "table column", + "column name": "restaurant_id", + "data type": "numeric", + "description": "Unique identifier for each restaurant", + "sample values": [1, 2, 3], + "synonyms": ["restaurant_id", "diner_id"] + }, + { + "name": "house_number", + "type": "table column", + "column name": "house_number", + "data type": "numeric", + "description": "The number assigned to the building where the restaurant is located", + "sample values": [123, 789, 12], + "synonyms": ["street_number"] + }, + { + "name": "street_name", + "type": "table column", + "column name": "street_name", + "data type": "string", + "description": "The name of the street where the restaurant is located", + "sample values": ["Main St", "Oak St", "Pine Ave"], + "synonyms": ["avenue"] + }, + { + "name": "city_name", + "type": "table column", + "column name": "city_name", + "data type": "string", + "description": "The name of the city where the restaurant is located", + "sample values": ["New York", "Los Angeles", "Miami"], + "synonyms": [] + } + ], + "description": "Contains the location of each restaurant", + "synonyms": ["address"] + }, + { + "name": "restaurants", + "type": "simple table", + "table path": "restaurant", + "unique properties": [ + "id_" + ], + "properties": [ + { + "name": "id_", + "type": "table column", + "column name": "id", + "data type": "numeric", + "description": "Unique identifier for each restaurant", + "sample values": [1, 2, 3], + "synonyms": ["identifier"] + }, + { + "name": "name", + "type": "table column", + "column name": "name", + "data type": "string", + "description": "The name of the restaurant", + "sample values": ["The Pasta House", "The Burger Joint", "The Seafood Shack"], + "synonyms": ["restaurant"] + }, + { + "name": "food_type", + "type": "table column", + "column name": "food_type", + "data type": "string", + "description": "The type of food served at the restaurant", + "sample values": ["Seafood", "American", "Japanese"], + "synonyms": ["specialty", "menu type"] + }, + { + "name": "city_name", + "type": "table column", + "column name": "city_name", + "data type": "string", + "description": "The city where the restaurant is located", + "sample values": ["San Francisco", "New York", "Miami"], + "synonyms": ["locality", "town"] + }, + { + "name": "rating", + "type": "table column", + "column name": "rating", + "data type": "numeric", + "description": "The rating of the restaurant on a scale of 0 to 5", + "sample values": [4.2, 3.9, 4.5], + "synonyms": ["score", "review"] + } + ], + "description": "Contains the information of the restaurants", + "synonyms": ["diner"] + } + ], + "relationships": [ + { + "type": "simple join", + "name": "restaurant_locations", + "parent collection": "cities", + "child collection": "locations", + "singular": false, + "always matches": false, + "keys": { + "city_name": [ + "city_name" + ] + }, + "description": "All restaurant locations within the city", + "synonyms": ["restaurant locations"] + }, + { + "type": "reverse", + "name": "city", + "original parent": "cities", + "original property": "restaurant_locations", + "singular": true, + "always matches": false, + "description": "The geographic information for the city that the location belongs to", + "synonyms": ["geography", "town"] + }, + { + "type": "simple join", + "name": "location", + "parent collection": "restaurants", + "child collection": "locations", + "singular": true, + "always matches": true, + "keys": { + "id_": [ + "restaurant_id" + ] + }, + "description": "The location of this restaurant", + "synonyms": ["place", "diner"] + }, + { + "type": "reverse", + "name": "restaurant", + "original parent": "restaurants", + "original property": "location", + "singular": true, + "always matches": true, + "description": "The restaurant related to this location", + "synonyms": ["franchise", "chain"] + }, + { + "type": "simple join", + "name": "restaurants", + "parent collection": "cities", + "child collection": "restaurants", + "singular": false, + "always matches": false, + "keys": { + "city_name": [ + "city_name" + ] + }, + "description": "The restaurants located in this geographic territory", + "synonyms": ["diners"] + }, + { + "type": "reverse", + "name": "city", + "original parent": "cities", + "original property": "restaurants", + "singular": true, + "always matches": true, + "description": "The geographic territory related to this restaurant", + "synonyms": ["location", "territory"] + } + ] + } +] diff --git a/tests/test_pipeline_oracle.py b/tests/test_pipeline_oracle.py new file mode 100644 index 000000000..abc910c20 --- /dev/null +++ b/tests/test_pipeline_oracle.py @@ -0,0 +1,282 @@ +""" +Integration tests for the PyDough workflow on the TPC-H queries using Oracle. +""" + +from collections.abc import Callable + +import pandas as pd +import pytest + +from pydough import init_pydough_context, to_df +from pydough.configs import PyDoughConfigs +from pydough.database_connectors import DatabaseContext +from pydough.metadata import GraphMetadata +from pydough.unqualified import ( + UnqualifiedNode, +) +from tests.test_pipeline_defog_custom import get_day_of_week, get_start_of_week +from tests.test_pydough_functions.simple_pydough_functions import ( + simple_week_sampler_tpch, +) +from tests.test_pydough_functions.tpch_outputs import ( + tpch_q16_output, +) +from tests.test_pydough_functions.tpch_test_functions import ( + impl_tpch_q16, +) +from tests.testing_utilities import ( + PyDoughPandasTest, + PyDoughSQLComparisonTest, + graph_fetcher, + harmonize_types, +) + +from .conftest import tpch_custom_test_data_dialect_replacements +from .test_pipeline_custom_datasets import custom_datasets_test_data # noqa +from .test_pipeline_defog import defog_pipeline_test_data # noqa +from .test_pipeline_defog_custom import defog_custom_pipeline_test_data # noqa +from .test_pipeline_tpch_custom import tpch_custom_pipeline_test_data # noqa + + +@pytest.fixture( + params=[ + pytest.param( + PyDoughPandasTest( + impl_tpch_q16, + "TPCH", + tpch_q16_output, + "tpch_q16_params", + ), + id="tpch_q16_params", + ), + ], +) +def tpch_oracle_params_test_data(request) -> PyDoughPandasTest: + """ + Test data for e2e tests for the TPC-H query 16. Returns an instance of + PyDoughPandasTest containing information about the test. + """ + return request.param + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch( + tpch_pipeline_test_data: PyDoughPandasTest, + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], # Fix this +): + """ + Test executing the TPC-H queries from the original code generation on Oracle. + """ + tpch_pipeline_test_data.run_e2e_test( + get_sample_graph, + oracle_conn_db_context("tpch"), + coerce_types=True, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch_16_params( + tpch_oracle_params_test_data: PyDoughPandasTest, + get_sample_graph: graph_fetcher, + oracle_params_tpch_db_context: DatabaseContext, +): + """ + Test executing the TPC-H 16 from the original code generation, + with oracle as the executing database. + Using the `user`, `password`, `database`, and `host` + as keyword arguments to the DatabaseContext. + """ + tpch_oracle_params_test_data.run_e2e_test( + get_sample_graph, oracle_params_tpch_db_context, coerce_types=True + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_custom_functions( + custom_functions_test_data: PyDoughPandasTest, + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the custom functions test data using TPCH with Oracle + """ + custom_functions_test_data.run_e2e_test( + get_sample_graph, oracle_conn_db_context("tpch"), coerce_types=True + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch_simple_week( + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], + week_handling_config: PyDoughConfigs, +): + """ + Test executing simple_week_sampler using the TPCH schemas with different + week configurations, comparing against expected results. + """ + graph: GraphMetadata = get_sample_graph("TPCH") + root: UnqualifiedNode = init_pydough_context(graph)(simple_week_sampler_tpch)() + result: pd.DataFrame = to_df( + root, + metadata=graph, + database=oracle_conn_db_context("tpch"), + config=week_handling_config, + ) + + # Generate expected DataFrame based on week_handling_config + start_of_week = week_handling_config.start_of_week + start_week_as_zero = week_handling_config.start_week_as_zero + + x_dt = pd.Timestamp(2025, 3, 10, 11, 0, 0) + y_dt = pd.Timestamp(2025, 3, 14, 11, 0, 0) + y_dt2 = pd.Timestamp(2025, 3, 15, 11, 0, 0) + y_dt3 = pd.Timestamp(2025, 3, 16, 11, 0, 0) + y_dt4 = pd.Timestamp(2025, 3, 17, 11, 0, 0) + y_dt5 = pd.Timestamp(2025, 3, 18, 11, 0, 0) + y_dt6 = pd.Timestamp(2025, 3, 19, 11, 0, 0) + y_dt7 = pd.Timestamp(2025, 3, 20, 11, 0, 0) + y_dt8 = pd.Timestamp(2025, 3, 21, 11, 0, 0) + + # Calculate weeks difference + x_sow = get_start_of_week(x_dt, start_of_week) + y_sow = get_start_of_week(y_dt, start_of_week) + weeks_diff = (y_sow - x_sow).days // 7 + + # Create lists to store calculated values + dates = [y_dt, y_dt2, y_dt3, y_dt4, y_dt5, y_dt6, y_dt7, y_dt8] + sows = [] + daynames = [] + dayofweeks = [] + + # Calculate values for each date in a loop + for dt in dates: + # Calculate start of week + sow = get_start_of_week(dt, start_of_week).strftime("%Y-%m-%d") + sows.append(sow) + + # Get day name + dayname = dt.day_name() + daynames.append(dayname) + + # Calculate day of week + dayofweek = get_day_of_week(dt, start_of_week, start_week_as_zero) + dayofweeks.append(dayofweek) + + # Create dictionary for DataFrame + data_dict = {"weeks_diff": [weeks_diff]} + + # Add start of week columns + for i in range(len(dates)): + data_dict[f"sow{i + 1}"] = [sows[i]] + + # Add day name columns + for i in range(len(dates)): + data_dict[f"dayname{i + 1}"] = [daynames[i]] + + # Add day of week columns + for i in range(len(dates)): + data_dict[f"dayofweek{i + 1}"] = [dayofweeks[i]] + + # Create DataFrame with expected results + expected_df = pd.DataFrame(data_dict) + + for col_name in result.columns: + result[col_name], expected_df[col_name] = harmonize_types( + result[col_name], expected_df[col_name] + ) + pd.testing.assert_frame_equal( + result, expected_df, check_dtype=False, check_exact=False, atol=1e-8 + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_tpch_custom( + tpch_custom_pipeline_test_data: PyDoughPandasTest, # noqa: F811 + get_sample_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the TPC-H custom queries from the original code generation on + Oracle. + """ + tpch_custom_pipeline_test_data = tpch_custom_test_data_dialect_replacements( + oracle_conn_db_context("tpch").dialect, tpch_custom_pipeline_test_data + ) + + tpch_custom_pipeline_test_data.run_e2e_test( + get_sample_graph, + oracle_conn_db_context("tpch"), + coerce_types=True, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_defog_custom( + defog_custom_pipeline_test_data: PyDoughPandasTest, # noqa: F811 + get_oracle_defog_graphs: graph_fetcher, + defog_config: PyDoughConfigs, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the defog analytical queries with Oracle database. + """ + defog_custom_pipeline_test_data.run_e2e_test( + get_oracle_defog_graphs, + oracle_conn_db_context(defog_custom_pipeline_test_data.graph_name.lower()), + config=defog_config, + coerce_types=True, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_defog( + defog_pipeline_test_data: PyDoughSQLComparisonTest, # noqa: F811 + get_oracle_defog_graphs: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], + defog_config: PyDoughConfigs, + sqlite_defog_connection: DatabaseContext, +) -> None: + """ + Test executing the defog analytical questions on the sqlite database, + comparing against the result of running the reference SQL query text on the + same database connector. Run on the defog.ai queries. + NOTE: passing SQLite connection as reference database so that refsol + is executed using SQLite. + This is needed because refsol uses SQLite SQL syntax to obtain + the correct results. + """ + defog_pipeline_test_data.run_e2e_test( + get_oracle_defog_graphs, + oracle_conn_db_context(defog_pipeline_test_data.graph_name.lower()), + defog_config, + reference_database=sqlite_defog_connection, + coerce_types=True, + rtol=1e4, + ) + + +@pytest.mark.oracle +@pytest.mark.execute +def test_pipeline_e2e_oracle_custom_datasets( + custom_datasets_test_data: PyDoughPandasTest, # noqa: F811 + get_custom_datasets_graph: graph_fetcher, + oracle_conn_db_context: Callable[[str], DatabaseContext], +): + """ + Test executing the the custom queries with the custom datasets against the + refsol DataFrame. + """ + custom_datasets_test_data.run_e2e_test( + get_custom_datasets_graph, + oracle_conn_db_context(custom_datasets_test_data.graph_name.lower()), + coerce_types=True, + ) diff --git a/tests/test_pydough_functions/simple_pydough_functions.py b/tests/test_pydough_functions/simple_pydough_functions.py index 1f23f5c10..13e4fa007 100644 --- a/tests/test_pydough_functions/simple_pydough_functions.py +++ b/tests/test_pydough_functions/simple_pydough_functions.py @@ -2908,6 +2908,45 @@ def string_format_specifiers_snowflake(): ) +def string_format_specifiers_oracle(): + # String format specifiers for date/time with a static datetime + # Works for Oracle + # Using a specific date: 2023-07-15 14:30:45 + static_date = pd.Timestamp("2023-07-15 14:30:45") + return TPCH.CALCULATE( + # four-digit year + d1=STRING(static_date, "YYYY"), + # last two digits of the year + d2=STRING(static_date, "YY"), + # two-digit month (01–12) + d3=STRING(static_date, "MM"), + # abbreviated month name + d4=STRING(static_date, "Mon"), + # full month name + d5=STRING(static_date, "MMMM"), + # two-digit day of month (01–31) + d6=STRING(static_date, "DD"), + # abbreviated day of week + d7=STRING(static_date, "DY"), + # full day of week + d8=STRING(static_date, "DYDY"), + # hour in 24-hour format (00–23) + d9=STRING(static_date, "HH24"), + # hour in 12-hour format (01–12) + d10=STRING(static_date, "HH12"), + # minute (00–59) + d11=STRING(static_date, "MI"), + # second (00–59) + d12=STRING(static_date, "SS"), + # meridian indicator + d13=STRING(static_date, "PM"), + # fractional seconds (up to 9 digits) + d14=STRING(static_date, ".FF"), + # timezone hour and minute + d15=STRING(static_date, "TZH:TZM"), + ) + + def part_reduced_size(): # What are the top 5 line items with the highest discounts # on parts with the lowest retail prices casted to integers? diff --git a/tests/test_sql_refsols/agg_partition_oracle.sql b/tests/test_sql_refsols/agg_partition_oracle.sql new file mode 100644 index 000000000..4c7136a01 --- /dev/null +++ b/tests/test_sql_refsols/agg_partition_oracle.sql @@ -0,0 +1,10 @@ +WITH _T0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) +) +SELECT + MAX(N_ROWS) AS best_year +FROM _T0 diff --git a/tests/test_sql_refsols/agg_simplification_1_oracle.sql b/tests/test_sql_refsols/agg_simplification_1_oracle.sql new file mode 100644 index 000000000..aed5a4ea4 --- /dev/null +++ b/tests/test_sql_refsols/agg_simplification_1_oracle.sql @@ -0,0 +1,237 @@ +WITH _T1 AS ( + SELECT + sbtickerexchange AS SBTICKEREXCHANGE, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 1 + ELSE NULL + END AS EXPR_72, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(2) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 2 + ELSE NULL + END AS EXPR_73, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(-1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN -1 + ELSE NULL + END AS EXPR_74, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(-3) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN -3 + ELSE NULL + END AS EXPR_75, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(0) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 0 + ELSE NULL + END AS EXPR_76, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') - 1.0 + ) - ( + ( + COUNT(0.5) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN 0.5 + ELSE NULL + END AS EXPR_77, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) + ELSE NULL + END AS EXPR_79, + CASE + WHEN FLOOR(0.9 * COUNT(1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')))) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 1 + ELSE NULL + END AS EXPR_80, + CASE + WHEN FLOOR(0.8 * COUNT(2) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')))) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 2 + ELSE NULL + END AS EXPR_81, + CASE + WHEN FLOOR( + 0.7 * COUNT(-1) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN -1 + ELSE NULL + END AS EXPR_82, + CASE + WHEN FLOOR( + 0.6 * COUNT(-3) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN -3 + ELSE NULL + END AS EXPR_83, + CASE + WHEN FLOOR(0.5 * COUNT(0) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')))) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 0 + ELSE NULL + END AS EXPR_84, + CASE + WHEN FLOOR( + 0.4 * COUNT(0.5) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY '1') + THEN 0.5 + ELSE NULL + END AS EXPR_85, + CASE + WHEN FLOOR( + 0.2 * COUNT(LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca'))) + ) < ROW_NUMBER() OVER (PARTITION BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) ORDER BY LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) DESC NULLS LAST) + THEN LENGTH(NULLIF(sbtickerexchange, 'NYSE Arca')) + ELSE NULL + END AS EXPR_87 + FROM MAIN.SBTICKER +), _T0 AS ( + SELECT + LENGTH(CASE WHEN SBTICKEREXCHANGE <> 'NYSE Arca' THEN SBTICKEREXCHANGE ELSE NULL END) AS AUG_EXCHANGE, + AVG(EXPR_72) AS AVG_EXPR_72, + AVG(EXPR_73) AS AVG_EXPR_73, + AVG(EXPR_74) AS AVG_EXPR_74, + AVG(EXPR_75) AS AVG_EXPR_75, + AVG(EXPR_76) AS AVG_EXPR_76, + AVG(EXPR_77) AS AVG_EXPR_77, + AVG(EXPR_79) AS AVG_EXPR_79, + MAX(EXPR_80) AS MAX_EXPR_80, + MAX(EXPR_81) AS MAX_EXPR_81, + MAX(EXPR_82) AS MAX_EXPR_82, + MAX(EXPR_83) AS MAX_EXPR_83, + MAX(EXPR_84) AS MAX_EXPR_84, + MAX(EXPR_85) AS MAX_EXPR_85, + MAX(EXPR_87) AS MAX_EXPR_87, + COUNT(*) AS N_ROWS + FROM _T1 + GROUP BY + LENGTH(CASE WHEN SBTICKEREXCHANGE <> 'NYSE Arca' THEN SBTICKEREXCHANGE ELSE NULL END) +) +SELECT + AUG_EXCHANGE AS aug_exchange, + N_ROWS AS su1, + N_ROWS * 2 AS su2, + N_ROWS * -1 AS su3, + N_ROWS * -3 AS su4, + 0 AS su5, + N_ROWS * 0.5 AS su6, + 0 AS su7, + NVL(AUG_EXCHANGE, 0) AS su8, + N_ROWS AS co1, + N_ROWS AS co2, + N_ROWS AS co3, + N_ROWS AS co4, + N_ROWS AS co5, + N_ROWS AS co6, + 0 AS co7, + N_ROWS * CASE WHEN NOT AUG_EXCHANGE IS NULL THEN 1 ELSE 0 END AS co8, + 1 AS nd1, + 1 AS nd2, + 1 AS nd3, + 1 AS nd4, + 1 AS nd5, + 1 AS nd6, + 0 AS nd7, + CAST(NOT AUG_EXCHANGE IS NULL AS INT) AS nd8, + 1 AS av1, + 2 AS av2, + -1 AS av3, + -3 AS av4, + 0 AS av5, + 0.5 AS av6, + NULL AS av7, + AUG_EXCHANGE AS av8, + 1 AS mi1, + 2 AS mi2, + -1 AS mi3, + -3 AS mi4, + 0 AS mi5, + 0.5 AS mi6, + NULL AS mi7, + AUG_EXCHANGE AS mi8, + 1 AS ma1, + 2 AS ma2, + -1 AS ma3, + -3 AS ma4, + 0 AS ma5, + 0.5 AS ma6, + NULL AS ma7, + AUG_EXCHANGE AS ma8, + 1 AS an1, + 2 AS an2, + -1 AS an3, + -3 AS an4, + 0 AS an5, + 0.5 AS an6, + NULL AS an7, + AUG_EXCHANGE AS an8, + AVG_EXPR_72 AS me1, + AVG_EXPR_73 AS me2, + AVG_EXPR_74 AS me3, + AVG_EXPR_75 AS me4, + AVG_EXPR_76 AS me5, + AVG_EXPR_77 AS me6, + NULL AS me7, + AVG_EXPR_79 AS me8, + MAX_EXPR_80 AS qu1, + MAX_EXPR_81 AS qu2, + MAX_EXPR_82 AS qu3, + MAX_EXPR_83 AS qu4, + MAX_EXPR_84 AS qu5, + MAX_EXPR_85 AS qu6, + NULL AS qu7, + MAX_EXPR_87 AS qu8 +FROM _T0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/agg_simplification_2_oracle.sql b/tests/test_sql_refsols/agg_simplification_2_oracle.sql new file mode 100644 index 000000000..e4dccb32c --- /dev/null +++ b/tests/test_sql_refsols/agg_simplification_2_oracle.sql @@ -0,0 +1,16 @@ +SELECT + sbcuststate AS state, + COUNT(DISTINCT sbcustcity) AS a1, + COUNT(*) AS a2, + COUNT(CASE WHEN LOWER(sbcustname) LIKE 'j%' THEN sbcustname ELSE NULL END) AS a3, + NVL(SUM(CAST(sbcustpostalcode AS INT)), 0) AS a4, + MIN(sbcustphone) AS a5, + MAX(sbcustphone) AS a6, + ANY_VALUE(LOWER(sbcuststate)) AS a7, + ANY_VALUE(LOWER(sbcuststate)) AS a8, + ANY_VALUE(LOWER(sbcuststate)) AS a9 +FROM MAIN.SBCUSTOMER +GROUP BY + sbcuststate +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql new file mode 100644 index 000000000..81711b0a1 --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_1_oracle.sql @@ -0,0 +1,45 @@ +WITH _T1 AS ( + SELECT + s_name AS S_NAME, + s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER + WHERE + s_name = 'Supplier#000009450' +), _S11 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + PARTSUPP.ps_suppkey AS PS_SUPPKEY, + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) * ( + 1 - LINEITEM.l_tax + ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost + ) AS SUM_REVENUE + FROM TPCH.PARTSUPP PARTSUPP + JOIN _T1 _T4 + ON PARTSUPP.ps_suppkey = _T4.S_SUPPKEY + JOIN TPCH.PART PART + ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + AND LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +) +SELECT + PART.p_name AS part_name, + ROUND(NVL(_S11.SUM_REVENUE, 0), 2) AS revenue_generated +FROM TPCH.PARTSUPP PARTSUPP +JOIN _T1 _T1 + ON PARTSUPP.ps_suppkey = _T1.S_SUPPKEY +JOIN TPCH.PART PART + ON PART.p_container LIKE 'LG%' AND PART.p_partkey = PARTSUPP.ps_partkey +LEFT JOIN _S11 _S11 + ON PARTSUPP.ps_partkey = _S11.PS_PARTKEY AND PARTSUPP.ps_suppkey = _S11.PS_SUPPKEY +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 8 ROWS ONLY diff --git a/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql new file mode 100644 index 000000000..aea10e83a --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_2_oracle.sql @@ -0,0 +1,34 @@ +WITH _S6 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) * ( + 1 - LINEITEM.l_tax + ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost + ) AS SUM_REVENUE + FROM TPCH.PARTSUPP PARTSUPP + JOIN TPCH.SUPPLIER SUPPLIER + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey + AND SUPPLIER.s_name = 'Supplier#000000182' + JOIN TPCH.PART PART + ON PART.p_container LIKE 'SM%' AND PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) + AND LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +) +SELECT + PART.p_name AS part_name, + ROUND(NVL(_S6.SUM_REVENUE, 0), 2) AS revenue_generated +FROM _S6 _S6 +JOIN TPCH.PART PART + ON PART.p_partkey = _S6.PS_PARTKEY +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 4 ROWS ONLY diff --git a/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql new file mode 100644 index 000000000..9bab90dbd --- /dev/null +++ b/tests/test_sql_refsols/aggregation_analytics_3_oracle.sql @@ -0,0 +1,35 @@ +WITH _S6 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY, + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) * ( + 1 - LINEITEM.l_tax + ) - LINEITEM.l_quantity * PARTSUPP.ps_supplycost + ) AS SUM_REVENUE + FROM TPCH.PARTSUPP PARTSUPP + JOIN TPCH.SUPPLIER SUPPLIER + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey + AND SUPPLIER.s_name = 'Supplier#000000182' + JOIN TPCH.PART PART + ON PART.p_container LIKE 'MED%' AND PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1994 + AND LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +) +SELECT + PART.p_name AS part_name, + ROUND(NVL(_S6.SUM_REVENUE, 0) / NVL(_S6.SUM_L_QUANTITY, 0), 2) AS revenue_ratio +FROM _S6 _S6 +JOIN TPCH.PART PART + ON PART.p_partkey = _S6.PS_PARTKEY +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/aggregation_functions_oracle.sql b/tests/test_sql_refsols/aggregation_functions_oracle.sql new file mode 100644 index 000000000..17a483609 --- /dev/null +++ b/tests/test_sql_refsols/aggregation_functions_oracle.sql @@ -0,0 +1,70 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T2 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_nationkey AS C_NATIONKEY, + _S1.N_ROWS, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_17, + CASE + WHEN FLOOR(0.2 * COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey)) < ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_18 + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +), _T1 AS ( + SELECT + ANY_VALUE(C_ACCTBAL) AS ANYTHING_C_ACCTBAL, + AVG(C_ACCTBAL) AS AVG_C_ACCTBAL, + AVG(EXPR_17) AS AVG_EXPR_17, + COUNT(C_ACCTBAL) AS COUNT_C_ACCTBAL, + MAX(C_ACCTBAL) AS MAX_C_ACCTBAL, + MAX(EXPR_18) AS MAX_EXPR_18, + MIN(C_ACCTBAL) AS MIN_C_ACCTBAL, + COUNT(DISTINCT C_ACCTBAL) AS NDISTINCT_C_ACCTBAL, + STDDEV_POP(C_ACCTBAL) AS POPULATION_STD_C_ACCTBAL, + VARIANCE_POP(C_ACCTBAL) AS POPULATION_VAR_C_ACCTBAL, + STDDEV(C_ACCTBAL) AS SAMPLE_STD_C_ACCTBAL, + VARIANCE(C_ACCTBAL) AS SAMPLE_VAR_C_ACCTBAL, + SUM(C_ACCTBAL) AS SUM_C_ACCTBAL, + SUM(N_ROWS) AS SUM_N_ROWS + FROM _T2 + GROUP BY + C_NATIONKEY +) +SELECT + NVL(SUM_C_ACCTBAL, 0) AS sum_value, + AVG_C_ACCTBAL AS avg_value, + AVG_EXPR_17 AS median_value, + MIN_C_ACCTBAL AS min_value, + MAX_C_ACCTBAL AS max_value, + MAX_EXPR_18 AS quantile_value, + ANYTHING_C_ACCTBAL AS anything_value, + COUNT_C_ACCTBAL AS count_value, + NDISTINCT_C_ACCTBAL AS count_distinct_value, + SAMPLE_VAR_C_ACCTBAL AS variance_s_value, + POPULATION_VAR_C_ACCTBAL AS variance_p_value, + SAMPLE_STD_C_ACCTBAL AS stddev_s_value, + POPULATION_STD_C_ACCTBAL AS stddev_p_value +FROM _T1 +WHERE + SUM_N_ROWS = 0 OR SUM_N_ROWS IS NULL diff --git a/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql new file mode 100644 index 000000000..29da7a281 --- /dev/null +++ b/tests/test_sql_refsols/alternative_quarter_cum_ir_analysis_oracle.sql @@ -0,0 +1,78 @@ +WITH _S0 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _T2 AS ( + SELECT + pr_name AS PR_NAME, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'RubyCopper-Star' +), _S12 AS ( + SELECT DISTINCT + TRUNC(CAST(_S0.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + FROM _S0 _S0 + JOIN _T2 _T2 + ON _S0.CA_DT < TRUNC(DATE_ADD(CAST(_T2.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S0.CA_DT >= _T2.PR_RELEASE +), _T5 AS ( + SELECT + pr_id AS PR_ID, + pr_name AS PR_NAME + FROM MAIN.PRODUCTS + WHERE + pr_name = 'RubyCopper-Star' +), _S9 AS ( + SELECT + COUNTRIES.co_id AS CO_ID, + _T5.PR_ID + FROM _T5 _T5 + JOIN MAIN.COUNTRIES COUNTRIES + ON COUNTRIES.co_name = 'CN' +), _S13 AS ( + SELECT + TRUNC(CAST(_S2.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID + FROM _S0 _S2 + JOIN _T2 _T4 + ON _S2.CA_DT < TRUNC(DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S2.CA_DT >= _T4.PR_RELEASE + JOIN MAIN.INCIDENTS INCIDENTS + ON _S2.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN _S9 _S9 + ON INCIDENTS.in_repair_country_id = _S9.CO_ID + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = _S9.PR_ID + GROUP BY + TRUNC(CAST(_S2.CA_DT AS TIMESTAMP), 'QUARTER') +), _S21 AS ( + SELECT + TRUNC(CAST(_S14.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + COUNT(*) AS N_ROWS + FROM _S0 _S14 + JOIN _T2 _T8 + ON _S14.CA_DT < TRUNC(DATE_ADD(CAST(_T8.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S14.CA_DT >= _T8.PR_RELEASE + JOIN MAIN.DEVICES DEVICES + ON _S14.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN _T5 _T9 + ON DEVICES.de_product_id = _T9.PR_ID + GROUP BY + TRUNC(CAST(_S14.CA_DT AS TIMESTAMP), 'QUARTER') +) +SELECT + _S12.QUARTER AS quarter, + NVL(_S13.NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + NVL(_S21.N_ROWS, 0) AS n_sold, + ROUND( + SUM(NVL(_S13.NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY _S12.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S21.N_ROWS, 0)) OVER (ORDER BY _S12.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS quarter_cum +FROM _S12 _S12 +LEFT JOIN _S13 _S13 + ON _S12.QUARTER = _S13.QUARTER +LEFT JOIN _S21 _S21 + ON _S12.QUARTER = _S21.QUARTER +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql b/tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql new file mode 100644 index 000000000..704bb85e4 --- /dev/null +++ b/tests/test_sql_refsols/arithmetic_and_binary_operators_oracle.sql @@ -0,0 +1,16 @@ +SELECT + ( + LINEITEM.l_extendedprice * ( + 1 - ( + POWER(LINEITEM.l_discount, 2) + ) + ) + 1.0 + ) / PART.p_retailprice AS computed_value, + LINEITEM.l_quantity + LINEITEM.l_extendedprice AS total, + LINEITEM.l_extendedprice - LINEITEM.l_quantity AS delta, + LINEITEM.l_quantity * LINEITEM.l_discount AS product, + LINEITEM.l_extendedprice / LINEITEM.l_quantity AS ratio, + POWER(LINEITEM.l_discount, 2) AS exponent +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey diff --git a/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql b/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql new file mode 100644 index 000000000..b8e5545f5 --- /dev/null +++ b/tests/test_sql_refsols/avg_acctbal_wo_debt_oracle.sql @@ -0,0 +1,25 @@ +WITH _S1 AS ( + SELECT + c_nationkey AS C_NATIONKEY, + SUM(GREATEST(c_acctbal, 0)) AS EXPR_0, + COUNT(GREATEST(c_acctbal, 0)) AS EXPR_1_0 + FROM TPCH.CUSTOMER + GROUP BY + c_nationkey +), _S3 AS ( + SELECT + NATION.n_regionkey AS N_REGIONKEY, + SUM(_S1.EXPR_0) AS SUM_EXPR, + SUM(_S1.EXPR_1_0) AS SUM_EXPR_1 + FROM TPCH.NATION NATION + JOIN _S1 _S1 + ON NATION.n_nationkey = _S1.C_NATIONKEY + GROUP BY + NATION.n_regionkey +) +SELECT + REGION.r_name AS region_name, + _S3.SUM_EXPR / _S3.SUM_EXPR_1 AS avg_bal_without_debt_erasure +FROM TPCH.REGION REGION +JOIN _S3 _S3 + ON REGION.r_regionkey = _S3.N_REGIONKEY diff --git a/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql new file mode 100644 index 000000000..71166e85b --- /dev/null +++ b/tests/test_sql_refsols/avg_gap_prev_urgent_same_clerk_oracle.sql @@ -0,0 +1,14 @@ +WITH _T0 AS ( + SELECT + DATEDIFF( + CAST(o_orderdate AS DATETIME), + CAST(LAG(o_orderdate, 1) OVER (PARTITION BY o_clerk ORDER BY o_orderdate) AS DATETIME), + DAY + ) AS DELTA + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' +) +SELECT + AVG(DELTA) AS avg_delta +FROM _T0 diff --git a/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql new file mode 100644 index 000000000..250ec02c8 --- /dev/null +++ b/tests/test_sql_refsols/avg_order_diff_per_customer_oracle.sql @@ -0,0 +1,24 @@ +WITH _T1 AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + ORDERS.o_custkey AS O_CUSTKEY, + DATEDIFF( + CAST(ORDERS.o_orderdate AS DATETIME), + CAST(LAG(ORDERS.o_orderdate, 1) OVER (PARTITION BY ORDERS.o_custkey ORDER BY ORDERS.o_orderdate) AS DATETIME), + DAY + ) AS DAY_DIFF + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'JAPAN' + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_orderpriority = '1-URGENT' +) +SELECT + ANY_VALUE(C_NAME) AS name, + AVG(DAY_DIFF) AS avg_diff +FROM _T1 +GROUP BY + O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql new file mode 100644 index 000000000..e90b5e642 --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_1_oracle.sql @@ -0,0 +1,27 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T1 AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + ORDER BY + CUSTOMER.c_acctbal DESC NULLS LAST, + NVL(_S1.N_ROWS, 0) NULLS FIRST + FETCH FIRST 10 ROWS ONLY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders +FROM _T1 +WHERE + N_ROWS <> 0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql new file mode 100644 index 000000000..3a87abebc --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_2_oracle.sql @@ -0,0 +1,27 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS, + COUNT(*) OVER (PARTITION BY CUSTOMER.c_nationkey) AS N_CUST + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders, + N_CUST AS n_cust +FROM _T1 +WHERE + N_ROWS <> 0 +ORDER BY + C_ACCTBAL DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql new file mode 100644 index 000000000..3a87abebc --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_3_oracle.sql @@ -0,0 +1,27 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS, + COUNT(*) OVER (PARTITION BY CUSTOMER.c_nationkey) AS N_CUST + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders, + N_CUST AS n_cust +FROM _T1 +WHERE + N_ROWS <> 0 +ORDER BY + C_ACCTBAL DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql new file mode 100644 index 000000000..b0f682f4a --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_4_oracle.sql @@ -0,0 +1,26 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _T AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS, + AVG(CAST(NVL(_S1.N_ROWS, 0) AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey) AS _W + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +) +SELECT + C_CUSTKEY AS cust_key, + N_ROWS AS n_orders +FROM _T +WHERE + N_ROWS <> 0 AND _W > NVL(N_ROWS, 0) +ORDER BY + C_ACCTBAL DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql new file mode 100644 index 000000000..657e14682 --- /dev/null +++ b/tests/test_sql_refsols/bad_child_reuse_5_oracle.sql @@ -0,0 +1,33 @@ +WITH _T2 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + O_CUSTKEY +), _S2 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_custkey AS C_CUSTKEY, + _S1.N_ROWS + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY + ORDER BY + 1 DESC NULLS LAST, + 2 DESC NULLS LAST + FETCH FIRST 10 ROWS ONLY +) +SELECT + _S2.C_CUSTKEY AS cust_key, + NVL(_S2.N_ROWS, 0) AS n_orders +FROM _S2 _S2 +JOIN _T2 _S3 + ON _S2.C_CUSTKEY = _S3.O_CUSTKEY +ORDER BY + _S2.C_ACCTBAL DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/casting_functions_oracle.sql b/tests/test_sql_refsols/casting_functions_oracle.sql new file mode 100644 index 000000000..589838d9c --- /dev/null +++ b/tests/test_sql_refsols/casting_functions_oracle.sql @@ -0,0 +1,6 @@ +SELECT + TO_CHAR(o_orderdate, 'YYYY-MM-DD') AS cast_to_string, + CAST(o_totalprice AS CLOB) AS cast_to_string2, + CAST(o_totalprice AS INT) AS cast_to_integer, + CAST(o_shippriority AS DOUBLE PRECISION) AS cast_to_float +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql new file mode 100644 index 000000000..440d9980c --- /dev/null +++ b/tests/test_sql_refsols/comparisons_and_logical_operators_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +) +SELECT + CUSTOMER.c_acctbal < 0 AS in_debt, + _S1.N_ROWS <= 12 OR _S1.N_ROWS IS NULL AS at_most_12_orders, + REGION.r_name = 'EUROPE' AS is_european, + NATION.n_name <> 'GERMANY' AS non_german, + CUSTOMER.c_acctbal > 0 AS non_empty_acct, + NOT _S1.N_ROWS IS NULL AND _S1.N_ROWS >= 5 AS at_least_5_orders, + REGION.r_name = 'ASIA' OR REGION.r_name = 'EUROPE' AS is_eurasian, + CUSTOMER.c_acctbal < 0 AND REGION.r_name = 'EUROPE' AS is_european_in_debt +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey diff --git a/tests/test_sql_refsols/conditional_functions_oracle.sql b/tests/test_sql_refsols/conditional_functions_oracle.sql new file mode 100644 index 000000000..39d55094b --- /dev/null +++ b/tests/test_sql_refsols/conditional_functions_oracle.sql @@ -0,0 +1,18 @@ +SELECT + CASE WHEN ANY_VALUE(CUSTOMER.c_acctbal) > 1000 THEN 'High' ELSE 'Low' END AS iff_col, + ANY_VALUE(CUSTOMER.c_name) IN ('Alice', 'Bob', 'Charlie') AS isin_col, + NVL(MIN(ORDERS.o_totalprice), 0.0) AS default_val, + NOT MIN(ORDERS.o_totalprice) IS NULL AS has_acct_bal, + MIN(ORDERS.o_totalprice) IS NULL AS no_acct_bal, + CASE + WHEN ANY_VALUE(CUSTOMER.c_acctbal) > 0 + THEN ANY_VALUE(CUSTOMER.c_acctbal) + ELSE NULL + END AS no_debt_bal +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey +WHERE + CUSTOMER.c_acctbal <= 1000 AND CUSTOMER.c_acctbal >= 100 +GROUP BY + CUSTOMER.c_custkey diff --git a/tests/test_sql_refsols/country_x_year_analysis_oracle.sql b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql new file mode 100644 index 000000000..d00c0f5ad --- /dev/null +++ b/tests/test_sql_refsols/country_x_year_analysis_oracle.sql @@ -0,0 +1,63 @@ +WITH _T1 AS ( + SELECT + co_name AS CO_NAME + FROM MAIN.COUNTRIES + WHERE + NOT co_name LIKE '%C%' +), _T4 AS ( + SELECT + pr_name AS PR_NAME, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'AmethystCopper-I' +), _S3 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _S15 AS ( + SELECT + _S7.CA_DT, + _T6.CO_NAME, + COUNT(*) AS N_ROWS + FROM _T1 _T6 + CROSS JOIN _T4 _T7 + JOIN _S3 _S7 + ON _S7.CA_DT < DATE_ADD(CAST(_T7.PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + AND _S7.CA_DT >= _T7.PR_RELEASE + JOIN MAIN.DEVICES DEVICES + ON _S7.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'AmethystCopper-I' + JOIN MAIN.COUNTRIES COUNTRIES + ON COUNTRIES.co_id = DEVICES.de_purchase_country_id + AND COUNTRIES.co_name = _T6.CO_NAME + GROUP BY + _S7.CA_DT, + _T6.CO_NAME +), _S17 AS ( + SELECT + TRUNC(CAST(_S3.CA_DT AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + _T3.CO_NAME, + SUM(_S15.N_ROWS) AS SUM_N_ROWS + FROM _T1 _T3 + CROSS JOIN _T4 _T4 + JOIN _S3 _S3 + ON _S3.CA_DT < DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR') + AND _S3.CA_DT >= _T4.PR_RELEASE + LEFT JOIN _S15 _S15 + ON _S15.CA_DT = _S3.CA_DT AND _S15.CO_NAME = _T3.CO_NAME + GROUP BY + TRUNC(CAST(_S3.CA_DT AS TIMESTAMP), 'YEAR'), + _T3.CO_NAME +) +SELECT + _T1.CO_NAME AS country_name, + _S17.START_OF_YEAR AS start_of_year, + NVL(_S17.SUM_N_ROWS, 0) AS n_purchases +FROM _T1 _T1 +LEFT JOIN _S17 _S17 + ON _S17.CO_NAME = _T1.CO_NAME +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/country_x_year_combos_oracle.sql b/tests/test_sql_refsols/country_x_year_combos_oracle.sql new file mode 100644 index 000000000..da1b56b19 --- /dev/null +++ b/tests/test_sql_refsols/country_x_year_combos_oracle.sql @@ -0,0 +1,26 @@ +WITH _T1 AS ( + SELECT + co_name AS CO_NAME + FROM MAIN.COUNTRIES + WHERE + NOT co_name LIKE '%C%' +), _S5 AS ( + SELECT DISTINCT + TRUNC(CAST(CALENDAR.ca_dt AS TIMESTAMP), 'YEAR') AS START_OF_YEAR, + _T3.CO_NAME + FROM _T1 _T3 + JOIN MAIN.PRODUCTS PRODUCTS + ON PRODUCTS.pr_name = 'AmethystCopper-I' + JOIN MAIN.CALENDAR CALENDAR + ON CALENDAR.ca_dt < DATE_ADD(CAST(PRODUCTS.pr_release AS TIMESTAMP), 2, 'YEAR') + AND CALENDAR.ca_dt >= PRODUCTS.pr_release +) +SELECT + _T1.CO_NAME AS country_name, + _S5.START_OF_YEAR AS start_of_year +FROM _T1 _T1 +LEFT JOIN _S5 _S5 + ON _S5.CO_NAME = _T1.CO_NAME +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql new file mode 100644 index 000000000..38685d21c --- /dev/null +++ b/tests/test_sql_refsols/cumulative_stock_analysis_oracle.sql @@ -0,0 +1,32 @@ +SELECT + SBTRANSACTION.sbtxdatetime AS date_time, + COUNT(*) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS txn_within_day, + COUNT( + CASE WHEN SBTRANSACTION.sbtxtype = 'buy' THEN SBTRANSACTION.sbtxtype ELSE NULL END + ) OVER (PARTITION BY TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n_buys_within_day, + ROUND( + ( + 100.0 * SUM(SBTICKER.sbtickersymbol IN ('AAPL', 'AMZN')) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) + ) / COUNT(*) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS pct_apple_txns, + SUM( + CASE + WHEN SBTRANSACTION.sbtxtype = 'buy' + THEN SBTRANSACTION.sbtxshares + ELSE 0 - SBTRANSACTION.sbtxshares + END + ) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS share_change, + ROUND( + AVG(CAST(SBTRANSACTION.sbtxamount AS DOUBLE PRECISION)) OVER (ORDER BY SBTRANSACTION.sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS rolling_avg_amount +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid +WHERE + EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 4 + AND EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + AND SBTRANSACTION.sbtxstatus = 'success' +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql new file mode 100644 index 000000000..5a41ca09b --- /dev/null +++ b/tests/test_sql_refsols/customer_largest_order_deltas_oracle.sql @@ -0,0 +1,53 @@ +WITH _S1 AS ( + SELECT + l_discount AS L_DISCOUNT, + l_extendedprice AS L_EXTENDEDPRICE, + l_orderkey AS L_ORDERKEY + FROM TPCH.LINEITEM + WHERE + EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_shipmode = 'AIR' +), _T5 AS ( + SELECT + ANY_VALUE(ORDERS.o_custkey) AS ANYTHING_O_CUSTKEY, + ANY_VALUE(ORDERS.o_orderdate) AS ANYTHING_O_ORDERDATE, + SUM(_S1.L_EXTENDEDPRICE * ( + 1 - _S1.L_DISCOUNT + )) AS SUM_R + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S1 _S1 + ON ORDERS.o_orderkey = _S1.L_ORDERKEY + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1994 + GROUP BY + ORDERS.o_orderkey +), _T AS ( + SELECT + ANYTHING_O_CUSTKEY, + ANYTHING_O_ORDERDATE, + SUM_R, + LAG(NVL(SUM_R, 0), 1) OVER (PARTITION BY ANYTHING_O_CUSTKEY ORDER BY ANYTHING_O_ORDERDATE) AS _W + FROM _T5 +), _T1 AS ( + SELECT + _T.ANYTHING_O_CUSTKEY, + CUSTOMER.c_name AS C_NAME, + NVL(_T.SUM_R, 0) - LAG(NVL(_T.SUM_R, 0), 1) OVER (PARTITION BY _T.ANYTHING_O_CUSTKEY ORDER BY _T.ANYTHING_O_ORDERDATE) AS REVENUE_DELTA + FROM TPCH.CUSTOMER CUSTOMER + JOIN _T _T + ON CUSTOMER.c_custkey = _T.ANYTHING_O_CUSTKEY AND NOT _T._W IS NULL + WHERE + CUSTOMER.c_mktsegment = 'AUTOMOBILE' +) +SELECT + ANY_VALUE(C_NAME) AS name, + CASE + WHEN ABS(MIN(REVENUE_DELTA)) > MAX(REVENUE_DELTA) + THEN MIN(REVENUE_DELTA) + ELSE MAX(REVENUE_DELTA) + END AS largest_diff +FROM _T1 +GROUP BY + ANYTHING_O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql new file mode 100644 index 000000000..3a0ecd689 --- /dev/null +++ b/tests/test_sql_refsols/customer_most_recent_orders_oracle.sql @@ -0,0 +1,25 @@ +WITH _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_totalprice AS O_TOTALPRICE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate DESC, o_orderkey) AS _W + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + O_CUSTKEY, + SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM _T + WHERE + _W <= 5 + GROUP BY + O_CUSTKEY +) +SELECT + CUSTOMER.c_name AS name, + NVL(_S1.SUM_O_TOTALPRICE, 0) AS total_recent_value +FROM TPCH.CUSTOMER CUSTOMER +JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/datediff_oracle.sql b/tests/test_sql_refsols/datediff_oracle.sql new file mode 100644 index 000000000..accf3de8f --- /dev/null +++ b/tests/test_sql_refsols/datediff_oracle.sql @@ -0,0 +1,16 @@ +SELECT + sbtxdatetime AS x, + TIME_STR_TO_TIME('2025-05-02 11:00:00') AS y1, + TIME_STR_TO_TIME('2023-04-03 13:16:30') AS y, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), YEAR) AS years_diff, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), MONTH) AS months_diff, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), DAY) AS days_diff, + DATEDIFF(TIME_STR_TO_TIME('2025-05-02 11:00:00'), CAST(sbtxdatetime AS DATETIME), HOUR) AS hours_diff, + DATEDIFF(TIME_STR_TO_TIME('2023-04-03 13:16:30'), CAST(sbtxdatetime AS DATETIME), MINUTE) AS minutes_diff, + DATEDIFF(TIME_STR_TO_TIME('2023-04-03 13:16:30'), CAST(sbtxdatetime AS DATETIME), SECOND) AS seconds_diff +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 +ORDER BY + 4 NULLS FIRST +FETCH FIRST 30 ROWS ONLY diff --git a/tests/test_sql_refsols/datetime_current_oracle.sql b/tests/test_sql_refsols/datetime_current_oracle.sql new file mode 100644 index 000000000..6a81334e8 --- /dev/null +++ b/tests/test_sql_refsols/datetime_current_oracle.sql @@ -0,0 +1,10 @@ +SELECT + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 5, 'MONTH'), 1, DAY) AS d1, + DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 24, 'HOUR') AS d2, + DATE_ADD( + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 12, 'HOUR'), 150, MINUTE), + 2, + 'SECOND' + ) AS d3 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/datetime_functions_oracle.sql b/tests/test_sql_refsols/datetime_functions_oracle.sql new file mode 100644 index 000000000..35065ebf5 --- /dev/null +++ b/tests/test_sql_refsols/datetime_functions_oracle.sql @@ -0,0 +1,57 @@ +SELECT + CURRENT_TIMESTAMP AS ts_now_1, + TRUNC(CURRENT_TIMESTAMP, 'DAY') AS ts_now_2, + TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS ts_now_3, + DATE_ADD(CURRENT_TIMESTAMP, 1, 'HOUR') AS ts_now_4, + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS ts_now_5, + TO_DATE('1995-10-08', 'YYYY-MM-DD') AS ts_now_6, + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS year_col, + 2020 AS year_py, + 1995 AS year_pd, + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) AS month_col, + 2 AS month_str, + 1 AS month_dt, + EXTRACT(DAY FROM CAST(o_orderdate AS DATETIME)) AS day_col, + 25 AS day_str, + 23 AS hour_str, + 59 AS minute_str, + 59 AS second_ts, + DATEDIFF(CAST('1992-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), DAY) AS dd_col_str, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1992-01-01' AS TIMESTAMP), DAY) AS dd_str_col, + DATEDIFF(CAST(o_orderdate AS DATETIME), TIME_STR_TO_TIME('1995-10-10 00:00:00'), MONTH) AS dd_pd_col, + DATEDIFF(TIME_STR_TO_TIME('1992-01-01 12:30:45'), CAST(o_orderdate AS DATETIME), YEAR) AS dd_col_dt, + DATEDIFF(TIME_STR_TO_TIME('1992-01-01 12:30:45'), CAST('1992-01-01' AS TIMESTAMP), WEEK) AS dd_dt_str, + DAY_OF_WEEK(o_orderdate) AS dow_col, + 3 AS dow_str1, + 4 AS dow_str2, + 5 AS dow_str3, + 6 AS dow_str4, + 0 AS dow_str5, + 1 AS dow_str6, + 2 AS dow_str7, + 3 AS dow_dt, + 2 AS dow_pd, + CASE + WHEN DAY_OF_WEEK(o_orderdate) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(o_orderdate) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(o_orderdate) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(o_orderdate) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(o_orderdate) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(o_orderdate) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(o_orderdate) = 6 + THEN 'Saturday' + END AS dayname_col, + 'Monday' AS dayname_str1, + 'Tuesday' AS dayname_str2, + 'Wednesday' AS dayname_str3, + 'Thursday' AS dayname_str4, + 'Friday' AS dayname_str5, + 'Saturday' AS dayname_str6, + 'Sunday' AS dayname_dt +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/datetime_relative_oracle.sql b/tests/test_sql_refsols/datetime_relative_oracle.sql new file mode 100644 index 000000000..39826dfcc --- /dev/null +++ b/tests/test_sql_refsols/datetime_relative_oracle.sql @@ -0,0 +1,31 @@ +WITH _T0 AS ( + SELECT + o_orderdate AS O_ORDERDATE + FROM TPCH.ORDERS + ORDER BY + o_custkey NULLS FIRST, + 1 NULLS FIRST + FETCH FIRST 10 ROWS ONLY +) +SELECT + TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'YEAR') AS d1, + TRUNC(CAST(O_ORDERDATE AS TIMESTAMP), 'MONTH') AS d2, + DATE_ADD( + DATE_SUB( + DATE_ADD( + DATE_SUB(DATE_ADD(DATE_SUB(CAST(O_ORDERDATE AS TIMESTAMP), 11, YEAR), 9, 'MONTH'), 7, DAY), + 5, + 'HOUR' + ), + 3, + MINUTE + ), + 1, + 'SECOND' + ) AS d3, + TIME_STR_TO_TIME('2025-07-04 12:00:00') AS d4, + TIME_STR_TO_TIME('2025-07-04 12:58:00') AS d5, + TIME_STR_TO_TIME('2025-07-26 02:45:25') AS d6 +FROM _T0 +ORDER BY + O_ORDERDATE NULLS FIRST diff --git a/tests/test_sql_refsols/datetime_sampler_oracle.sql b/tests/test_sql_refsols/datetime_sampler_oracle.sql new file mode 100644 index 000000000..e7db84617 --- /dev/null +++ b/tests/test_sql_refsols/datetime_sampler_oracle.sql @@ -0,0 +1,164 @@ +SELECT + TIME_STR_TO_TIME('2025-07-04 12:58:45') AS _expr0, + TIME_STR_TO_TIME('2024-12-31 11:59:00') AS _expr1, + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS _expr2, + TO_DATE('1999-03-14', 'YYYY-MM-DD') AS _expr3, + CURRENT_TIMESTAMP AS _expr4, + CURRENT_TIMESTAMP AS _expr5, + CURRENT_TIMESTAMP AS _expr6, + CURRENT_TIMESTAMP AS _expr7, + CURRENT_TIMESTAMP AS _expr8, + CURRENT_TIMESTAMP AS _expr9, + CURRENT_TIMESTAMP AS _expr10, + CURRENT_TIMESTAMP AS _expr11, + CURRENT_TIMESTAMP AS _expr12, + CURRENT_TIMESTAMP AS _expr13, + CURRENT_TIMESTAMP AS _expr14, + CURRENT_TIMESTAMP AS _expr15, + CURRENT_TIMESTAMP AS _expr16, + CURRENT_TIMESTAMP AS _expr17, + CURRENT_TIMESTAMP AS _expr18, + CAST(o_orderdate AS TIMESTAMP) AS _expr19, + TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND) AS _expr20, + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 8, 'MINUTE'), 141, MONTH) AS _expr21, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), SECOND), HOUR) AS _expr22, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), SECOND), HOUR) AS _expr23, + DATE_ADD(DATE_SUB(CURRENT_TIMESTAMP, 96, HOUR), 15, 'YEAR') AS _expr24, + DATE_ADD( + TIMESTAMP_TRUNC(DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 3, YEAR), MINUTE), + 65, + 'MONTH' + ) AS _expr25, + TRUNC(DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 56, HOUR), 'YEAR') AS _expr26, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 63, DAY), MINUTE), SECOND) AS _expr27, + TRUNC(CURRENT_TIMESTAMP, 'MONTH') AS _expr28, + DATE_ADD(TIMESTAMP_TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 312, HOUR), SECOND), 48, 'YEAR') AS _expr29, + DATE_SUB( + DATE_ADD(TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 75, 'DAY'), 'DAY'), 600, 'MINUTE'), + 294, + DAY + ) AS _expr30, + DATE_SUB(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 480, 'MONTH'), 45, YEAR) AS _expr31, + TIMESTAMP_TRUNC( + TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 270, MINUTE), 34, SECOND), 'DAY'), + SECOND + ) AS _expr32, + DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 213, 'SECOND') AS _expr33, + DATE_ADD( + DATE_ADD(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 13, 'MINUTE'), 28, 'YEAR'), + 344, + 'SECOND' + ) AS _expr34, + TRUNC(CURRENT_TIMESTAMP, 'DAY') AS _expr35, + TIME_STR_TO_TIME('2116-01-01 00:49:00') AS _expr36, + TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), 'DAY') AS _expr37, + TRUNC(TRUNC(CURRENT_TIMESTAMP, 'DAY'), 'YEAR') AS _expr38, + TIME_STR_TO_TIME('2025-07-01 00:22:00') AS _expr39, + TRUNC(CURRENT_TIMESTAMP, 'YEAR') AS _expr40, + TRUNC( + DATE_SUB( + DATE_ADD(DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 82, 'SECOND'), 415, 'SECOND'), + 160, + SECOND + ), + 'YEAR' + ) AS _expr41, + DATE_ADD(CURRENT_TIMESTAMP, 192, 'MONTH') AS _expr42, + DATE_ADD( + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, HOUR), MINUTE), HOUR), + 486, + 'MINUTE' + ) AS _expr43, + DATE_SUB(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, SECOND), 50, HOUR) AS _expr44, + TIMESTAMP_TRUNC( + DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 297, 'DAY'), 72, 'MONTH'), 92, MONTH), + HOUR + ) AS _expr45, + TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 285, 'SECOND'), 'DAY') AS _expr46, + TO_DATE('1999-05-15', 'YYYY-MM-DD') AS _expr47, + DATE_SUB(TRUNC(DATE_ADD(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 1, 'HOUR'), 'MONTH'), 21, DAY) AS _expr48, + DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 212, 'MINUTE'), 368, 'YEAR') AS _expr49, + TO_DATE('2024-01-01', 'YYYY-MM-DD') AS _expr50, + TO_DATE('1999-03-14', 'YYYY-MM-DD') AS _expr51, + DATE_ADD( + TIMESTAMP_TRUNC(TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 60, HOUR), 'DAY'), MINUTE), + 196, + 'YEAR' + ) AS _expr52, + DATE_ADD( + TIMESTAMP_TRUNC(DATE_SUB(DATE_SUB(CURRENT_TIMESTAMP, 40, HOUR), 385, DAY), MINUTE), + 29, + 'HOUR' + ) AS _expr53, + TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(DATE_ADD(CURRENT_TIMESTAMP, 405, 'DAY'), HOUR), MINUTE) AS _expr54, + DATE_ADD( + DATE_ADD(TIMESTAMP_TRUNC(TRUNC(CURRENT_TIMESTAMP, 'YEAR'), SECOND), 98, 'YEAR'), + 96, + 'MONTH' + ) AS _expr55, + DATE_ADD( + TRUNC(TIMESTAMP_TRUNC(TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, MINUTE), SECOND), 'DAY'), + 78, + 'SECOND' + ) AS _expr56, + DATE_ADD( + DATE_SUB(DATE_ADD(DATE_ADD(CURRENT_TIMESTAMP, 136, 'HOUR'), 104, 'MINUTE'), 104, MONTH), + 312, + 'DAY' + ) AS _expr57, + DATE_SUB(DATE_ADD(CURRENT_TIMESTAMP, 45, 'MONTH'), 135, SECOND) AS _expr58, + EXTRACT(YEAR FROM CURRENT_TIMESTAMP) AS _expr59, + 2025 AS _expr60, + 1999 AS _expr61, + EXTRACT(MONTH FROM CURRENT_TIMESTAMP) AS _expr62, + 6 AS _expr63, + 3 AS _expr64, + EXTRACT(DAY FROM CURRENT_TIMESTAMP) AS _expr65, + 4 AS _expr66, + 4 AS _expr67, + EXTRACT(HOUR FROM CURRENT_TIMESTAMP) AS _expr68, + 0 AS _expr69, + 0 AS _expr70, + EXTRACT(MINUTE FROM CURRENT_TIMESTAMP) AS _expr71, + 30 AS _expr72, + 0 AS _expr73, + EXTRACT(SECOND FROM CURRENT_TIMESTAMP) AS _expr74, + 45 AS _expr75, + 0 AS _expr76, + DATEDIFF(CURRENT_TIMESTAMP, CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS _expr77, + DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), CAST(o_orderdate AS DATETIME), YEAR) AS _expr78, + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MONTH) AS _expr79, + DATEDIFF(TO_DATE('2022-11-24', 'YYYY-MM-DD'), TIME_STR_TO_TIME('2006-05-01 12:00:00'), MONTH) AS _expr80, + DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, DAY) AS _expr81, + DATEDIFF(CURRENT_TIMESTAMP, CAST('1999-03-14' AS TIMESTAMP), DAY) AS _expr82, + DATEDIFF(CURRENT_TIMESTAMP, CURRENT_TIMESTAMP, HOUR) AS _expr83, + DATEDIFF(CAST(o_orderdate AS DATETIME), TO_DATE('2005-06-30', 'YYYY-MM-DD'), HOUR) AS _expr84, + DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CURRENT_TIMESTAMP, MINUTE) AS _expr85, + DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), CAST(o_orderdate AS DATETIME), MINUTE) AS _expr86, + DATEDIFF(TIME_STR_TO_TIME('2021-01-01 07:35:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS _expr87, + DATEDIFF( + CAST('2018-02-14 12:41:06' AS TIMESTAMP), + TO_DATE('2005-06-30', 'YYYY-MM-DD'), + SECOND + ) AS _expr88, + DATEDIFF(TIME_STR_TO_TIME('2006-05-01 12:00:00'), CAST(o_orderdate AS DATETIME), YEAR) AS _expr89, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('2018-02-14 12:41:06' AS TIMESTAMP), YEAR) AS _expr90, + DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), CAST(o_orderdate AS DATETIME), MONTH) AS _expr91, + DATEDIFF( + CAST('2018-02-14 12:41:06' AS TIMESTAMP), + TIME_STR_TO_TIME('2019-07-04 11:30:00'), + MONTH + ) AS _expr92, + DATEDIFF(CAST(o_orderdate AS DATETIME), CURRENT_TIMESTAMP, DAY) AS _expr93, + DATEDIFF(CURRENT_TIMESTAMP, TIME_STR_TO_TIME('2019-07-04 11:30:00'), DAY) AS _expr94, + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), TO_DATE('2022-11-24', 'YYYY-MM-DD'), HOUR) AS _expr95, + DATEDIFF( + TIME_STR_TO_TIME('2020-12-31 00:31:06'), + CAST('2018-02-14 12:41:06' AS TIMESTAMP), + HOUR + ) AS _expr96, + DATEDIFF(TIME_STR_TO_TIME('2020-12-31 00:31:06'), TO_DATE('2005-06-30', 'YYYY-MM-DD'), MINUTE) AS _expr97, + DATEDIFF(CAST('2018-02-14 12:41:06' AS TIMESTAMP), CURRENT_TIMESTAMP, MINUTE) AS _expr98, + DATEDIFF(CAST('1999-03-14' AS TIMESTAMP), CURRENT_TIMESTAMP, SECOND) AS _expr99, + DATEDIFF(TIME_STR_TO_TIME('2019-07-04 11:30:00'), TO_DATE('2022-11-24', 'YYYY-MM-DD'), SECOND) AS _expr100 +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/deep_best_analysis_oracle.sql b/tests/test_sql_refsols/deep_best_analysis_oracle.sql new file mode 100644 index 000000000..e8d0e5b2a --- /dev/null +++ b/tests/test_sql_refsols/deep_best_analysis_oracle.sql @@ -0,0 +1,109 @@ +WITH _T2 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY, + c_nationkey AS C_NATIONKEY + FROM TPCH.CUSTOMER +), _T AS ( + SELECT + C_ACCTBAL, + C_CUSTKEY, + C_NATIONKEY, + ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS _W + FROM _T2 +), _S4 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), _T_2 AS ( + SELECT + _S5.C_ACCTBAL, + _S4.N_NATIONKEY, + _S4.N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY _S4.N_REGIONKEY ORDER BY _S5.C_ACCTBAL DESC, _S5.C_CUSTKEY) AS _W + FROM _S4 _S4 + JOIN _T2 _S5 + ON _S4.N_NATIONKEY = _S5.C_NATIONKEY +), _S7 AS ( + SELECT + C_ACCTBAL, + N_NATIONKEY, + N_REGIONKEY + FROM _T_2 + WHERE + _W = 1 +), _T_3 AS ( + SELECT + _S8.N_NATIONKEY, + _S8.N_REGIONKEY, + PARTSUPP.ps_availqty AS PS_AVAILQTY, + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUPPLIER.s_nationkey AS S_NATIONKEY, + SUPPLIER.s_suppkey AS S_SUPPKEY, + ROW_NUMBER() OVER (PARTITION BY _S8.N_REGIONKEY ORDER BY PARTSUPP.ps_availqty DESC, PARTSUPP.ps_partkey) AS _W + FROM _S4 _S8 + JOIN TPCH.SUPPLIER SUPPLIER + ON SUPPLIER.s_nationkey = _S8.N_NATIONKEY + JOIN TPCH.PARTSUPP PARTSUPP + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +), _T_4 AS ( + SELECT + N_NATIONKEY, + N_REGIONKEY, + PS_AVAILQTY, + PS_PARTKEY, + S_NATIONKEY, + S_SUPPKEY, + ROW_NUMBER() OVER (PARTITION BY N_REGIONKEY ORDER BY PS_AVAILQTY DESC, S_SUPPKEY) AS _W + FROM _T_3 + WHERE + _W = 1 +), _S13 AS ( + SELECT + N_NATIONKEY, + N_REGIONKEY, + PS_AVAILQTY, + PS_PARTKEY, + S_SUPPKEY + FROM _T_4 + WHERE + N_NATIONKEY = S_NATIONKEY AND _W = 1 +), _T_5 AS ( + SELECT + C_CUSTKEY, + C_NATIONKEY, + ROW_NUMBER() OVER (ORDER BY C_ACCTBAL DESC, C_CUSTKEY) AS _W + FROM _T2 +), _S15 AS ( + SELECT + C_CUSTKEY, + C_NATIONKEY + FROM _T_5 + WHERE + _W = 1 +) +SELECT + REGION.r_name, + NATION.n_name, + _T.C_CUSTKEY AS c_key, + _T.C_ACCTBAL AS c_bal, + _S7.C_ACCTBAL AS cr_bal, + _S13.S_SUPPKEY AS s_key, + _S13.PS_PARTKEY AS p_key, + _S13.PS_AVAILQTY AS p_qty, + _S15.C_CUSTKEY AS cg_key +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN _T _T + ON NATION.n_nationkey = _T.C_NATIONKEY AND _T._W = 1 +LEFT JOIN _S7 _S7 + ON NATION.n_nationkey = _S7.N_NATIONKEY AND REGION.r_regionkey = _S7.N_REGIONKEY +LEFT JOIN _S13 _S13 + ON NATION.n_nationkey = _S13.N_NATIONKEY AND REGION.r_regionkey = _S13.N_REGIONKEY +LEFT JOIN _S15 _S15 + ON NATION.n_nationkey = _S15.C_NATIONKEY +ORDER BY + 2 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen10_oracle.sql b/tests/test_sql_refsols/defog_academic_gen10_oracle.sql new file mode 100644 index 000000000..3fcab37c3 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen10_oracle.sql @@ -0,0 +1,5 @@ +SELECT + title +FROM MAIN.PUBLICATION +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen11_oracle.sql b/tests/test_sql_refsols/defog_academic_gen11_oracle.sql new file mode 100644 index 000000000..b4fd8b3e6 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen11_oracle.sql @@ -0,0 +1,13 @@ +WITH _S0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.PUBLICATION +), _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.AUTHOR +) +SELECT + _S0.N_ROWS / NULLIF(_S1.N_ROWS, 0) AS publication_to_author_ratio +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/defog_academic_gen12_oracle.sql b/tests/test_sql_refsols/defog_academic_gen12_oracle.sql new file mode 100644 index 000000000..a3ff46359 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen12_oracle.sql @@ -0,0 +1,3 @@ +SELECT + SUM(NOT cid IS NULL) / NULLIF(SUM(NOT jid IS NULL), 0) AS ratio +FROM MAIN.PUBLICATION diff --git a/tests/test_sql_refsols/defog_academic_gen13_oracle.sql b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql new file mode 100644 index 000000000..eb8c255e8 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen13_oracle.sql @@ -0,0 +1,23 @@ +WITH _S1 AS ( + SELECT + did AS DID, + COUNT(*) AS N_ROWS + FROM MAIN.DOMAIN_PUBLICATION + GROUP BY + did +), _S3 AS ( + SELECT + did AS DID, + COUNT(*) AS N_ROWS + FROM MAIN.DOMAIN_KEYWORD + GROUP BY + did +) +SELECT + DOMAIN.did AS domain_id, + NVL(_S1.N_ROWS, 0) / NULLIF(_S3.N_ROWS, 0) AS ratio +FROM MAIN.DOMAIN DOMAIN +LEFT JOIN _S1 _S1 + ON DOMAIN.did = _S1.DID +LEFT JOIN _S3 _S3 + ON DOMAIN.did = _S3.DID diff --git a/tests/test_sql_refsols/defog_academic_gen14_oracle.sql b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql new file mode 100644 index 000000000..ca6d0ba14 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen14_oracle.sql @@ -0,0 +1,8 @@ +SELECT + year, + COUNT(*) AS num_publications, + COUNT(DISTINCT jid) AS num_journals, + COUNT(*) / NULLIF(COUNT(DISTINCT jid), 0) AS ratio +FROM MAIN.PUBLICATION +GROUP BY + year diff --git a/tests/test_sql_refsols/defog_academic_gen15_oracle.sql b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql new file mode 100644 index 000000000..d9a01a6ac --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen15_oracle.sql @@ -0,0 +1,18 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(ORGANIZATION.continent) AS ANYTHING_CONTINENT, + COUNT(AUTHOR.oid) AS COUNT_OID + FROM MAIN.ORGANIZATION ORGANIZATION + LEFT JOIN MAIN.AUTHOR AUTHOR + ON AUTHOR.oid = ORGANIZATION.oid + GROUP BY + ORGANIZATION.oid +) +SELECT + ANYTHING_CONTINENT AS continent, + NVL(SUM(COUNT_OID), 0) / COUNT(*) AS ratio +FROM _T1 +GROUP BY + ANYTHING_CONTINENT +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen16_oracle.sql b/tests/test_sql_refsols/defog_academic_gen16_oracle.sql new file mode 100644 index 000000000..6fd7a3f5e --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen16_oracle.sql @@ -0,0 +1,19 @@ +WITH _S3 AS ( + SELECT + WRITES.aid AS AID, + COUNT(DISTINCT PUBLICATION.pid) AS NDISTINCT_PID + FROM MAIN.WRITES WRITES + JOIN MAIN.PUBLICATION PUBLICATION + ON PUBLICATION.pid = WRITES.pid AND PUBLICATION.year = 2021 + GROUP BY + WRITES.aid +) +SELECT + AUTHOR.name, + _S3.NDISTINCT_PID AS count_publication +FROM MAIN.AUTHOR AUTHOR +JOIN _S3 _S3 + ON AUTHOR.aid = _S3.AID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen17_oracle.sql b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql new file mode 100644 index 000000000..f6638bd62 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen17_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ANY_VALUE(CONFERENCE.name) AS name, + NVL(NULLIF(COUNT(PUBLICATION.cid), 0), 0) AS count_publications +FROM MAIN.CONFERENCE CONFERENCE +LEFT JOIN MAIN.PUBLICATION PUBLICATION + ON CONFERENCE.cid = PUBLICATION.cid +GROUP BY + CONFERENCE.cid +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen18_oracle.sql b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql new file mode 100644 index 000000000..fef7d2f38 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen18_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + jid AS JID, + COUNT(*) AS N_ROWS + FROM MAIN.PUBLICATION + GROUP BY + jid +) +SELECT + JOURNAL.name, + JOURNAL.jid AS journal_id, + NVL(_S1.N_ROWS, 0) AS num_publications +FROM MAIN.JOURNAL JOURNAL +LEFT JOIN _S1 _S1 + ON JOURNAL.jid = _S1.JID +ORDER BY + 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_academic_gen19_oracle.sql b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql new file mode 100644 index 000000000..e6dc99683 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen19_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ANY_VALUE(CONFERENCE.name) AS name, + NVL(NULLIF(COUNT(PUBLICATION.cid), 0), 0) AS num_publications +FROM MAIN.CONFERENCE CONFERENCE +LEFT JOIN MAIN.PUBLICATION PUBLICATION + ON CONFERENCE.cid = PUBLICATION.cid +GROUP BY + CONFERENCE.cid +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_academic_gen1_oracle.sql b/tests/test_sql_refsols/defog_academic_gen1_oracle.sql new file mode 100644 index 000000000..1b959360c --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen1_oracle.sql @@ -0,0 +1,18 @@ +WITH _T0 AS ( + SELECT + WRITES.aid AS AID, + COUNT(DISTINCT DOMAIN_PUBLICATION.did) AS NDISTINCT_DID + FROM MAIN.WRITES WRITES + JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid + JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did + AND DOMAIN.name IN ('Data Science', 'Machine Learning') + GROUP BY + WRITES.aid +) +SELECT + AUTHOR.name +FROM MAIN.AUTHOR AUTHOR +JOIN _T0 _T0 + ON AUTHOR.aid = _T0.AID AND _T0.NDISTINCT_DID = 2 diff --git a/tests/test_sql_refsols/defog_academic_gen20_oracle.sql b/tests/test_sql_refsols/defog_academic_gen20_oracle.sql new file mode 100644 index 000000000..4db5a69e3 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen20_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS n +FROM MAIN.PUBLICATION PUBLICATION +JOIN MAIN.JOURNAL JOURNAL + ON JOURNAL.jid = PUBLICATION.jid AND LOWER(JOURNAL.name) LIKE 'j%' diff --git a/tests/test_sql_refsols/defog_academic_gen21_oracle.sql b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql new file mode 100644 index 000000000..aa793bf3f --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen21_oracle.sql @@ -0,0 +1,12 @@ +SELECT + ORGANIZATION.name AS oranization_name, + ORGANIZATION.oid AS organization_id +FROM MAIN.ORGANIZATION ORGANIZATION +JOIN MAIN.AUTHOR AUTHOR + ON AUTHOR.oid = ORGANIZATION.oid +JOIN MAIN.WRITES WRITES + ON AUTHOR.aid = WRITES.aid +JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid +JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did AND DOMAIN.name = 'Machine Learning' diff --git a/tests/test_sql_refsols/defog_academic_gen22_oracle.sql b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql new file mode 100644 index 000000000..033908e18 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen22_oracle.sql @@ -0,0 +1,16 @@ +WITH _S0 AS ( + SELECT + aid AS AID, + did AS DID + FROM MAIN.DOMAIN_AUTHOR +) +SELECT + AUTHOR.name, + AUTHOR.aid AS author_id +FROM MAIN.AUTHOR AUTHOR +JOIN _S0 _S0 + ON AUTHOR.aid = _S0.AID +JOIN _S0 _S1 + ON _S0.DID = _S1.DID +JOIN MAIN.AUTHOR AUTHOR_2 + ON AUTHOR_2.aid = _S1.AID AND LOWER(AUTHOR_2.name) LIKE '%martin%' diff --git a/tests/test_sql_refsols/defog_academic_gen23_oracle.sql b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql new file mode 100644 index 000000000..56dd99741 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen23_oracle.sql @@ -0,0 +1,6 @@ +SELECT + AUTHOR.name, + AUTHOR.aid AS author_id +FROM MAIN.AUTHOR AUTHOR +JOIN MAIN.ORGANIZATION ORGANIZATION + ON AUTHOR.oid = ORGANIZATION.oid diff --git a/tests/test_sql_refsols/defog_academic_gen24_oracle.sql b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql new file mode 100644 index 000000000..271916517 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen24_oracle.sql @@ -0,0 +1,19 @@ +WITH _S7 AS ( + SELECT + DOMAIN_CONFERENCE.cid AS CID, + WRITES.pid AS PID + FROM MAIN.WRITES WRITES + JOIN MAIN.DOMAIN_AUTHOR DOMAIN_AUTHOR + ON DOMAIN_AUTHOR.aid = WRITES.aid + JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_AUTHOR.did AND LOWER(DOMAIN.name) LIKE '%sociology%' + JOIN MAIN.DOMAIN_CONFERENCE DOMAIN_CONFERENCE + ON DOMAIN.did = DOMAIN_CONFERENCE.did +) +SELECT + PUBLICATION.title +FROM MAIN.PUBLICATION PUBLICATION +JOIN _S7 _S7 + ON PUBLICATION.cid = _S7.CID AND PUBLICATION.pid = _S7.PID +WHERE + PUBLICATION.year = 2020 diff --git a/tests/test_sql_refsols/defog_academic_gen25_oracle.sql b/tests/test_sql_refsols/defog_academic_gen25_oracle.sql new file mode 100644 index 000000000..4ed17f9f9 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen25_oracle.sql @@ -0,0 +1,9 @@ +SELECT DISTINCT + AUTHOR.name AS author_name +FROM MAIN.AUTHOR AUTHOR +JOIN MAIN.WRITES WRITES + ON AUTHOR.aid = WRITES.aid +JOIN MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + ON DOMAIN_PUBLICATION.pid = WRITES.pid +JOIN MAIN.DOMAIN DOMAIN + ON DOMAIN.did = DOMAIN_PUBLICATION.did AND DOMAIN.name = 'Computer Science' diff --git a/tests/test_sql_refsols/defog_academic_gen2_oracle.sql b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql new file mode 100644 index 000000000..064538245 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen2_oracle.sql @@ -0,0 +1,16 @@ +WITH _S3 AS ( + SELECT + WRITES.aid AS AID, + SUM(PUBLICATION.citation_num) AS SUM_CITATION_NUM + FROM MAIN.WRITES WRITES + JOIN MAIN.PUBLICATION PUBLICATION + ON PUBLICATION.pid = WRITES.pid + GROUP BY + WRITES.aid +) +SELECT + AUTHOR.name, + NVL(_S3.SUM_CITATION_NUM, 0) AS total_citations +FROM MAIN.AUTHOR AUTHOR +JOIN _S3 _S3 + ON AUTHOR.aid = _S3.AID diff --git a/tests/test_sql_refsols/defog_academic_gen3_oracle.sql b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql new file mode 100644 index 000000000..c60cca3b1 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen3_oracle.sql @@ -0,0 +1,6 @@ +SELECT + year, + COUNT(*) AS _expr0 +FROM MAIN.PUBLICATION +GROUP BY + year diff --git a/tests/test_sql_refsols/defog_academic_gen4_oracle.sql b/tests/test_sql_refsols/defog_academic_gen4_oracle.sql new file mode 100644 index 000000000..3cc9a35e2 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen4_oracle.sql @@ -0,0 +1,16 @@ +WITH _S3 AS ( + SELECT + DOMAIN_PUBLICATION.did AS DID, + AVG(PUBLICATION.reference_num) AS AVG_REFERENCE_NUM + FROM MAIN.DOMAIN_PUBLICATION DOMAIN_PUBLICATION + JOIN MAIN.PUBLICATION PUBLICATION + ON DOMAIN_PUBLICATION.pid = PUBLICATION.pid + GROUP BY + DOMAIN_PUBLICATION.did +) +SELECT + DOMAIN.name, + _S3.AVG_REFERENCE_NUM AS average_references +FROM MAIN.DOMAIN DOMAIN +LEFT JOIN _S3 _S3 + ON DOMAIN.did = _S3.DID diff --git a/tests/test_sql_refsols/defog_academic_gen5_oracle.sql b/tests/test_sql_refsols/defog_academic_gen5_oracle.sql new file mode 100644 index 000000000..e8d9e4f86 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen5_oracle.sql @@ -0,0 +1,6 @@ +SELECT + year, + AVG(citation_num) AS average_citations +FROM MAIN.PUBLICATION +GROUP BY + year diff --git a/tests/test_sql_refsols/defog_academic_gen6_oracle.sql b/tests/test_sql_refsols/defog_academic_gen6_oracle.sql new file mode 100644 index 000000000..3cf8c207f --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen6_oracle.sql @@ -0,0 +1,6 @@ +SELECT + title +FROM MAIN.PUBLICATION +ORDER BY + citation_num DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen7_oracle.sql b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql new file mode 100644 index 000000000..773797334 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen7_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + did AS DID, + COUNT(DISTINCT aid) AS NDISTINCT_AID + FROM MAIN.DOMAIN_AUTHOR + GROUP BY + did +) +SELECT + DOMAIN.name, + NVL(_S1.NDISTINCT_AID, 0) AS author_count +FROM MAIN.DOMAIN DOMAIN +LEFT JOIN _S1 _S1 + ON DOMAIN.did = _S1.DID +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen8_oracle.sql b/tests/test_sql_refsols/defog_academic_gen8_oracle.sql new file mode 100644 index 000000000..2f0e61a30 --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen8_oracle.sql @@ -0,0 +1,6 @@ +SELECT + title +FROM MAIN.PUBLICATION +ORDER BY + reference_num DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_academic_gen9_oracle.sql b/tests/test_sql_refsols/defog_academic_gen9_oracle.sql new file mode 100644 index 000000000..82e0c97fa --- /dev/null +++ b/tests/test_sql_refsols/defog_academic_gen9_oracle.sql @@ -0,0 +1,7 @@ +SELECT + title, + citation_num +FROM MAIN.PUBLICATION +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv10_oracle.sql b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql new file mode 100644 index 000000000..0d4d5f38e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv10_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) AS MONTH_SBTXDATETIME, + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) AS YEAR_SBTXDATETIME, + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + GROUP BY + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)), + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)), + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustname AS name, + NVL(_S1.N_ROWS, 0) AS num_transactions +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID + AND _S1.MONTH_SBTXDATETIME = EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) + AND _S1.YEAR_SBTXDATETIME = EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv11_oracle.sql b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql new file mode 100644 index 000000000..3a46a6f5e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv11_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n_customers +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickersymbol IN ('AMZN', 'AAPL', 'GOOGL', 'META', 'NFLX') +WHERE + SBCUSTOMER.sbcustemail LIKE '%.com' diff --git a/tests/test_sql_refsols/defog_broker_adv12_oracle.sql b/tests/test_sql_refsols/defog_broker_adv12_oracle.sql new file mode 100644 index 000000000..8838d355a --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv12_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNT(*) AS n_customers +FROM MAIN.SBCUSTOMER +WHERE + ( + LOWER(sbcustname) LIKE '%ez' OR LOWER(sbcustname) LIKE 'j%' + ) + AND LOWER(sbcuststate) LIKE '%a' diff --git a/tests/test_sql_refsols/defog_broker_adv13_oracle.sql b/tests/test_sql_refsols/defog_broker_adv13_oracle.sql new file mode 100644 index 000000000..6173b1741 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv13_oracle.sql @@ -0,0 +1,8 @@ +SELECT + sbcustcountry AS cust_country, + COUNT(*) AS TAC +FROM MAIN.SBCUSTOMER +WHERE + sbcustjoindate >= TO_DATE('2023-01-01', 'YYYY-MM-DD') +GROUP BY + sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_adv14_oracle.sql b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql new file mode 100644 index 000000000..1759f243b --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv14_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + sbdptickerid AS SBDPTICKERID, + COUNT(sbdpclose) AS COUNT_SBDPCLOSE, + SUM(sbdpclose) AS SUM_SBDPCLOSE + FROM MAIN.SBDAILYPRICE + WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sbdpdate AS DATETIME), DAY) <= 7 + GROUP BY + sbdptickerid +) +SELECT + SBTICKER.sbtickertype AS ticker_type, + SUM(_S1.SUM_SBDPCLOSE) / SUM(_S1.COUNT_SBDPCLOSE) AS ACP +FROM MAIN.SBTICKER SBTICKER +JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBDPTICKERID +GROUP BY + SBTICKER.sbtickertype diff --git a/tests/test_sql_refsols/defog_broker_adv15_oracle.sql b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql new file mode 100644 index 000000000..e1cebfb27 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv15_oracle.sql @@ -0,0 +1,10 @@ +SELECT + sbcustcountry AS country, + 100 * ( + NVL(SUM(sbcuststatus = 'active'), 0) / COUNT(*) + ) AS ar +FROM MAIN.SBCUSTOMER +WHERE + sbcustjoindate <= '2022-12-31' AND sbcustjoindate >= '2022-01-01' +GROUP BY + sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_adv16_oracle.sql b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql new file mode 100644 index 000000000..4260360a9 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv16_oracle.sql @@ -0,0 +1,23 @@ +WITH _S1 AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + SUM(sbtxtax + sbtxcommission) AS SUM_EXPR, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH) AND sbtxtype = 'sell' + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + ( + 100.0 * ( + NVL(_S1.SUM_SBTXAMOUNT, 0) - NVL(_S1.SUM_EXPR, 0) + ) + ) / NVL(_S1.SUM_SBTXAMOUNT, 0) AS SPM +FROM MAIN.SBTICKER SBTICKER +JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_broker_adv1_oracle.sql b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql new file mode 100644 index 000000000..c24b8cb5d --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv1_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustname AS name, + NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv2_oracle.sql b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql new file mode 100644 index 000000000..2f4a3b8ff --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv2_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 10, DAY), 'DAY') + AND sbtxtype = 'buy' + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + NVL(_S1.N_ROWS, 0) AS tx_count +FROM MAIN.SBTICKER SBTICKER +LEFT JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv3_oracle.sql b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql new file mode 100644 index 000000000..7cb8a51f8 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv3_oracle.sql @@ -0,0 +1,19 @@ +WITH _T1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS, + SUM(sbtxstatus = 'success') AS SUM_EXPR + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustname AS name, + ( + 100.0 * NVL(_T1.SUM_EXPR, 0) + ) / _T1.N_ROWS AS success_rate +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN _T1 _T1 + ON SBCUSTOMER.sbcustid = _T1.SBTXCUSTID AND _T1.N_ROWS >= 5 +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_broker_adv4_oracle.sql b/tests/test_sql_refsols/defog_broker_adv4_oracle.sql new file mode 100644 index 000000000..ddeb351a6 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv4_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + sbdptickerid AS SBDPTICKERID, + MAX(sbdphigh) AS MAX_SBDPHIGH, + MIN(sbdplow) AS MIN_SBDPLOW + FROM MAIN.SBDAILYPRICE + WHERE + sbdpdate <= TO_DATE('2023-04-04', 'YYYY-MM-DD') + AND sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') + GROUP BY + sbdptickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + _S1.MAX_SBDPHIGH - _S1.MIN_SBDPLOW AS price_change +FROM MAIN.SBTICKER SBTICKER +LEFT JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBDPTICKERID +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_adv5_oracle.sql b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql new file mode 100644 index 000000000..377b1212f --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv5_oracle.sql @@ -0,0 +1,59 @@ +WITH _S0 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbdpdate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))), ( + 2 * -1 + )) + END + ) AS MONTH, + sbdptickerid AS SBDPTICKERID, + COUNT(sbdpclose) AS COUNT_SBDPCLOSE, + MAX(sbdphigh) AS MAX_SBDPHIGH, + MIN(sbdplow) AS MIN_SBDPLOW, + SUM(sbdpclose) AS SUM_SBDPCLOSE + FROM MAIN.SBDAILYPRICE + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbdpdate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbdpdate AS DATETIME))), ( + 2 * -1 + )) + END + ), + sbdptickerid +), _T0 AS ( + SELECT + _S0.MONTH, + SBTICKER.sbtickersymbol AS SBTICKERSYMBOL, + MAX(_S0.MAX_SBDPHIGH) AS MAX_MAX_SBDPHIGH, + MIN(_S0.MIN_SBDPLOW) AS MIN_MIN_SBDPLOW, + SUM(_S0.COUNT_SBDPCLOSE) AS SUM_COUNT_SBDPCLOSE, + SUM(_S0.SUM_SBDPCLOSE) AS SUM_SUM_SBDPCLOSE + FROM _S0 _S0 + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = _S0.SBDPTICKERID + GROUP BY + _S0.MONTH, + SBTICKER.sbtickersymbol +) +SELECT + SBTICKERSYMBOL AS symbol, + MONTH AS month, + SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE AS avg_close, + MAX_MAX_SBDPHIGH AS max_high, + MIN_MIN_SBDPLOW AS min_low, + ( + ( + SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE + ) - LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) + ) / LAG(SUM_SUM_SBDPCLOSE / SUM_COUNT_SBDPCLOSE, 1) OVER (PARTITION BY SBTICKERSYMBOL ORDER BY MONTH) AS momc +FROM _T0 diff --git a/tests/test_sql_refsols/defog_broker_adv6_oracle.sql b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql new file mode 100644 index 000000000..439f89fb9 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv6_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustname AS name, + _S1.N_ROWS AS num_tx, + NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount, + RANK() OVER (ORDER BY NVL(_S1.SUM_SBTXAMOUNT, 0) DESC) AS cust_rank +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_adv7_oracle.sql b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql new file mode 100644 index 000000000..68fecfd7b --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv7_oracle.sql @@ -0,0 +1,78 @@ +WITH _S2 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))), ( + 2 * -1 + )) + END + ) AS MONTH, + COUNT(*) AS N_ROWS + FROM MAIN.SBCUSTOMER + WHERE + sbcustjoindate < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'MONTH') + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(sbcustjoindate AS DATETIME))), ( + 2 * -1 + )) + END + ) +), _S3 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) AS MONTH, + AVG(SBTRANSACTION.sbtxamount) AS AVG_SBTXAMOUNT + FROM MAIN.SBCUSTOMER SBCUSTOMER + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) = EXTRACT(MONTH FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) + AND EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)) = EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) + AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + WHERE + SBCUSTOMER.sbcustjoindate < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND SBCUSTOMER.sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'MONTH') + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(SBCUSTOMER.sbcustjoindate AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) +) +SELECT + _S2.MONTH AS month, + _S2.N_ROWS AS customer_signups, + _S3.AVG_SBTXAMOUNT AS avg_tx_amount +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.MONTH = _S3.MONTH diff --git a/tests/test_sql_refsols/defog_broker_adv8_oracle.sql b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql new file mode 100644 index 000000000..a124a5926 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv8_oracle.sql @@ -0,0 +1,10 @@ +SELECT + NULLIF(COUNT(*), 0) AS n_transactions, + NVL(SUM(SBTRANSACTION.sbtxamount), 0) AS total_amount +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON LOWER(SBCUSTOMER.sbcustcountry) = 'usa' + AND SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid +WHERE + SBTRANSACTION.sbtxdatetime < TRUNC(CURRENT_TIMESTAMP, 'WEEK') + AND SBTRANSACTION.sbtxdatetime >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 1, WEEK) diff --git a/tests/test_sql_refsols/defog_broker_adv9_oracle.sql b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql new file mode 100644 index 000000000..f1247db1e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_adv9_oracle.sql @@ -0,0 +1,20 @@ +SELECT + TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') AS week, + COUNT(*) AS num_transactions, + NVL( + SUM(( + MOD(( + DAY_OF_WEEK(SBTRANSACTION.sbtxdatetime) + 6 + ), 7) + ) IN (5, 6)), + 0 + ) AS weekend_transactions +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickertype = 'stock' +WHERE + SBTRANSACTION.sbtxdatetime < TRUNC(CURRENT_TIMESTAMP, 'WEEK') + AND SBTRANSACTION.sbtxdatetime >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 8, WEEK) +GROUP BY + TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_broker_basic10_oracle.sql b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql new file mode 100644 index 000000000..28dcbe3a8 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic10_oracle.sql @@ -0,0 +1,6 @@ +SELECT + SBTICKER.sbtickerid AS _id, + SBTICKER.sbtickersymbol AS symbol +FROM MAIN.SBTICKER SBTICKER +JOIN MAIN.SBDAILYPRICE SBDAILYPRICE + ON SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid diff --git a/tests/test_sql_refsols/defog_broker_basic1_oracle.sql b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql new file mode 100644 index 000000000..ef3b58c45 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic1_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + WHERE + sbtxdatetime >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 30, DAY), 'DAY') + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustcountry AS country, + NVL(SUM(_S1.N_ROWS), 0) AS num_transactions, + NVL(SUM(_S1.SUM_SBTXAMOUNT), 0) AS total_amount +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +GROUP BY + SBCUSTOMER.sbcustcountry diff --git a/tests/test_sql_refsols/defog_broker_basic2_oracle.sql b/tests/test_sql_refsols/defog_broker_basic2_oracle.sql new file mode 100644 index 000000000..6f963cb54 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic2_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxtype AS transaction_type, + COUNT(DISTINCT sbtxcustid) AS num_customers, + AVG(sbtxshares) AS avg_shares +FROM MAIN.SBTRANSACTION +WHERE + sbtxdatetime <= TO_DATE('2023-03-31', 'YYYY-MM-DD') + AND sbtxdatetime >= TO_DATE('2023-01-01', 'YYYY-MM-DD') +GROUP BY + sbtxtype +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic3_oracle.sql b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql new file mode 100644 index 000000000..43686a8c6 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic3_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + sbtxtickerid AS SBTXTICKERID, + COUNT(*) AS N_ROWS, + SUM(sbtxamount) AS SUM_SBTXAMOUNT + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxtickerid +) +SELECT + SBTICKER.sbtickersymbol AS symbol, + NVL(_S1.N_ROWS, 0) AS num_transactions, + NVL(_S1.SUM_SBTXAMOUNT, 0) AS total_amount +FROM MAIN.SBTICKER SBTICKER +LEFT JOIN _S1 _S1 + ON SBTICKER.sbtickerid = _S1.SBTXTICKERID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic4_oracle.sql b/tests/test_sql_refsols/defog_broker_basic4_oracle.sql new file mode 100644 index 000000000..f393e80a3 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic4_oracle.sql @@ -0,0 +1,34 @@ +WITH _S0 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + sbtxtickerid AS SBTXTICKERID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid, + sbtxtickerid +), _S2 AS ( + SELECT + SBTICKER.sbtickertype AS SBTICKERTYPE, + _S0.SBTXCUSTID, + SUM(_S0.N_ROWS) AS SUM_N_ROWS + FROM _S0 _S0 + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = _S0.SBTXTICKERID + GROUP BY + SBTICKER.sbtickertype, + _S0.SBTXCUSTID +) +SELECT + SBCUSTOMER.sbcuststate AS state, + _S2.SBTICKERTYPE AS ticker_type, + SUM(_S2.SUM_N_ROWS) AS num_transactions +FROM _S2 _S2 +JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = _S2.SBTXCUSTID +GROUP BY + SBCUSTOMER.sbcuststate, + _S2.SBTICKERTYPE +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic5_oracle.sql b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql new file mode 100644 index 000000000..aae7e245d --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic5_oracle.sql @@ -0,0 +1,5 @@ +SELECT + SBCUSTOMER.sbcustid AS _id +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid AND SBTRANSACTION.sbtxtype = 'buy' diff --git a/tests/test_sql_refsols/defog_broker_basic6_oracle.sql b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql new file mode 100644 index 000000000..40f0b5e9d --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic6_oracle.sql @@ -0,0 +1,6 @@ +SELECT + SBTICKER.sbtickerid AS _id +FROM MAIN.SBTICKER SBTICKER +JOIN MAIN.SBDAILYPRICE SBDAILYPRICE + ON SBDAILYPRICE.sbdpdate >= TO_DATE('2023-04-01', 'YYYY-MM-DD') + AND SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid diff --git a/tests/test_sql_refsols/defog_broker_basic7_oracle.sql b/tests/test_sql_refsols/defog_broker_basic7_oracle.sql new file mode 100644 index 000000000..2ff35b8be --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic7_oracle.sql @@ -0,0 +1,9 @@ +SELECT + sbtxstatus AS status, + COUNT(*) AS num_transactions +FROM MAIN.SBTRANSACTION +GROUP BY + sbtxstatus +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic8_oracle.sql b/tests/test_sql_refsols/defog_broker_basic8_oracle.sql new file mode 100644 index 000000000..bc7fec654 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic8_oracle.sql @@ -0,0 +1,9 @@ +SELECT + sbcustcountry AS country, + COUNT(*) AS num_customers +FROM MAIN.SBCUSTOMER +GROUP BY + sbcustcountry +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_basic9_oracle.sql b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql new file mode 100644 index 000000000..7467ecb95 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_basic9_oracle.sql @@ -0,0 +1,6 @@ +SELECT + SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustname AS name +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid diff --git a/tests/test_sql_refsols/defog_broker_gen1_oracle.sql b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql new file mode 100644 index 000000000..fc5ae4c8e --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen1_oracle.sql @@ -0,0 +1,8 @@ +SELECT + MIN(SBDAILYPRICE.sbdpclose) AS lowest_price +FROM MAIN.SBDAILYPRICE SBDAILYPRICE +JOIN MAIN.SBTICKER SBTICKER + ON SBDAILYPRICE.sbdptickerid = SBTICKER.sbtickerid + AND SBTICKER.sbtickersymbol = 'VTI' +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(SBDAILYPRICE.sbdpdate AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_broker_gen2_oracle.sql b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql new file mode 100644 index 000000000..b2e6fa910 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen2_oracle.sql @@ -0,0 +1,6 @@ +SELECT + COUNT(*) AS transaction_count +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + AND SBCUSTOMER.sbcustjoindate >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 70, DAY), 'DAY') diff --git a/tests/test_sql_refsols/defog_broker_gen3_oracle.sql b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql new file mode 100644 index 000000000..ff2528e48 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen3_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + MIN(sbtxdatetime) AS MIN_SBTXDATETIME + FROM MAIN.SBTRANSACTION + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS cust_id, + DATEDIFF( + CAST(_S1.MIN_SBTXDATETIME AS DATETIME), + CAST(SBCUSTOMER.sbcustjoindate AS DATETIME), + SECOND + ) / 86400.0 AS DaysFromJoinToFirstTransaction +FROM MAIN.SBCUSTOMER SBCUSTOMER +JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID diff --git a/tests/test_sql_refsols/defog_broker_gen4_oracle.sql b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql new file mode 100644 index 000000000..5ecfd9079 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen4_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + sbtxcustid AS SBTXCUSTID, + COUNT(*) AS N_ROWS + FROM MAIN.SBTRANSACTION + WHERE + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY') = TO_DATE('2023-04-01', 'YYYY-MM-DD') + AND sbtxtype = 'sell' + GROUP BY + sbtxcustid +) +SELECT + SBCUSTOMER.sbcustid AS _id, + SBCUSTOMER.sbcustname AS name, + NVL(_S1.N_ROWS, 0) AS num_tx +FROM MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S1 _S1 + ON SBCUSTOMER.sbcustid = _S1.SBTXCUSTID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_broker_gen5_oracle.sql b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql new file mode 100644 index 000000000..59c8567b5 --- /dev/null +++ b/tests/test_sql_refsols/defog_broker_gen5_oracle.sql @@ -0,0 +1,12 @@ +SELECT + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') AS month, + AVG(sbtxprice) AS avg_price +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(MONTH FROM CAST(sbtxdatetime AS DATETIME)) IN (1, 2, 3) + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 + AND sbtxstatus = 'success' +GROUP BY + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'MONTH') +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql new file mode 100644 index 000000000..e4c217050 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv10_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + sale_id AS SALE_ID, + MAX(payment_date) AS MAX_PAYMENT_DATE + FROM MAIN.PAYMENTS_RECEIVED + GROUP BY + sale_id +) +SELECT + ROUND( + AVG( + DATEDIFF(CAST(_S1.MAX_PAYMENT_DATE AS DATETIME), CAST(SALES.sale_date AS DATETIME), DAY) + ), + 2 + ) AS avg_days_to_payment +FROM MAIN.SALES SALES +LEFT JOIN _S1 _S1 + ON SALES._id = _S1.SALE_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql new file mode 100644 index 000000000..4a8dfc7de --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv11_oracle.sql @@ -0,0 +1,19 @@ +WITH _S0 AS ( + SELECT + car_id AS CAR_ID, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + EXTRACT(YEAR FROM CAST(sale_date AS DATETIME)) = 2023 + GROUP BY + car_id +) +SELECT + ( + ( + NVL(SUM(_S0.SUM_SALE_PRICE), 0) - NVL(SUM(CARS.cost), 0) + ) / NVL(SUM(CARS.cost), 0) + ) * 100 AS GPM +FROM _S0 _S0 +JOIN MAIN.CARS CARS + ON CARS._id = _S0.CAR_ID diff --git a/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql new file mode 100644 index 000000000..061b61a35 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv12_oracle.sql @@ -0,0 +1,14 @@ +SELECT + CARS.make, + CARS.model, + SALES.sale_price +FROM MAIN.SALES SALES +JOIN MAIN.CARS CARS + ON CARS._id = SALES.car_id +JOIN MAIN.INVENTORY_SNAPSHOTS INVENTORY_SNAPSHOTS + ON CARS._id = INVENTORY_SNAPSHOTS.car_id + AND INVENTORY_SNAPSHOTS.snapshot_date = SALES.sale_date + AND NOT INVENTORY_SNAPSHOTS.is_in_inventory +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql new file mode 100644 index 000000000..35e025121 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS TSC +FROM MAIN.SALES +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql new file mode 100644 index 000000000..52c71ad39 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv15_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + AVG(sale_price) AS AVG_SALE_PRICE + FROM MAIN.SALES + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + _S1.AVG_SALE_PRICE AS ASP +FROM MAIN.SALESPERSONS SALESPERSONS +LEFT JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql new file mode 100644 index 000000000..b0798c8a8 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv16_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS._id, + SALESPERSONS.first_name, + SALESPERSONS.last_name, + NVL(_S1.SUM_SALE_PRICE, 0) AS total +FROM MAIN.SALESPERSONS SALESPERSONS +LEFT JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql new file mode 100644 index 000000000..e310104b3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv1_oracle.sql @@ -0,0 +1,21 @@ +SELECT + TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') AS payment_week, + COUNT(*) AS total_payments, + NVL( + SUM( + ( + MOD(( + DAY_OF_WEEK(PAYMENTS_RECEIVED.payment_date) + 6 + ), 7) + ) IN (5, 6) + ), + 0 + ) AS weekend_payments +FROM MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED +JOIN MAIN.SALES SALES + ON PAYMENTS_RECEIVED.sale_id = SALES._id AND SALES.sale_price > 30000 +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) <= 8 + AND DATEDIFF(CURRENT_TIMESTAMP, CAST(PAYMENTS_RECEIVED.payment_date AS DATETIME), WEEK) >= 1 +GROUP BY + TRUNC(CAST(PAYMENTS_RECEIVED.payment_date AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql new file mode 100644 index 000000000..103486c61 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv2_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS + FROM MAIN.SALES + WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 30 + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS._id, + SALESPERSONS.first_name, + SALESPERSONS.last_name, + _S1.N_ROWS AS num_sales +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 4 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql new file mode 100644 index 000000000..b2be4d80b --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv3_oracle.sql @@ -0,0 +1,21 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(CARS.make) AS ANYTHING_MAKE, + ANY_VALUE(CARS.model) AS ANYTHING_MODEL, + COUNT(SALES.car_id) AS COUNT_CAR_ID + FROM MAIN.CARS CARS + LEFT JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id + WHERE + LOWER(CARS.vin_number) LIKE '%m5%' + GROUP BY + CARS._id +) +SELECT + ANYTHING_MAKE AS make, + ANYTHING_MODEL AS model, + NVL(SUM(COUNT_CAR_ID), 0) AS num_sales +FROM _T1 +GROUP BY + ANYTHING_MAKE, + ANYTHING_MODEL diff --git a/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql new file mode 100644 index 000000000..822289164 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv4_oracle.sql @@ -0,0 +1,9 @@ +SELECT + COUNT(*) AS num_sales, + CASE WHEN COUNT(*) <> 0 THEN NVL(SUM(SALES.sale_price), 0) ELSE NULL END AS total_revenue +FROM MAIN.CARS CARS +JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id + AND SALES.sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 30, DAY) +WHERE + LOWER(CARS.make) LIKE '%toyota%' diff --git a/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql new file mode 100644 index 000000000..e4a4a4f4a --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv5_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_sales, + _S1.N_ROWS AS num_sales, + RANK() OVER (ORDER BY NVL(_S1.SUM_SALE_PRICE, 0) DESC) AS sales_rank +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql new file mode 100644 index 000000000..f117716b5 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv6_oracle.sql @@ -0,0 +1,20 @@ +WITH _T AS ( + SELECT + car_id AS CAR_ID, + is_in_inventory AS IS_IN_INVENTORY, + ROW_NUMBER() OVER (PARTITION BY car_id ORDER BY snapshot_date DESC) AS _W + FROM MAIN.INVENTORY_SNAPSHOTS +) +SELECT + ANY_VALUE(CARS.make) AS make, + ANY_VALUE(CARS.model) AS model, + MAX(SALES.sale_price) AS highest_sale_price +FROM MAIN.CARS CARS +JOIN _T _T + ON CARS._id = _T.CAR_ID AND NOT _T.IS_IN_INVENTORY AND _T._W = 1 +LEFT JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id +GROUP BY + CARS._id +ORDER BY + 3 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql new file mode 100644 index 000000000..8da3ad13a --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv7_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + car_id AS CAR_ID, + AVG(sale_price) AS AVG_SALE_PRICE + FROM MAIN.SALES + GROUP BY + car_id +) +SELECT + CARS.make, + CARS.model, + CARS.year, + CARS.color, + CARS.vin_number, + _S1.AVG_SALE_PRICE AS avg_sale_price +FROM MAIN.CARS CARS +LEFT JOIN _S1 _S1 + ON CARS._id = _S1.CAR_ID +WHERE + LOWER(CARS.make) LIKE '%fords%' OR LOWER(CARS.model) LIKE '%mustang%' diff --git a/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql new file mode 100644 index 000000000..ffee74ac5 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_adv9_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(sale_price) AS ASP +FROM MAIN.SALES +WHERE + sale_date <= '2023-03-31' AND sale_date >= '2023-01-01' diff --git a/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql new file mode 100644 index 000000000..5d5532a4b --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic10_oracle.sql @@ -0,0 +1,22 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + sale_date >= DATE_SUB(CURRENT_TIMESTAMP, 3, MONTH) + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + NVL(_S1.N_ROWS, 0) AS total_sales, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue +FROM MAIN.SALESPERSONS SALESPERSONS +LEFT JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql new file mode 100644 index 000000000..309996ad3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic1_oracle.sql @@ -0,0 +1,8 @@ +SELECT + CARS._id, + CARS.make, + CARS.model, + CARS.year +FROM MAIN.CARS CARS +JOIN MAIN.SALES SALES + ON CARS._id = SALES.car_id diff --git a/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql new file mode 100644 index 000000000..78f8ce95e --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic2_oracle.sql @@ -0,0 +1,5 @@ +SELECT + CUSTOMERS._id +FROM MAIN.CUSTOMERS CUSTOMERS +JOIN MAIN.SALES SALES + ON CUSTOMERS._id = SALES.customer_id diff --git a/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql new file mode 100644 index 000000000..01e3e7313 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic3_oracle.sql @@ -0,0 +1,8 @@ +SELECT + SALESPERSONS._id AS salesperson_id +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN MAIN.SALES SALES + ON SALES.salesperson_id = SALESPERSONS._id +JOIN MAIN.PAYMENTS_RECEIVED PAYMENTS_RECEIVED + ON PAYMENTS_RECEIVED.payment_method = 'cash' + AND PAYMENTS_RECEIVED.sale_id = SALES._id diff --git a/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql new file mode 100644 index 000000000..ca96da0e3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic4_oracle.sql @@ -0,0 +1,7 @@ +SELECT + SALESPERSONS._id, + SALESPERSONS.first_name, + SALESPERSONS.last_name +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN MAIN.SALES SALES + ON SALES.salesperson_id = SALESPERSONS._id diff --git a/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql new file mode 100644 index 000000000..81e9bacc8 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic5_oracle.sql @@ -0,0 +1,22 @@ +WITH _S1 AS ( + SELECT + salesperson_id AS SALESPERSON_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(sale_date AS DATETIME), DAY) <= 30 + GROUP BY + salesperson_id +) +SELECT + SALESPERSONS.first_name, + SALESPERSONS.last_name, + _S1.N_ROWS AS total_sales, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue +FROM MAIN.SALESPERSONS SALESPERSONS +JOIN _S1 _S1 + ON SALESPERSONS._id = _S1.SALESPERSON_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql new file mode 100644 index 000000000..c837e2702 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic6_oracle.sql @@ -0,0 +1,12 @@ +SELECT + CUSTOMERS.state, + COUNT(DISTINCT SALES.customer_id) AS unique_customers, + NVL(SUM(SALES.sale_price), 0) AS total_revenue +FROM MAIN.SALES SALES +JOIN MAIN.CUSTOMERS CUSTOMERS + ON CUSTOMERS._id = SALES.customer_id +GROUP BY + CUSTOMERS.state +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql new file mode 100644 index 000000000..fa57bcc72 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic7_oracle.sql @@ -0,0 +1,10 @@ +SELECT + payment_method, + COUNT(*) AS total_payments, + NVL(SUM(payment_amount), 0) AS total_amount +FROM MAIN.PAYMENTS_RECEIVED +GROUP BY + payment_method +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql new file mode 100644 index 000000000..51b30b8f3 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic8_oracle.sql @@ -0,0 +1,20 @@ +WITH _S1 AS ( + SELECT + car_id AS CAR_ID, + COUNT(*) AS N_ROWS, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + GROUP BY + car_id +) +SELECT + CARS.make, + CARS.model, + NVL(_S1.N_ROWS, 0) AS total_sales, + NVL(_S1.SUM_SALE_PRICE, 0) AS total_revenue +FROM MAIN.CARS CARS +LEFT JOIN _S1 _S1 + ON CARS._id = _S1.CAR_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_basic9_oracle.sql b/tests/test_sql_refsols/defog_dealership_basic9_oracle.sql new file mode 100644 index 000000000..f0051b3fd --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_basic9_oracle.sql @@ -0,0 +1,9 @@ +SELECT + state, + COUNT(*) AS total_signups +FROM MAIN.CUSTOMERS +GROUP BY + state +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql new file mode 100644 index 000000000..99d0ee519 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen1_oracle.sql @@ -0,0 +1,11 @@ +SELECT + first_name, + last_name, + phone, + DATEDIFF(CAST(termination_date AS DATETIME), CAST(hire_date AS DATETIME), DAY) AS days_employed +FROM MAIN.SALESPERSONS +WHERE + NOT termination_date IS NULL +ORDER BY + 4 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql new file mode 100644 index 000000000..8cff8f98f --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen2_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS weekend_payments +FROM MAIN.PAYMENTS_MADE +WHERE + ( + MOD(( + DAY_OF_WEEK(payment_date) + 6 + ), 7) + ) IN (5, 6) + AND vendor_name = 'Utility Company' diff --git a/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql new file mode 100644 index 000000000..32befecca --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen3_oracle.sql @@ -0,0 +1,13 @@ +SELECT + payment_date, + payment_method, + NVL(SUM(payment_amount), 0) AS total_amount +FROM MAIN.PAYMENTS_RECEIVED +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(payment_date AS DATETIME), WEEK) = 1 +GROUP BY + payment_date, + payment_method +ORDER BY + 1 DESC NULLS LAST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql new file mode 100644 index 000000000..93b1b0f57 --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen4_oracle.sql @@ -0,0 +1,33 @@ +WITH _S0 AS ( + SELECT + TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER') AS QUARTER, + customer_id AS CUSTOMER_ID, + SUM(sale_price) AS SUM_SALE_PRICE + FROM MAIN.SALES + WHERE + EXTRACT(YEAR FROM CAST(sale_date AS DATETIME)) = 2023 + GROUP BY + TRUNC(CAST(sale_date AS TIMESTAMP), 'QUARTER'), + customer_id +), _T1 AS ( + SELECT + _S0.QUARTER, + CUSTOMERS.state AS STATE, + SUM(_S0.SUM_SALE_PRICE) AS SUM_SUM_SALE_PRICE + FROM _S0 _S0 + JOIN MAIN.CUSTOMERS CUSTOMERS + ON CUSTOMERS._id = _S0.CUSTOMER_ID + GROUP BY + _S0.QUARTER, + CUSTOMERS.state +) +SELECT + QUARTER AS quarter, + STATE AS customer_state, + SUM_SUM_SALE_PRICE AS total_sales +FROM _T1 +WHERE + NOT SUM_SUM_SALE_PRICE IS NULL AND SUM_SUM_SALE_PRICE > 0 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql new file mode 100644 index 000000000..e341242df --- /dev/null +++ b/tests/test_sql_refsols/defog_dealership_gen5_oracle.sql @@ -0,0 +1,20 @@ +WITH _T AS ( + SELECT + car_id AS CAR_ID, + is_in_inventory AS IS_IN_INVENTORY, + RANK() OVER (ORDER BY snapshot_date DESC) AS _W + FROM MAIN.INVENTORY_SNAPSHOTS + WHERE + EXTRACT(MONTH FROM CAST(snapshot_date AS DATETIME)) = 3 + AND EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 +) +SELECT + CARS._id, + CARS.make, + CARS.model, + CARS.year +FROM _T _T +JOIN MAIN.CARS CARS + ON CARS._id = _T.CAR_ID +WHERE + _T.IS_IN_INVENTORY AND _T._W = 1 diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql new file mode 100644 index 000000000..54abc90be --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv10_oracle.sql @@ -0,0 +1,21 @@ +WITH _S3 AS ( + SELECT + TREATMENTS.drug_id AS DRUG_ID, + COUNT(*) AS N_ROWS + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.ADVERSE_EVENTS ADVERSE_EVENTS + ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id + AND TRUNC(CAST(ADVERSE_EVENTS.reported_dt AS TIMESTAMP), 'MONTH') = TRUNC(CAST(TREATMENTS.start_dt AS TIMESTAMP), 'MONTH') + GROUP BY + TREATMENTS.drug_id +) +SELECT + DRUGS.drug_id, + DRUGS.drug_name, + _S3.N_ROWS AS num_adverse_events +FROM MAIN.DRUGS DRUGS +JOIN _S3 _S3 + ON DRUGS.drug_id = _S3.DRUG_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql new file mode 100644 index 000000000..0dcf91911 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv11_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS num_patients_with_gmail_or_yahoo +FROM MAIN.PATIENTS +WHERE + email LIKE '%@gmail.com' OR email LIKE '%@yahoo.com' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql new file mode 100644 index 000000000..7eca7d159 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv12_oracle.sql @@ -0,0 +1,7 @@ +SELECT + first_name, + last_name, + specialty +FROM MAIN.DOCTORS +WHERE + LOWER(first_name) LIKE 'j%' OR LOWER(last_name) LIKE '%son%' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql new file mode 100644 index 000000000..f63887b27 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv13_oracle.sql @@ -0,0 +1,5 @@ +SELECT + COUNT(*) AS PIC_female +FROM MAIN.PATIENTS +WHERE + gender = 'Female' AND ins_type = 'private' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql new file mode 100644 index 000000000..482c93660 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(weight_kg) AS CAW_male +FROM MAIN.PATIENTS +WHERE + gender = 'Male' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql new file mode 100644 index 000000000..52bc4e847 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv15_oracle.sql @@ -0,0 +1,20 @@ +WITH _S3 AS ( + SELECT + drug_id AS DRUG_ID, + AVG( + tot_drug_amt / DATEDIFF(CAST(end_dt AS DATETIME), CAST(start_dt AS DATETIME), DAY) + ) AS AVG_DDD + FROM MAIN.TREATMENTS + WHERE + NOT end_dt IS NULL + GROUP BY + drug_id +) +SELECT + DRUGS.drug_name, + _S3.AVG_DDD AS avg_ddd +FROM MAIN.DRUGS DRUGS +JOIN MAIN.TREATMENTS TREATMENTS + ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT TREATMENTS.end_dt IS NULL +LEFT JOIN _S3 _S3 + ON DRUGS.drug_id = _S3.DRUG_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql new file mode 100644 index 000000000..15c5a4d0b --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv16_oracle.sql @@ -0,0 +1,9 @@ +SELECT + ( + ( + AVG(day100_pasi_score) - AVG(day7_pasi_score) + ) / AVG(day7_pasi_score) + ) * 100 AS d7d100pir +FROM MAIN.OUTCOMES +WHERE + NOT day100_pasi_score IS NULL AND NOT day7_pasi_score IS NULL diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql new file mode 100644 index 000000000..78e84803c --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv1_oracle.sql @@ -0,0 +1,7 @@ +SELECT DISTINCT + DOCTORS.loc_state AS state +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'biologic' +JOIN MAIN.DOCTORS DOCTORS + ON DOCTORS.doc_id = TREATMENTS.doc_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql new file mode 100644 index 000000000..58f79825c --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv2_oracle.sql @@ -0,0 +1,7 @@ +SELECT + AVG(PATIENTS.weight_kg) AS avg_weight +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND LOWER(DRUGS.drug_name) = 'drugalin' +JOIN MAIN.PATIENTS PATIENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql new file mode 100644 index 000000000..9c576f138 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ADVERSE_EVENTS.description, + ADVERSE_EVENTS.treatment_id, + DRUGS.drug_id, + DRUGS.drug_name +FROM MAIN.ADVERSE_EVENTS ADVERSE_EVENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'topical' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql new file mode 100644 index 000000000..53e8a3e3d --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv4_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS patient_count +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id +JOIN MAIN.DIAGNOSES DIAGNOSES + ON DIAGNOSES.diag_id = TREATMENTS.diag_id + AND LOWER(DIAGNOSES.diag_name) = 'psoriasis vulgaris' +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND LOWER(DRUGS.drug_type) = 'biologic' diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql new file mode 100644 index 000000000..bf0356723 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv5_oracle.sql @@ -0,0 +1,31 @@ +WITH _T1 AS ( + SELECT + MIN(EXTRACT(YEAR FROM CAST(TREATMENTS_2.start_dt AS DATETIME))) AS MIN_YEAR_START_DT + FROM MAIN.PATIENTS PATIENTS + JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id + LEFT JOIN MAIN.TREATMENTS TREATMENTS_2 + ON PATIENTS.patient_id = TREATMENTS_2.patient_id + GROUP BY + PATIENTS.patient_id +), _T0 AS ( + SELECT + MIN_YEAR_START_DT, + COUNT(*) AS N_ROWS + FROM _T1 + GROUP BY + MIN_YEAR_START_DT +) +SELECT + CAST(MIN_YEAR_START_DT AS CLOB) AS year, + N_ROWS AS number_of_new_patients, + CASE + WHEN ( + N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + ) <> 0 + THEN N_ROWS - NVL(LAG(N_ROWS, 1) OVER (ORDER BY MIN_YEAR_START_DT), N_ROWS) + ELSE NULL + END AS npi +FROM _T0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql new file mode 100644 index 000000000..b7e2433f0 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv6_oracle.sql @@ -0,0 +1,16 @@ +WITH _S1 AS ( + SELECT + doc_id AS DOC_ID, + COUNT(DISTINCT drug_id) AS NDISTINCT_DRUG_ID + FROM MAIN.TREATMENTS + GROUP BY + doc_id +) +SELECT + DOCTORS.doc_id, + DOCTORS.specialty, + _S1.NDISTINCT_DRUG_ID AS num_distinct_drugs, + DENSE_RANK() OVER (PARTITION BY DOCTORS.specialty ORDER BY _S1.NDISTINCT_DRUG_ID DESC) AS SDRSDR +FROM MAIN.DOCTORS DOCTORS +JOIN _S1 _S1 + ON DOCTORS.doc_id = _S1.DOC_ID diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql new file mode 100644 index 000000000..d9e60aeb8 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv7_oracle.sql @@ -0,0 +1,9 @@ +SELECT + COUNT(*) AS num_treatments +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.PATIENTS PATIENTS + ON LOWER(PATIENTS.first_name) = 'alice' + AND PATIENTS.patient_id = TREATMENTS.patient_id +WHERE + TREATMENTS.start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND TREATMENTS.start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 6, MONTH) diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql new file mode 100644 index 000000000..e33d49c5a --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv8_oracle.sql @@ -0,0 +1,27 @@ +WITH _T0 AS ( + SELECT + TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') AS START_MONTH, + COUNT(*) AS N_ROWS, + COUNT(DISTINCT diag_id) AS NDISTINCT_DIAG_ID + FROM MAIN.TREATMENTS + WHERE + DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 12, MONTH) <= TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') + AND TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + GROUP BY + TRUNC(CAST(start_dt AS TIMESTAMP), 'MONTH') +) +SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM START_MONTH), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM START_MONTH)) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM START_MONTH), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM START_MONTH)), -2) + END + ) AS start_month, + NDISTINCT_DIAG_ID AS PMPD, + N_ROWS AS PMTC +FROM _T0 +ORDER BY + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql new file mode 100644 index 000000000..38990537b --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_adv9_oracle.sql @@ -0,0 +1,78 @@ +WITH _S2 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))), ( + 2 * -1 + )) + END + ) AS TREATMENT_MONTH, + COUNT(DISTINCT patient_id) AS NDISTINCT_PATIENT_ID + FROM MAIN.TREATMENTS + WHERE + start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 3, MONTH) + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR(CONCAT('00', EXTRACT(MONTH FROM CAST(start_dt AS DATETIME))), ( + 2 * -1 + )) + END + ) +), _S3 AS ( + SELECT + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) AS TREATMENT_MONTH, + COUNT(DISTINCT TREATMENTS.patient_id) AS NDISTINCT_PATIENT_ID + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND DRUGS.drug_type = 'biologic' + WHERE + TREATMENTS.start_dt < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND TREATMENTS.start_dt >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 3, MONTH) + GROUP BY + LISTAGG( + '-', + EXTRACT(YEAR FROM CAST(TREATMENTS.start_dt AS DATETIME)), + CASE + WHEN LENGTH(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))) >= 2 + THEN SUBSTR(EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME)), 1, 2) + ELSE SUBSTR( + CONCAT('00', EXTRACT(MONTH FROM CAST(TREATMENTS.start_dt AS DATETIME))), + ( + 2 * -1 + ) + ) + END + ) +) +SELECT + _S2.TREATMENT_MONTH AS month, + _S2.NDISTINCT_PATIENT_ID AS patient_count, + NVL(_S3.NDISTINCT_PATIENT_ID, 0) AS biologic_treatment_count +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.TREATMENT_MONTH = _S3.TREATMENT_MONTH +ORDER BY + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql new file mode 100644 index 000000000..f83061557 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic10_oracle.sql @@ -0,0 +1,6 @@ +SELECT + DRUGS.drug_id, + DRUGS.drug_name +FROM MAIN.DRUGS DRUGS +JOIN MAIN.TREATMENTS TREATMENTS + ON DRUGS.drug_id = TREATMENTS.drug_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql new file mode 100644 index 000000000..525ea1b8f --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic1_oracle.sql @@ -0,0 +1,31 @@ +WITH _S1 AS ( + SELECT + doc_id AS DOC_ID, + COUNT(*) AS N_ROWS, + SUM(tot_drug_amt) AS SUM_TOT_DRUG_AMT + FROM MAIN.TREATMENTS + WHERE + start_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') + GROUP BY + doc_id +), _T1 AS ( + SELECT + DOCTORS.specialty AS SPECIALTY, + SUM(_S1.N_ROWS) AS SUM_N_ROWS, + SUM(_S1.SUM_TOT_DRUG_AMT) AS SUM_SUM_TOT_DRUG_AMT + FROM MAIN.DOCTORS DOCTORS + LEFT JOIN _S1 _S1 + ON DOCTORS.doc_id = _S1.DOC_ID + GROUP BY + DOCTORS.specialty +) +SELECT + SPECIALTY AS specialty, + SUM_N_ROWS AS num_treatments, + NVL(SUM_SUM_TOT_DRUG_AMT, 0) AS total_drug_amount +FROM _T1 +WHERE + SUM_N_ROWS <> 0 +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql new file mode 100644 index 000000000..9290669b7 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic2_oracle.sql @@ -0,0 +1,63 @@ +WITH _T2 AS ( + SELECT + end_dt AS END_DT, + patient_id AS PATIENT_ID, + treatment_id AS TREATMENT_ID + FROM MAIN.TREATMENTS + WHERE + EXTRACT(YEAR FROM CAST(end_dt AS DATETIME)) = 2022 +), _T3 AS ( + SELECT + day100_pasi_score AS DAY100_PASI_SCORE, + treatment_id AS TREATMENT_ID + FROM MAIN.OUTCOMES + WHERE + NOT day100_pasi_score IS NULL +), _S3 AS ( + SELECT + ins_type AS INS_TYPE, + patient_id AS PATIENT_ID + FROM MAIN.PATIENTS +), _S10 AS ( + SELECT + _S3.INS_TYPE, + COUNT(DISTINCT _T2.PATIENT_ID) AS NDISTINCT_PATIENT_ID + FROM _T2 _T2 + JOIN _T3 _T3 + ON _T2.TREATMENT_ID = _T3.TREATMENT_ID + JOIN _S3 _S3 + ON _S3.PATIENT_ID = _T2.PATIENT_ID + GROUP BY + _S3.INS_TYPE +), _S9 AS ( + SELECT + treatment_id AS TREATMENT_ID, + COUNT(day100_pasi_score) AS COUNT_DAY100_PASI_SCORE, + SUM(day100_pasi_score) AS SUM_DAY100_PASI_SCORE + FROM MAIN.OUTCOMES + GROUP BY + treatment_id +), _S11 AS ( + SELECT + SUM(_S9.SUM_DAY100_PASI_SCORE) / SUM(_S9.COUNT_DAY100_PASI_SCORE) AS AVG_DAY100_PASI_SCORE, + _S7.INS_TYPE + FROM _T2 _T6 + JOIN _T3 _T7 + ON _T6.TREATMENT_ID = _T7.TREATMENT_ID + JOIN _S3 _S7 + ON _S7.PATIENT_ID = _T6.PATIENT_ID + JOIN _S9 _S9 + ON _S9.TREATMENT_ID = _T6.TREATMENT_ID + GROUP BY + _S7.INS_TYPE +) +SELECT + _S10.INS_TYPE AS insurance_type, + _S10.NDISTINCT_PATIENT_ID AS num_distinct_patients, + _S11.AVG_DAY100_PASI_SCORE AS avg_pasi_score_day100 +FROM _S10 _S10 +LEFT JOIN _S11 _S11 + ON _S10.INS_TYPE = _S11.INS_TYPE +ORDER BY + 3 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql new file mode 100644 index 000000000..ba625b6b6 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic3_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + drug_id AS DRUG_ID, + AVG(tot_drug_amt) AS AVG_TOT_DRUG_AMT, + COUNT(*) AS N_ROWS + FROM MAIN.TREATMENTS + GROUP BY + drug_id +) +SELECT + DRUGS.drug_name, + NVL(_S1.N_ROWS, 0) AS num_treatments, + _S1.AVG_TOT_DRUG_AMT AS avg_drug_amount +FROM MAIN.DRUGS DRUGS +LEFT JOIN _S1 _S1 + ON DRUGS.drug_id = _S1.DRUG_ID +ORDER BY + 2 DESC NULLS LAST, + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql new file mode 100644 index 000000000..7044080db --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic4_oracle.sql @@ -0,0 +1,30 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(TREATMENTS.diag_id) AS ANYTHING_DIAG_ID, + ANY_VALUE(TREATMENTS.patient_id) AS ANYTHING_PATIENT_ID, + MAX(OUTCOMES.day100_itch_vas) AS MAX_DAY100_ITCH_VAS + FROM MAIN.TREATMENTS TREATMENTS + JOIN MAIN.OUTCOMES OUTCOMES + ON OUTCOMES.treatment_id = TREATMENTS.treatment_id + GROUP BY + OUTCOMES.treatment_id +), _S3 AS ( + SELECT + ANYTHING_DIAG_ID, + MAX(MAX_DAY100_ITCH_VAS) AS MAX_MAX_DAY100_ITCH_VAS, + COUNT(DISTINCT ANYTHING_PATIENT_ID) AS NDISTINCT_ANYTHING_PATIENT_ID + FROM _T1 + GROUP BY + ANYTHING_DIAG_ID +) +SELECT + DIAGNOSES.diag_name AS diagnosis_name, + _S3.NDISTINCT_ANYTHING_PATIENT_ID AS num_patients, + _S3.MAX_MAX_DAY100_ITCH_VAS AS max_itch_score +FROM MAIN.DIAGNOSES DIAGNOSES +JOIN _S3 _S3 + ON DIAGNOSES.diag_id = _S3.ANYTHING_DIAG_ID +ORDER BY + 3 DESC NULLS LAST, + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql new file mode 100644 index 000000000..07f71c274 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic5_oracle.sql @@ -0,0 +1,7 @@ +SELECT + DOCTORS.doc_id, + DOCTORS.first_name, + DOCTORS.last_name +FROM MAIN.DOCTORS DOCTORS +JOIN MAIN.TREATMENTS TREATMENTS + ON DOCTORS.doc_id = TREATMENTS.doc_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql new file mode 100644 index 000000000..6998557e6 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + PATIENTS.patient_id, + PATIENTS.first_name, + PATIENTS.last_name +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id +JOIN MAIN.OUTCOMES OUTCOMES + ON OUTCOMES.treatment_id = TREATMENTS.treatment_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql new file mode 100644 index 000000000..c1015336f --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic7_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ins_type AS insurance_type, + AVG(height_cm) AS avg_height, + AVG(weight_kg) AS avg_weight +FROM MAIN.PATIENTS +GROUP BY + ins_type +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql new file mode 100644 index 000000000..0a21cc8de --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic8_oracle.sql @@ -0,0 +1,9 @@ +SELECT + specialty, + COUNT(*) AS num_doctors +FROM MAIN.DOCTORS +GROUP BY + specialty +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql new file mode 100644 index 000000000..c6256e898 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_basic9_oracle.sql @@ -0,0 +1,7 @@ +SELECT + PATIENTS.patient_id, + PATIENTS.first_name, + PATIENTS.last_name +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON PATIENTS.patient_id = TREATMENTS.patient_id diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql new file mode 100644 index 000000000..964d6dcdb --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen1_oracle.sql @@ -0,0 +1,13 @@ +SELECT + ADVERSE_EVENTS.treatment_id, + TREATMENTS.start_dt AS treatment_start_date, + ADVERSE_EVENTS.reported_dt AS adverse_event_date, + ADVERSE_EVENTS.description +FROM MAIN.ADVERSE_EVENTS ADVERSE_EVENTS +JOIN MAIN.TREATMENTS TREATMENTS + ON ADVERSE_EVENTS.treatment_id = TREATMENTS.treatment_id + AND DATEDIFF( + CAST(ADVERSE_EVENTS.reported_dt AS DATETIME), + CAST(TREATMENTS.start_dt AS DATETIME), + DAY + ) <= 10 diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql new file mode 100644 index 000000000..788d00c7a --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen2_oracle.sql @@ -0,0 +1,26 @@ +WITH _T AS ( + SELECT + doc_id AS DOC_ID, + start_dt AS START_DT, + treatment_id AS TREATMENT_ID, + ROW_NUMBER() OVER (PARTITION BY doc_id ORDER BY start_dt) AS _W + FROM MAIN.TREATMENTS +), _S1 AS ( + SELECT + DOC_ID, + START_DT, + TREATMENT_ID + FROM _T + WHERE + _W = 1 +) +SELECT + DOCTORS.last_name, + DOCTORS.year_reg, + _S1.START_DT AS first_treatment_date, + _S1.TREATMENT_ID AS first_treatment_id +FROM MAIN.DOCTORS DOCTORS +LEFT JOIN _S1 _S1 + ON DOCTORS.doc_id = _S1.DOC_ID +WHERE + DOCTORS.year_reg = EXTRACT(YEAR FROM DATE_SUB(CURRENT_TIMESTAMP, 2, YEAR)) diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql new file mode 100644 index 000000000..405b438a7 --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen3_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(DATEDIFF(CURRENT_TIMESTAMP, CAST(date_of_birth AS DATETIME), YEAR)) AS average_age +FROM MAIN.PATIENTS +WHERE + gender = 'Male' AND ins_type = 'private' diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql new file mode 100644 index 000000000..e3f8ff9ae --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen4_oracle.sql @@ -0,0 +1,19 @@ +SELECT + TREATMENTS_2.treatment_id, + TREATMENTS_2.start_dt AS treatment_start_date, + TREATMENTS_2.end_dt AS treatment_end_date, + CONCOMITANT_MEDS.start_dt AS concomitant_med_start_date, + CONCOMITANT_MEDS.end_dt AS concomitant_med_end_date +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.CONCOMITANT_MEDS CONCOMITANT_MEDS + ON CONCOMITANT_MEDS.treatment_id = TREATMENTS.treatment_id +JOIN MAIN.TREATMENTS TREATMENTS_2 + ON CONCOMITANT_MEDS.treatment_id = TREATMENTS_2.treatment_id + AND DATEDIFF( + CAST(CONCOMITANT_MEDS.start_dt AS DATETIME), + CAST(TREATMENTS_2.start_dt AS DATETIME), + DAY + ) <= 14 + AND TREATMENTS_2.is_placebo +WHERE + TREATMENTS.is_placebo = TRUE diff --git a/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql new file mode 100644 index 000000000..b231e94be --- /dev/null +++ b/tests/test_sql_refsols/defog_dermtreatment_gen5_oracle.sql @@ -0,0 +1,11 @@ +SELECT + COUNT(*) AS num_treatments +FROM MAIN.TREATMENTS TREATMENTS +JOIN MAIN.DIAGNOSES DIAGNOSES + ON DIAGNOSES.diag_id = TREATMENTS.diag_id + AND LOWER(DIAGNOSES.diag_name) LIKE '%psoriasis%' +JOIN MAIN.DRUGS DRUGS + ON DRUGS.drug_id = TREATMENTS.drug_id AND NOT DRUGS.fda_appr_dt IS NULL +WHERE + NOT TREATMENTS.end_dt IS NULL + AND TREATMENTS.end_dt >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 6, MONTH), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql new file mode 100644 index 000000000..6fee26cc1 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv10_oracle.sql @@ -0,0 +1,9 @@ +SELECT + WALLET_TRANSACTIONS_DAILY.sender_id AS user_id, + COUNT(*) AS total_transactions +FROM MAIN.USERS USERS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id + AND WALLET_TRANSACTIONS_DAILY.sender_type = 0 +GROUP BY + WALLET_TRANSACTIONS_DAILY.sender_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql new file mode 100644 index 000000000..339cd6a87 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv11_oracle.sql @@ -0,0 +1,18 @@ +SELECT + USER_SESSIONS.user_id AS uid, + SUM( + DATEDIFF( + CAST(USER_SESSIONS.session_end_ts AS DATETIME), + CAST(USER_SESSIONS.session_start_ts AS DATETIME), + SECOND + ) + ) AS total_duration +FROM MAIN.USERS USERS +JOIN MAIN.USER_SESSIONS USER_SESSIONS + ON USERS.uid = USER_SESSIONS.user_id + AND USER_SESSIONS.session_end_ts < '2023-06-08' + AND USER_SESSIONS.session_start_ts >= '2023-06-01' +GROUP BY + USER_SESSIONS.user_id +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql new file mode 100644 index 000000000..70cd17a4f --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv12_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUPONS.cid AS coupon_id, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount +FROM MAIN.COUPONS COUPONS +LEFT JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON COUPONS.cid = WALLET_TRANSACTIONS_DAILY.coupon_id +WHERE + COUPONS.merchant_id = '1' +GROUP BY + COUPONS.cid diff --git a/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql new file mode 100644 index 000000000..4a17a3456 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv13_oracle.sql @@ -0,0 +1,6 @@ +SELECT + COUNT(*) AS TUC +FROM MAIN.USER_SESSIONS +WHERE + session_end_ts >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH), 'DAY') + OR session_start_ts >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 1, MONTH), 'DAY') diff --git a/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql new file mode 100644 index 000000000..bc455ae65 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(status = 'success'), 0) / COUNT(*) AS _expr0 +FROM MAIN.WALLET_TRANSACTIONS_DAILY +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(created_at AS DATETIME), MONTH) = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql new file mode 100644 index 000000000..daa189a31 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv15_oracle.sql @@ -0,0 +1,21 @@ +WITH _S3 AS ( + SELECT + COUPONS.merchant_id AS MERCHANT_ID, + COUNT(*) AS N_ROWS + FROM MAIN.COUPONS COUPONS + JOIN MAIN.MERCHANTS MERCHANTS + ON COUPONS.merchant_id = MERCHANTS.mid + AND DATEDIFF(CAST(COUPONS.created_at AS DATETIME), CAST(MERCHANTS.created_at AS DATETIME), MONTH) = 0 + GROUP BY + COUPONS.merchant_id +) +SELECT + MERCHANTS.mid AS merchant_id, + MERCHANTS.name AS merchant_name, + NVL(_S3.N_ROWS, 0) AS coupons_per_merchant +FROM MAIN.MERCHANTS MERCHANTS +LEFT JOIN _S3 _S3 + ON MERCHANTS.mid = _S3.MERCHANT_ID +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql new file mode 100644 index 000000000..46759086c --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv16_oracle.sql @@ -0,0 +1,12 @@ +SELECT + ANY_VALUE(USERS.username) AS username, + COUNT(*) AS total_unread_notifs +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.status = 'unread' + AND NOTIFICATIONS.type = 'promotion' + AND NOTIFICATIONS.user_id = USERS.uid +WHERE + LOWER(USERS.country) = 'us' +GROUP BY + NOTIFICATIONS.user_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql new file mode 100644 index 000000000..a400fa7a7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv1_oracle.sql @@ -0,0 +1,9 @@ +SELECT + ANY_VALUE(MERCHANTS.name) AS name, + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.coupon_id) / COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.txid) AS CPUR +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + WALLET_TRANSACTIONS_DAILY.receiver_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql new file mode 100644 index 000000000..af55a5d09 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv2_oracle.sql @@ -0,0 +1,19 @@ +SELECT + TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') AS week, + COUNT(*) AS num_notifs, + NVL( + SUM(( + MOD(( + DAY_OF_WEEK(NOTIFICATIONS.created_at) + 6 + ), 7) + ) IN (5, 6)), + 0 + ) AS weekend_notifs +FROM MAIN.NOTIFICATIONS NOTIFICATIONS +JOIN MAIN.USERS USERS + ON NOTIFICATIONS.user_id = USERS.uid AND USERS.country IN ('US', 'CA') +WHERE + NOTIFICATIONS.created_at < TRUNC(CURRENT_TIMESTAMP, 'WEEK') + AND NOTIFICATIONS.created_at >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'WEEK'), 3, WEEK) +GROUP BY + TRUNC(CAST(NOTIFICATIONS.created_at AS TIMESTAMP), 'WEEK') diff --git a/tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql new file mode 100644 index 000000000..65a45ff17 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + ANY_VALUE(MERCHANTS.name) AS merchant_name, + COUNT(*) AS total_coupons +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.COUPONS COUPONS + ON COUPONS.merchant_id = MERCHANTS.mid +WHERE + LOWER(MERCHANTS.category) LIKE '%retail%' AND MERCHANTS.status = 'active' +GROUP BY + COUPONS.merchant_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql new file mode 100644 index 000000000..f6da2c390 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv4_oracle.sql @@ -0,0 +1,12 @@ +SELECT + COUNT(*) AS num_transactions, + CASE + WHEN COUNT(*) <> 0 + THEN NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) + ELSE NULL + END AS total_amount +FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY +JOIN MAIN.USERS USERS + ON USERS.country = 'US' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql new file mode 100644 index 000000000..f2e00e4f0 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv5_oracle.sql @@ -0,0 +1,5 @@ +SELECT + AVG(balance) AS AMB +FROM MAIN.WALLET_USER_BALANCE_DAILY +WHERE + DATEDIFF(CURRENT_TIMESTAMP, CAST(updated_at AS DATETIME), DAY) <= 7 diff --git a/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql new file mode 100644 index 000000000..e3bbd9ad8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv6_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + balance AS BALANCE, + user_id AS USER_ID, + ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY updated_at DESC) AS _W + FROM MAIN.WALLET_USER_BALANCE_DAILY +) +SELECT + USER_ID AS user_id, + BALANCE AS latest_balance +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql new file mode 100644 index 000000000..461713544 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv7_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + marketing_opt_in AS MARKETING_OPT_IN, + user_id AS USER_ID, + ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY created_at DESC) AS _W + FROM MAIN.USER_SETTING_SNAPSHOT +) +SELECT + USERS.uid, + _T.MARKETING_OPT_IN AS marketing_opt_in +FROM MAIN.USERS USERS +JOIN _T _T + ON USERS.uid = _T.USER_ID AND _T._W = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql new file mode 100644 index 000000000..90ce9d77a --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv8_oracle.sql @@ -0,0 +1,13 @@ +SELECT + WALLET_TRANSACTIONS_DAILY.receiver_id AS merchants_id, + ANY_VALUE(MERCHANTS.name) AS merchants_name, + ANY_VALUE(MERCHANTS.category) AS category, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_revenue, + ROW_NUMBER() OVER (ORDER BY NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) DESC) AS mrr +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id + AND WALLET_TRANSACTIONS_DAILY.receiver_type = 1 + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + WALLET_TRANSACTIONS_DAILY.receiver_id diff --git a/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql new file mode 100644 index 000000000..1733ce8d8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_adv9_oracle.sql @@ -0,0 +1,10 @@ +SELECT + TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') AS year_month, + COUNT(DISTINCT sender_id) AS active_users +FROM MAIN.WALLET_TRANSACTIONS_DAILY +WHERE + created_at < TRUNC(CURRENT_TIMESTAMP, 'MONTH') + AND created_at >= DATE_SUB(TRUNC(CURRENT_TIMESTAMP, 'MONTH'), 2, MONTH) + AND sender_type = 0 +GROUP BY + TRUNC(CAST(created_at AS TIMESTAMP), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql new file mode 100644 index 000000000..b3d311310 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic10_oracle.sql @@ -0,0 +1,21 @@ +WITH _S1 AS ( + SELECT + amount AS AMOUNT, + receiver_id AS RECEIVER_ID + FROM MAIN.WALLET_TRANSACTIONS_DAILY + WHERE + created_at >= TRUNC(DATE_SUB(CURRENT_TIMESTAMP, 150, DAY), 'DAY') + AND receiver_type = 1 +) +SELECT + ANY_VALUE(MERCHANTS.name) AS merchant_name, + NVL(NULLIF(COUNT(_S1.RECEIVER_ID), 0), 0) AS total_transactions, + NVL(SUM(_S1.AMOUNT), 0) AS total_amount +FROM MAIN.MERCHANTS MERCHANTS +LEFT JOIN _S1 _S1 + ON MERCHANTS.mid = _S1.RECEIVER_ID +GROUP BY + MERCHANTS.mid +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql new file mode 100644 index 000000000..e9bd25cf7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic1_oracle.sql @@ -0,0 +1,12 @@ +SELECT + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS TIMESTAMP), 'MONTH') AS month, + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.sender_id) AS active_users +FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY +JOIN MAIN.USERS USERS + ON USERS.status = 'active' AND USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + EXTRACT(YEAR FROM CAST(WALLET_TRANSACTIONS_DAILY.created_at AS DATETIME)) = 2023 + AND WALLET_TRANSACTIONS_DAILY.sender_type = 0 + AND WALLET_TRANSACTIONS_DAILY.status = 'success' +GROUP BY + TRUNC(CAST(WALLET_TRANSACTIONS_DAILY.created_at AS TIMESTAMP), 'MONTH') diff --git a/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql new file mode 100644 index 000000000..8a6bdf8d9 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic2_oracle.sql @@ -0,0 +1,6 @@ +SELECT + MERCHANTS.mid AS merchant_id, + MERCHANTS.name AS merchant_name +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.COUPONS COUPONS + ON COUPONS.merchant_id = MERCHANTS.mid diff --git a/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql new file mode 100644 index 000000000..6a3d1b881 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic3_oracle.sql @@ -0,0 +1,6 @@ +SELECT + MERCHANTS.mid AS merchant +FROM MAIN.MERCHANTS MERCHANTS +JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON MERCHANTS.mid = WALLET_TRANSACTIONS_DAILY.receiver_id + AND WALLET_TRANSACTIONS_DAILY.receiver_type = 1 diff --git a/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql new file mode 100644 index 000000000..4d70d0ac7 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic4_oracle.sql @@ -0,0 +1,5 @@ +SELECT + USERS.uid AS user_id +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.type = 'transaction' AND NOTIFICATIONS.user_id = USERS.uid diff --git a/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql new file mode 100644 index 000000000..c4afae6f5 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic5_oracle.sql @@ -0,0 +1,6 @@ +SELECT + USERS.uid, + USERS.username +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.user_id = USERS.uid diff --git a/tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql new file mode 100644 index 000000000..1fad261a8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + device_type, + COUNT(*) AS count +FROM MAIN.USER_SESSIONS +GROUP BY + device_type +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 2 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql new file mode 100644 index 000000000..641290b6c --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic7_oracle.sql @@ -0,0 +1,9 @@ +SELECT + status, + COUNT(*) AS count +FROM MAIN.WALLET_TRANSACTIONS_DAILY +GROUP BY + status +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql new file mode 100644 index 000000000..148c636dc --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic8_oracle.sql @@ -0,0 +1,12 @@ +SELECT + ANY_VALUE(COUPONS.code) AS coupon_code, + COUNT(WALLET_TRANSACTIONS_DAILY.txid) AS redemption_count, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_discount +FROM MAIN.COUPONS COUPONS +LEFT JOIN MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY + ON COUPONS.cid = WALLET_TRANSACTIONS_DAILY.coupon_id +GROUP BY + COUPONS.cid +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql b/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql new file mode 100644 index 000000000..6e97509d8 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_basic9_oracle.sql @@ -0,0 +1,14 @@ +SELECT + USERS.country, + COUNT(DISTINCT WALLET_TRANSACTIONS_DAILY.sender_id) AS user_count, + NVL(SUM(WALLET_TRANSACTIONS_DAILY.amount), 0) AS total_amount +FROM MAIN.WALLET_TRANSACTIONS_DAILY WALLET_TRANSACTIONS_DAILY +LEFT JOIN MAIN.USERS USERS + ON USERS.uid = WALLET_TRANSACTIONS_DAILY.sender_id +WHERE + WALLET_TRANSACTIONS_DAILY.sender_type = 0 +GROUP BY + USERS.country +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql new file mode 100644 index 000000000..e9f9f48e5 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen1_oracle.sql @@ -0,0 +1,26 @@ +WITH _T0 AS ( + SELECT + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY WALLET_MERCHANT_BALANCE_DAILY.balance DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(WALLET_MERCHANT_BALANCE_DAILY.balance) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN WALLET_MERCHANT_BALANCE_DAILY.balance + ELSE NULL + END AS EXPR_1 + FROM MAIN.WALLET_MERCHANT_BALANCE_DAILY WALLET_MERCHANT_BALANCE_DAILY + JOIN MAIN.MERCHANTS MERCHANTS + ON LOWER(MERCHANTS.category) LIKE '%retail%' + AND MERCHANTS.mid = WALLET_MERCHANT_BALANCE_DAILY.merchant_id + AND MERCHANTS.status = 'active' + WHERE + TRUNC(CAST(WALLET_MERCHANT_BALANCE_DAILY.updated_at AS TIMESTAMP), 'DAY') = TRUNC(CURRENT_TIMESTAMP, 'DAY') +) +SELECT + AVG(EXPR_1) AS _expr0 +FROM _T0 diff --git a/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql new file mode 100644 index 000000000..eb3840caa --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen2_oracle.sql @@ -0,0 +1,23 @@ +WITH _S0 AS ( + SELECT + MIN(snapshot_date) AS MIN_SNAPSHOT_DATE + FROM MAIN.USER_SETTING_SNAPSHOT + WHERE + EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 +), _S1 AS ( + SELECT + snapshot_date AS SNAPSHOT_DATE, + AVG(tx_limit_daily) AS AVG_TX_LIMIT_DAILY, + AVG(tx_limit_monthly) AS AVG_TX_LIMIT_MONTHLY + FROM MAIN.USER_SETTING_SNAPSHOT + WHERE + EXTRACT(YEAR FROM CAST(snapshot_date AS DATETIME)) = 2023 + GROUP BY + snapshot_date +) +SELECT + _S1.AVG_TX_LIMIT_DAILY AS avg_daily_limit, + _S1.AVG_TX_LIMIT_MONTHLY AS avg_monthly_limit +FROM _S0 _S0 +LEFT JOIN _S1 _S1 + ON _S0.MIN_SNAPSHOT_DATE = _S1.SNAPSHOT_DATE diff --git a/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql new file mode 100644 index 000000000..12217a386 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen3_oracle.sql @@ -0,0 +1,8 @@ +SELECT + device_type, + AVG( + DATEDIFF(CAST(session_end_ts AS DATETIME), CAST(session_start_ts AS DATETIME), SECOND) + ) AS avg_session_duration_seconds +FROM MAIN.USER_SESSIONS +GROUP BY + device_type diff --git a/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql new file mode 100644 index 000000000..51a3f4d03 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen4_oracle.sql @@ -0,0 +1,36 @@ +WITH _T1 AS ( + SELECT + merchant_id AS MERCHANT_ID, + start_date AS START_DATE + FROM MAIN.COUPONS +), _S1 AS ( + SELECT + MERCHANT_ID, + MIN(START_DATE) AS MIN_START_DATE + FROM _T1 + GROUP BY + MERCHANT_ID +), _S4 AS ( + SELECT + MERCHANTS.mid AS MID, + _S1.MIN_START_DATE, + ANY_VALUE(MERCHANTS.created_at) AS ANYTHING_CREATED_AT, + MAX(COUPONS.cid) AS MAX_CID + FROM MAIN.MERCHANTS MERCHANTS + LEFT JOIN _S1 _S1 + ON MERCHANTS.mid = _S1.MERCHANT_ID + LEFT JOIN MAIN.COUPONS COUPONS + ON COUPONS.merchant_id = MERCHANTS.mid AND COUPONS.start_date = _S1.MIN_START_DATE + GROUP BY + MERCHANTS.mid, + _S1.MIN_START_DATE +) +SELECT + _S4.MID AS merchants_id, + _S4.ANYTHING_CREATED_AT AS merchant_registration_date, + _S4.MIN_START_DATE AS earliest_coupon_start_date, + _S4.MAX_CID AS earliest_coupon_id +FROM _S4 _S4 +JOIN _T1 _S5 + ON _S4.MID = _S5.MERCHANT_ID + AND _S5.START_DATE <= DATE_ADD(CAST(_S4.ANYTHING_CREATED_AT AS TIMESTAMP), 1, 'YEAR') diff --git a/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql new file mode 100644 index 000000000..6264d6c93 --- /dev/null +++ b/tests/test_sql_refsols/defog_ewallet_gen5_oracle.sql @@ -0,0 +1,11 @@ +SELECT + USERS.username, + USERS.email, + USERS.created_at +FROM MAIN.USERS USERS +JOIN MAIN.NOTIFICATIONS NOTIFICATIONS + ON NOTIFICATIONS.user_id = USERS.uid +JOIN MAIN.USERS USERS_2 + ON NOTIFICATIONS.created_at <= DATE_ADD(CAST(USERS_2.created_at AS TIMESTAMP), 1, 'YEAR') + AND NOTIFICATIONS.created_at >= USERS_2.created_at + AND NOTIFICATIONS.user_id = USERS_2.uid diff --git a/tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql new file mode 100644 index 000000000..3b989280f --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen10_oracle.sql @@ -0,0 +1,7 @@ +SELECT + name, + rating +FROM MAIN.RESTAURANT +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql new file mode 100644 index 000000000..566fd4aac --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen11_oracle.sql @@ -0,0 +1,15 @@ +WITH _S0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + WHERE + rating > 4.5 +), _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT +) +SELECT + _S0.N_ROWS / _S1.N_ROWS AS ratio +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql new file mode 100644 index 000000000..6140ced43 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen12_oracle.sql @@ -0,0 +1,3 @@ +SELECT + NVL(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio +FROM MAIN.RESTAURANT diff --git a/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql new file mode 100644 index 000000000..3f873154b --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen13_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(rating > 4.0), 0) / NULLIF(SUM(rating < 4.0), 0) AS ratio +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'new york' diff --git a/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql new file mode 100644 index 000000000..d107fd0cd --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen14_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(LOWER(food_type) = 'vegan'), 0) / NULLIF(SUM(LOWER(food_type) <> 'vegan'), 0) AS ratio +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'san francisco' diff --git a/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql new file mode 100644 index 000000000..c4cd6b49b --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen15_oracle.sql @@ -0,0 +1,5 @@ +SELECT + NVL(SUM(LOWER(food_type) = 'italian'), 0) / NULLIF(COUNT(*), 0) AS ratio +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'los angeles' diff --git a/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql new file mode 100644 index 000000000..2a5b78bd7 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen16_oracle.sql @@ -0,0 +1,17 @@ +WITH _T0 AS ( + SELECT + city_name AS CITY_NAME, + name AS NAME, + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + GROUP BY + city_name, + name +) +SELECT + CITY_NAME AS city_name, + NAME AS name, + N_ROWS AS n_restaurants +FROM _T0 +WHERE + N_ROWS > 1 diff --git a/tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql new file mode 100644 index 000000000..af6d498f2 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen17_oracle.sql @@ -0,0 +1,8 @@ +SELECT + city_name, + AVG(rating) AS avg_rating +FROM MAIN.RESTAURANT +WHERE + LOWER(food_type) = 'mexican' +GROUP BY + city_name diff --git a/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql new file mode 100644 index 000000000..64c651bf1 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen18_oracle.sql @@ -0,0 +1,43 @@ +WITH _S0 AS ( + SELECT + city_name AS CITY_NAME, + region AS REGION + FROM MAIN.GEOGRAPHIC +), _S1 AS ( + SELECT + city_name AS CITY_NAME + FROM MAIN.RESTAURANT +), _S6 AS ( + SELECT DISTINCT + _S0.REGION + FROM _S0 _S0 + JOIN _S1 _S1 + ON _S0.CITY_NAME = _S1.CITY_NAME +), _S5 AS ( + SELECT + city_name AS CITY_NAME, + COUNT(rating) AS COUNT_RATING, + SUM(rating) AS SUM_RATING + FROM MAIN.RESTAURANT + GROUP BY + city_name +), _S7 AS ( + SELECT + SUM(_S5.SUM_RATING) / SUM(_S5.COUNT_RATING) AS AVG_RATING, + _S2.REGION + FROM _S0 _S2 + JOIN _S1 _S3 + ON _S2.CITY_NAME = _S3.CITY_NAME + JOIN _S5 _S5 + ON _S2.CITY_NAME = _S5.CITY_NAME + GROUP BY + _S2.REGION +) +SELECT + _S6.REGION AS rest_region, + _S7.AVG_RATING AS avg_rating +FROM _S6 _S6 +LEFT JOIN _S7 _S7 + ON _S6.REGION = _S7.REGION +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql new file mode 100644 index 000000000..c181210f5 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen19_oracle.sql @@ -0,0 +1,21 @@ +WITH _S0 AS ( + SELECT + city_name AS CITY_NAME, + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + WHERE + LOWER(food_type) = 'italian' + GROUP BY + city_name +) +SELECT + GEOGRAPHIC.region AS rest_region, + SUM(_S0.N_ROWS) AS n_restaurants +FROM _S0 _S0 +JOIN MAIN.GEOGRAPHIC GEOGRAPHIC + ON GEOGRAPHIC.city_name = _S0.CITY_NAME +GROUP BY + GEOGRAPHIC.region +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql new file mode 100644 index 000000000..d75957d8f --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen1_oracle.sql @@ -0,0 +1,6 @@ +SELECT + food_type, + COUNT(*) AS restaurants +FROM MAIN.RESTAURANT +GROUP BY + food_type diff --git a/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql new file mode 100644 index 000000000..4d1d8701d --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen20_oracle.sql @@ -0,0 +1,19 @@ +WITH _S0 AS ( + SELECT + city_name AS CITY_NAME, + COUNT(*) AS N_ROWS + FROM MAIN.RESTAURANT + GROUP BY + city_name +) +SELECT + GEOGRAPHIC.region AS rest_region, + SUM(_S0.N_ROWS) AS n_restaurants +FROM _S0 _S0 +JOIN MAIN.GEOGRAPHIC GEOGRAPHIC + ON GEOGRAPHIC.city_name = _S0.CITY_NAME +GROUP BY + GEOGRAPHIC.region +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql new file mode 100644 index 000000000..7ee13cbdd --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen21_oracle.sql @@ -0,0 +1,6 @@ +SELECT + city_name +FROM MAIN.RESTAURANT +ORDER BY + rating DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql new file mode 100644 index 000000000..47cfd7ec6 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen22_oracle.sql @@ -0,0 +1,6 @@ +SELECT + name, + rating +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'new york' AND rating > 4 diff --git a/tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql new file mode 100644 index 000000000..765fb6c80 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen23_oracle.sql @@ -0,0 +1,9 @@ +SELECT + RESTAURANT.name, + RESTAURANT.food_type +FROM MAIN.LOCATION LOCATION +JOIN MAIN.RESTAURANT RESTAURANT + ON LOCATION.restaurant_id = RESTAURANT.id +WHERE + LOWER(LOCATION.city_name) = 'san francisco' + AND LOWER(LOCATION.street_name) = 'market st' diff --git a/tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql new file mode 100644 index 000000000..f1628a159 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen24_oracle.sql @@ -0,0 +1,5 @@ +SELECT + name +FROM MAIN.RESTAURANT +WHERE + LOWER(food_type) = 'italian' diff --git a/tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql new file mode 100644 index 000000000..b88818312 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen25_oracle.sql @@ -0,0 +1,5 @@ +SELECT + name +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'los angeles' AND rating > 4 diff --git a/tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql new file mode 100644 index 000000000..c4ec51cdf --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen2_oracle.sql @@ -0,0 +1,6 @@ +SELECT + city_name, + COUNT(*) AS total_count +FROM MAIN.LOCATION +GROUP BY + city_name diff --git a/tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql new file mode 100644 index 000000000..edb9bf11b --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen3_oracle.sql @@ -0,0 +1,9 @@ +SELECT + food_type, + AVG(rating) AS avg_rating +FROM MAIN.RESTAURANT +GROUP BY + food_type +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql new file mode 100644 index 000000000..be1d37312 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen4_oracle.sql @@ -0,0 +1,11 @@ +SELECT + city_name, + COUNT(*) AS num_restaurants +FROM MAIN.RESTAURANT +WHERE + LOWER(food_type) = 'italian' +GROUP BY + city_name +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql new file mode 100644 index 000000000..d9d423edc --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen5_oracle.sql @@ -0,0 +1,9 @@ +SELECT + city_name, + COUNT(*) AS num_restaurants +FROM MAIN.LOCATION +GROUP BY + city_name +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql new file mode 100644 index 000000000..e1eda430d --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen6_oracle.sql @@ -0,0 +1,8 @@ +SELECT + street_name +FROM MAIN.LOCATION +GROUP BY + street_name +ORDER BY + COUNT(*) DESC NULLS LAST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql new file mode 100644 index 000000000..2dd5e2521 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen7_oracle.sql @@ -0,0 +1,5 @@ +SELECT + name +FROM MAIN.RESTAURANT +WHERE + LOWER(city_name) = 'new york' OR LOWER(food_type) = 'italian' diff --git a/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql new file mode 100644 index 000000000..597e3305d --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen8_oracle.sql @@ -0,0 +1,33 @@ +WITH _S1 AS ( + SELECT + city_name AS CITY_NAME, + region AS REGION + FROM MAIN.GEOGRAPHIC +), _S6 AS ( + SELECT DISTINCT + _S1.REGION + FROM MAIN.LOCATION LOCATION + LEFT JOIN _S1 _S1 + ON LOCATION.city_name = _S1.CITY_NAME +), _S7 AS ( + SELECT + _S3.REGION, + SUM(CASE WHEN NOT RESTAURANT.rating IS NULL THEN 1 ELSE 0 END) AS SUM_EXPR, + SUM(RESTAURANT.rating) AS SUM_RATING + FROM MAIN.LOCATION LOCATION + LEFT JOIN _S1 _S3 + ON LOCATION.city_name = _S3.CITY_NAME + JOIN MAIN.RESTAURANT RESTAURANT + ON LOCATION.restaurant_id = RESTAURANT.id + GROUP BY + _S3.REGION +) +SELECT + _S6.REGION AS region_name, + _S7.SUM_RATING / _S7.SUM_EXPR AS avg_rating +FROM _S6 _S6 +JOIN _S7 _S7 + ON _S6.REGION = _S7.REGION +ORDER BY + 1 NULLS FIRST, + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql b/tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql new file mode 100644 index 000000000..9f8c97897 --- /dev/null +++ b/tests/test_sql_refsols/defog_restaurants_gen9_oracle.sql @@ -0,0 +1,7 @@ +SELECT + name +FROM MAIN.RESTAURANT +ORDER BY + rating DESC NULLS LAST, + 1 DESC NULLS LAST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/double_cross_oracle.sql b/tests/test_sql_refsols/double_cross_oracle.sql new file mode 100644 index 000000000..ec5eea326 --- /dev/null +++ b/tests/test_sql_refsols/double_cross_oracle.sql @@ -0,0 +1,68 @@ +WITH _T3 AS ( + SELECT + o_orderdate AS O_ORDERDATE + FROM TPCH.ORDERS +), _S0 AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM _T3 +), _S2 AS ( + SELECT + DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) AS ORD_WK, + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN TPCH.ORDERS ORDERS + ON DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) < 10 + AND ORDERS.o_orderpriority = '1-URGENT' + AND ORDERS.o_orderstatus = 'F' + GROUP BY + DATEDIFF(CAST(ORDERS.o_orderdate AS DATETIME), CAST(_S0.MIN_O_ORDERDATE AS DATETIME), WEEK) +), _S3 AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM _T3 +), _T0 AS ( + SELECT + DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ) AS LINE_WK, + _S2.ORD_WK, + ANY_VALUE(_S2.N_ROWS) AS ANYTHING_N_ROWS, + COUNT(*) AS N_ROWS + FROM _S2 _S2 + CROSS JOIN _S3 _S3 + JOIN TPCH.LINEITEM LINEITEM + ON DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ) < 10 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1992 + AND LINEITEM.l_returnflag = 'R' + AND LINEITEM.l_shipmode = 'RAIL' + AND _S2.ORD_WK = DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ) + GROUP BY + DATEDIFF( + CAST(LINEITEM.l_receiptdate AS DATETIME), + CAST(_S3.MIN_O_ORDERDATE AS DATETIME), + WEEK + ), + _S2.ORD_WK +) +SELECT + ORD_WK AS wk, + N_ROWS AS n_lines, + ANYTHING_N_ROWS AS n_orders, + ROUND( + SUM(N_ROWS) OVER (ORDER BY LINE_WK ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(ANYTHING_N_ROWS) OVER (ORDER BY ORD_WK ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 4 + ) AS lpo +FROM _T0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/double_partition_oracle.sql b/tests/test_sql_refsols/double_partition_oracle.sql new file mode 100644 index 000000000..843f4d0f3 --- /dev/null +++ b/tests/test_sql_refsols/double_partition_oracle.sql @@ -0,0 +1,15 @@ +WITH _T0 AS ( + SELECT + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) +) +SELECT + YEAR_O_ORDERDATE AS year, + MAX(N_ROWS) AS best_month +FROM _T0 +GROUP BY + YEAR_O_ORDERDATE diff --git a/tests/test_sql_refsols/dumb_aggregation_oracle.sql b/tests/test_sql_refsols/dumb_aggregation_oracle.sql new file mode 100644 index 000000000..18c231309 --- /dev/null +++ b/tests/test_sql_refsols/dumb_aggregation_oracle.sql @@ -0,0 +1,46 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 2 ROWS ONLY +), _S1 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY r_regionkey ORDER BY r_regionkey DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(r_regionkey) OVER (PARTITION BY r_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN r_regionkey + ELSE NULL + END AS AVG_EXPR + FROM TPCH.REGION +) +SELECT + _S0.N_NAME AS nation_name, + _S1.R_NAME AS a1, + _S1.R_NAME AS a2, + _S1.R_REGIONKEY AS a3, + CASE + WHEN NOT CASE WHEN _S1.R_NAME <> 'AMERICA' THEN _S1.R_REGIONKEY ELSE NULL END IS NULL + THEN 1 + ELSE 0 + END AS a4, + 1 AS a5, + _S1.R_REGIONKEY AS a6, + _S1.R_NAME AS a7, + _S1.AVG_EXPR AS a8 +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.N_REGIONKEY = _S1.R_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql new file mode 100644 index 000000000..50f710944 --- /dev/null +++ b/tests/test_sql_refsols/epoch_culture_events_info_oracle.sql @@ -0,0 +1,32 @@ +WITH _S2 AS ( + SELECT + ev_dt AS EV_DT, + ev_key AS EV_KEY + FROM EVENTS +) +SELECT + EVENTS.ev_name AS event_name, + ERAS.er_name AS era_name, + EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) AS event_year, + SEASONS.s_name AS season_name, + TIMES.t_name AS tod +FROM EVENTS EVENTS +JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) +JOIN _S2 _S2 + ON EVENTS.ev_key = _S2.EV_KEY +JOIN SEASONS SEASONS + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(_S2.EV_DT AS DATETIME)) +JOIN _S2 _S6 + ON EVENTS.ev_key = _S6.EV_KEY +JOIN TIMES TIMES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(_S6.EV_DT AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(_S6.EV_DT AS DATETIME)) +WHERE + EVENTS.ev_typ = 'culture' +ORDER BY + EVENTS.ev_dt NULLS FIRST +FETCH FIRST 6 ROWS ONLY diff --git a/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql new file mode 100644 index 000000000..ade631cd8 --- /dev/null +++ b/tests/test_sql_refsols/epoch_event_gap_per_era_oracle.sql @@ -0,0 +1,27 @@ +WITH _T2 AS ( + SELECT + ERAS.er_end_year AS ER_END_YEAR, + ERAS.er_name AS ER_NAME, + ERAS.er_start_year AS ER_START_YEAR, + EVENTS.ev_dt AS EV_DT, + DATEDIFF( + CAST(EVENTS.ev_dt AS DATETIME), + CAST(LAG(EVENTS.ev_dt, 1) OVER (PARTITION BY ERAS.er_name, ERAS.er_name ORDER BY EVENTS.ev_dt) AS DATETIME), + DAY + ) AS DAY_GAP + FROM ERAS ERAS + JOIN EVENTS EVENTS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) +) +SELECT + ER_NAME AS era_name, + AVG(DAY_GAP) AS avg_event_gap +FROM _T2 +WHERE + ER_END_YEAR > EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) + AND ER_START_YEAR <= EXTRACT(YEAR FROM CAST(EV_DT AS DATETIME)) +GROUP BY + ER_NAME +ORDER BY + ANY_VALUE(ER_START_YEAR) NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_events_per_season_oracle.sql b/tests/test_sql_refsols/epoch_events_per_season_oracle.sql new file mode 100644 index 000000000..585bbad16 --- /dev/null +++ b/tests/test_sql_refsols/epoch_events_per_season_oracle.sql @@ -0,0 +1,13 @@ +SELECT + SEASONS.s_name AS season_name, + COUNT(*) AS n_events +FROM SEASONS SEASONS +JOIN EVENTS EVENTS + ON SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) +GROUP BY + SEASONS.s_name +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql new file mode 100644 index 000000000..4c896c87b --- /dev/null +++ b/tests/test_sql_refsols/epoch_first_event_per_era_oracle.sql @@ -0,0 +1,19 @@ +WITH _T AS ( + SELECT + ERAS.er_name AS ER_NAME, + ERAS.er_start_year AS ER_START_YEAR, + EVENTS.ev_name AS EV_NAME, + ROW_NUMBER() OVER (PARTITION BY ERAS.er_name ORDER BY EVENTS.ev_dt) AS _W + FROM ERAS ERAS + JOIN EVENTS EVENTS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) +) +SELECT + ER_NAME AS era_name, + EV_NAME AS event_name +FROM _T +WHERE + _W = 1 +ORDER BY + ER_START_YEAR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql new file mode 100644 index 000000000..766e646c5 --- /dev/null +++ b/tests/test_sql_refsols/epoch_intra_season_searches_oracle.sql @@ -0,0 +1,86 @@ +WITH _S0 AS ( + SELECT + s_month1 AS S_MONTH1, + s_month2 AS S_MONTH2, + s_month3 AS S_MONTH3, + s_name AS S_NAME + FROM SEASONS +), _S5 AS ( + SELECT + ev_dt AS EV_DT, + ev_name AS EV_NAME + FROM EVENTS +), _S9 AS ( + SELECT + _S2.S_NAME, + SEARCHES.search_id AS SEARCH_ID + FROM _S0 _S2 + JOIN SEARCHES SEARCHES + ON _S2.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S2.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S2.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + JOIN _S5 _S5 + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(_S5.EV_NAME), '%') + JOIN _S0 _S7 + ON _S2.S_NAME = _S7.S_NAME + AND ( + _S7.S_MONTH1 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + OR _S7.S_MONTH2 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + OR _S7.S_MONTH3 = EXTRACT(MONTH FROM CAST(_S5.EV_DT AS DATETIME)) + ) +), _T1 AS ( + SELECT + _S0.S_NAME, + COUNT(_S9.SEARCH_ID) AS COUNT_SEARCH_ID + FROM _S0 _S0 + JOIN SEARCHES SEARCHES + ON _S0.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S0.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S0.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + LEFT JOIN _S9 _S9 + ON SEARCHES.search_id = _S9.SEARCH_ID AND _S0.S_NAME = _S9.S_NAME + GROUP BY + SEARCHES.search_id, + _S0.S_NAME +), _S16 AS ( + SELECT + S_NAME, + COUNT(*) AS N_ROWS, + SUM(( + NOT NULLIF(COUNT_SEARCH_ID, 0) IS NULL AND NULLIF(COUNT_SEARCH_ID, 0) > 0 + )) AS SUM_IS_INTRA_SEASON + FROM _T1 + GROUP BY + S_NAME +), _S17 AS ( + SELECT + _S10.S_NAME, + COUNT(*) AS N_ROWS, + SUM(_S15.S_NAME = _S10.S_NAME) AS SUM_IS_INTRA_SEASON + FROM _S0 _S10 + JOIN _S5 _S11 + ON _S10.S_MONTH1 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + OR _S10.S_MONTH2 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + OR _S10.S_MONTH3 = EXTRACT(MONTH FROM CAST(_S11.EV_DT AS DATETIME)) + JOIN SEARCHES SEARCHES + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(_S11.EV_NAME), '%') + JOIN _S0 _S15 + ON _S15.S_MONTH1 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S15.S_MONTH2 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + OR _S15.S_MONTH3 = EXTRACT(MONTH FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + _S10.S_NAME +) +SELECT + _S16.S_NAME AS season_name, + ROUND(( + 100.0 * NVL(_S16.SUM_IS_INTRA_SEASON, 0) + ) / _S16.N_ROWS, 2) AS pct_season_searches, + ROUND(( + 100.0 * NVL(_S17.SUM_IS_INTRA_SEASON, 0) + ) / NVL(_S17.N_ROWS, 0), 2) AS pct_event_searches +FROM _S16 _S16 +LEFT JOIN _S17 _S17 + ON _S16.S_NAME = _S17.S_NAME +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql new file mode 100644 index 000000000..02aa44615 --- /dev/null +++ b/tests/test_sql_refsols/epoch_most_popular_search_engine_per_tod_oracle.sql @@ -0,0 +1,29 @@ +WITH _T2 AS ( + SELECT + SEARCHES.search_engine AS SEARCH_ENGINE, + TIMES.t_name AS T_NAME, + COUNT(*) AS N_ROWS + FROM TIMES TIMES + JOIN SEARCHES SEARCHES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + SEARCHES.search_engine, + TIMES.t_name +), _T AS ( + SELECT + SEARCH_ENGINE, + T_NAME, + N_ROWS, + ROW_NUMBER() OVER (PARTITION BY T_NAME ORDER BY N_ROWS DESC, SEARCH_ENGINE) AS _W + FROM _T2 +) +SELECT + T_NAME AS tod, + SEARCH_ENGINE AS search_engine, + N_ROWS AS n_searches +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql b/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql new file mode 100644 index 000000000..9299070ad --- /dev/null +++ b/tests/test_sql_refsols/epoch_most_popular_topic_per_region_oracle.sql @@ -0,0 +1,28 @@ +WITH _T1 AS ( + SELECT + EVENTS.ev_typ AS EV_TYP, + USERS.user_region AS USER_REGION, + COUNT(DISTINCT SEARCHES.search_id) AS NDISTINCT_SEARCH_ID + FROM EVENTS EVENTS + JOIN SEARCHES SEARCHES + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN USERS USERS + ON SEARCHES.search_user_id = USERS.user_id + GROUP BY + EVENTS.ev_typ, + USERS.user_region +), _T AS ( + SELECT + EV_TYP, + USER_REGION, + NDISTINCT_SEARCH_ID, + ROW_NUMBER() OVER (PARTITION BY USER_REGION ORDER BY NDISTINCT_SEARCH_ID DESC) AS _W + FROM _T1 +) +SELECT + USER_REGION AS region, + EV_TYP AS event_type, + NDISTINCT_SEARCH_ID AS n_searches +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql new file mode 100644 index 000000000..94566b070 --- /dev/null +++ b/tests/test_sql_refsols/epoch_num_predawn_cold_war_oracle.sql @@ -0,0 +1,19 @@ +WITH _S0 AS ( + SELECT + ev_dt AS EV_DT, + ev_key AS EV_KEY + FROM EVENTS +) +SELECT + COUNT(DISTINCT _S0.EV_KEY) AS n_events +FROM _S0 _S0 +JOIN TIMES TIMES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(_S0.EV_DT AS DATETIME)) + AND TIMES.t_name = 'Pre-Dawn' + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(_S0.EV_DT AS DATETIME)) +JOIN _S0 _S2 + ON _S0.EV_KEY = _S2.EV_KEY +JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(_S2.EV_DT AS DATETIME)) + AND ERAS.er_name = 'Cold War' + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(_S2.EV_DT AS DATETIME)) diff --git a/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql b/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql new file mode 100644 index 000000000..46530b80a --- /dev/null +++ b/tests/test_sql_refsols/epoch_overlapping_event_search_other_users_per_user_oracle.sql @@ -0,0 +1,29 @@ +WITH _S0 AS ( + SELECT + user_id AS USER_ID, + user_name AS USER_NAME + FROM USERS +), _S1 AS ( + SELECT + search_string AS SEARCH_STRING, + search_user_id AS SEARCH_USER_ID + FROM SEARCHES +) +SELECT + ANY_VALUE(_S0.USER_NAME) AS user_name, + COUNT(DISTINCT _S7.USER_ID) AS n_other_users +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.USER_ID = _S1.SEARCH_USER_ID +JOIN EVENTS EVENTS + ON LOWER(_S1.SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') +JOIN _S1 _S5 + ON LOWER(_S5.SEARCH_STRING) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') +JOIN _S0 _S7 + ON _S0.USER_NAME <> _S7.USER_NAME AND _S5.SEARCH_USER_ID = _S7.USER_ID +GROUP BY + _S0.USER_ID +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 7 ROWS ONLY diff --git a/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql b/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql new file mode 100644 index 000000000..ab4c80c99 --- /dev/null +++ b/tests/test_sql_refsols/epoch_overlapping_event_searches_per_user_oracle.sql @@ -0,0 +1,35 @@ +WITH _S0 AS ( + SELECT + user_id AS USER_ID, + user_name AS USER_NAME + FROM USERS +), _T2 AS ( + SELECT + _S0.USER_ID, + ANY_VALUE(SEARCHES.search_user_id) AS ANYTHING_SEARCH_USER_ID, + ANY_VALUE(_S0.USER_NAME) AS ANYTHING_USER_NAME + FROM _S0 _S0 + JOIN SEARCHES SEARCHES + ON SEARCHES.search_user_id = _S0.USER_ID + JOIN EVENTS EVENTS + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN SEARCHES SEARCHES_2 + ON LOWER(SEARCHES_2.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN _S0 _S7 + ON SEARCHES_2.search_user_id = _S7.USER_ID AND _S0.USER_NAME <> _S7.USER_NAME + GROUP BY + SEARCHES.search_id, + _S0.USER_ID +) +SELECT + ANY_VALUE(ANYTHING_USER_NAME) AS user_name, + COUNT(*) AS n_searches +FROM _T2 +WHERE + ANYTHING_SEARCH_USER_ID = USER_ID +GROUP BY + USER_ID +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 4 ROWS ONLY diff --git a/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql new file mode 100644 index 000000000..55a1b08b5 --- /dev/null +++ b/tests/test_sql_refsols/epoch_pct_searches_per_tod_oracle.sql @@ -0,0 +1,20 @@ +WITH _T0 AS ( + SELECT + TIMES.t_name AS T_NAME, + ANY_VALUE(TIMES.t_start_hour) AS ANYTHING_T_START_HOUR, + COUNT(*) AS N_ROWS + FROM TIMES TIMES + JOIN SEARCHES SEARCHES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + TIMES.t_name +) +SELECT + T_NAME AS tod, + ROUND(( + 100.0 * N_ROWS + ) / SUM(N_ROWS) OVER (), 2) AS pct_searches +FROM _T0 +ORDER BY + ANYTHING_T_START_HOUR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql new file mode 100644 index 000000000..518f51a92 --- /dev/null +++ b/tests/test_sql_refsols/epoch_search_results_by_tod_oracle.sql @@ -0,0 +1,22 @@ +WITH _T0 AS ( + SELECT + TIMES.t_name AS T_NAME, + ANY_VALUE(TIMES.t_start_hour) AS ANYTHING_T_START_HOUR, + AVG(SEARCHES.search_num_results) AS AVG_SEARCH_NUM_RESULTS, + COUNT(*) AS N_ROWS + FROM TIMES TIMES + JOIN SEARCHES SEARCHES + ON TIMES.t_end_hour > EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + AND TIMES.t_start_hour <= EXTRACT(HOUR FROM CAST(SEARCHES.search_ts AS DATETIME)) + GROUP BY + TIMES.t_name +) +SELECT + T_NAME AS tod, + ROUND(( + 100.0 * N_ROWS + ) / SUM(N_ROWS) OVER (), 2) AS pct_searches, + ROUND(AVG_SEARCH_NUM_RESULTS, 2) AS avg_results +FROM _T0 +ORDER BY + ANYTHING_T_START_HOUR NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql b/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql new file mode 100644 index 000000000..da14a0d97 --- /dev/null +++ b/tests/test_sql_refsols/epoch_summer_events_per_type_oracle.sql @@ -0,0 +1,15 @@ +SELECT + EVENTS.ev_typ AS event_type, + COUNT(*) AS n_events +FROM EVENTS EVENTS +JOIN SEASONS SEASONS + ON ( + SEASONS.s_month1 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month2 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + OR SEASONS.s_month3 = EXTRACT(MONTH FROM CAST(EVENTS.ev_dt AS DATETIME)) + ) + AND SEASONS.s_name = 'Summer' +GROUP BY + EVENTS.ev_typ +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql new file mode 100644 index 000000000..9c93974e4 --- /dev/null +++ b/tests/test_sql_refsols/epoch_unique_users_per_engine_oracle.sql @@ -0,0 +1,23 @@ +WITH _S0 AS ( + SELECT DISTINCT + search_engine AS SEARCH_ENGINE + FROM SEARCHES +), _S1 AS ( + SELECT + search_engine AS SEARCH_ENGINE, + COUNT(DISTINCT search_user_id) AS NDISTINCT_SEARCH_USER_ID + FROM SEARCHES + WHERE + EXTRACT(YEAR FROM CAST(search_ts AS DATETIME)) <= 2019 + AND EXTRACT(YEAR FROM CAST(search_ts AS DATETIME)) >= 2010 + GROUP BY + search_engine +) +SELECT + _S0.SEARCH_ENGINE AS engine, + NVL(_S1.NDISTINCT_SEARCH_USER_ID, 0) AS n_users +FROM _S0 _S0 +LEFT JOIN _S1 _S1 + ON _S0.SEARCH_ENGINE = _S1.SEARCH_ENGINE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql new file mode 100644 index 000000000..30588f15b --- /dev/null +++ b/tests/test_sql_refsols/epoch_users_most_cold_war_searches_oracle.sql @@ -0,0 +1,30 @@ +WITH _T1 AS ( + SELECT + ANY_VALUE(SEARCHES.search_user_id) AS ANYTHING_SEARCH_USER_ID + FROM SEARCHES SEARCHES + JOIN EVENTS EVENTS + ON LOWER(SEARCHES.search_string) LIKE CONCAT('%', LOWER(EVENTS.ev_name), '%') + JOIN ERAS ERAS + ON ERAS.er_end_year > EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + AND ERAS.er_name = 'Cold War' + AND ERAS.er_start_year <= EXTRACT(YEAR FROM CAST(EVENTS.ev_dt AS DATETIME)) + GROUP BY + SEARCHES.search_id +), _S5 AS ( + SELECT + ANYTHING_SEARCH_USER_ID, + COUNT(*) AS N_ROWS + FROM _T1 + GROUP BY + ANYTHING_SEARCH_USER_ID +) +SELECT + USERS.user_name, + _S5.N_ROWS AS n_cold_war_searches +FROM USERS USERS +JOIN _S5 _S5 + ON USERS.user_id = _S5.ANYTHING_SEARCH_USER_ID +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/extract_colors_oracle.sql b/tests/test_sql_refsols/extract_colors_oracle.sql new file mode 100644 index 000000000..89b70ac66 --- /dev/null +++ b/tests/test_sql_refsols/extract_colors_oracle.sql @@ -0,0 +1,283 @@ +WITH _S0 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 1 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S0 + WHERE + rest <> '' +), _S1 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S0 +), _S2 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 2 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S2 + WHERE + rest <> '' +), _S3 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S2 +), _S4 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 3 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S4 + WHERE + rest <> '' +), _S5 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S4 +), _S6 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 4 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S6 + WHERE + rest <> '' +), _S7 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S6 +), _S8 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 5 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S8 + WHERE + rest <> '' +), _S9 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S8 +), _S10 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + P_NAME AS REST, + ' ' AS DELIM, + 6 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S10 + WHERE + rest <> '' +), _S11 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S10 +) +SELECT + p_partkey AS key, + UPPER( + ( + SELECT + _S0.PART + FROM _S0 _S0 + CROSS JOIN _S1 _S1 + WHERE + _S0.PART_INDEX <> 0 + AND _S0.PART_INDEX = CASE + WHEN _S0.IDX > 0 + THEN _S0.IDX + WHEN _S0.IDX < 0 + THEN _S1.TOTAL_PARTS + _S0.IDX + 1 + ELSE 1 + END + ) + ) AS c1, + UPPER( + ( + SELECT + _S2.PART + FROM _S2 _S2 + CROSS JOIN _S3 _S3 + WHERE + _S2.PART_INDEX <> 0 + AND _S2.PART_INDEX = CASE + WHEN _S2.IDX > 0 + THEN _S2.IDX + WHEN _S2.IDX < 0 + THEN _S3.TOTAL_PARTS + _S2.IDX + 1 + ELSE 1 + END + ) + ) AS c2, + UPPER( + ( + SELECT + _S4.PART + FROM _S4 _S4 + CROSS JOIN _S5 _S5 + WHERE + _S4.PART_INDEX <> 0 + AND _S4.PART_INDEX = CASE + WHEN _S4.IDX > 0 + THEN _S4.IDX + WHEN _S4.IDX < 0 + THEN _S5.TOTAL_PARTS + _S4.IDX + 1 + ELSE 1 + END + ) + ) AS c3, + UPPER( + ( + SELECT + _S6.PART + FROM _S6 _S6 + CROSS JOIN _S7 _S7 + WHERE + _S6.PART_INDEX <> 0 + AND _S6.PART_INDEX = CASE + WHEN _S6.IDX > 0 + THEN _S6.IDX + WHEN _S6.IDX < 0 + THEN _S7.TOTAL_PARTS + _S6.IDX + 1 + ELSE 1 + END + ) + ) AS c4, + UPPER( + ( + SELECT + _S8.PART + FROM _S8 _S8 + CROSS JOIN _S9 _S9 + WHERE + _S8.PART_INDEX <> 0 + AND _S8.PART_INDEX = CASE + WHEN _S8.IDX > 0 + THEN _S8.IDX + WHEN _S8.IDX < 0 + THEN _S9.TOTAL_PARTS + _S8.IDX + 1 + ELSE 1 + END + ) + ) AS c5, + UPPER( + ( + SELECT + _S10.PART + FROM _S10 _S10 + CROSS JOIN _S11 _S11 + WHERE + _S10.PART_INDEX <> 0 + AND _S10.PART_INDEX = CASE + WHEN _S10.IDX > 0 + THEN _S10.IDX + WHEN _S10.IDX < 0 + THEN _S11.TOTAL_PARTS + _S10.IDX + 1 + ELSE 1 + END + ) + ) AS c6 +FROM TPCH.PART +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/first_order_in_year_oracle.sql b/tests/test_sql_refsols/first_order_in_year_oracle.sql new file mode 100644 index 000000000..b7bff4dc7 --- /dev/null +++ b/tests/test_sql_refsols/first_order_in_year_oracle.sql @@ -0,0 +1,19 @@ +WITH _T AS ( + SELECT + o_orderdate AS O_ORDERDATE, + o_orderkey AS O_ORDERKEY, + LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS _W, + LAG(o_orderdate, 1) OVER (ORDER BY o_orderdate, o_orderkey) AS _W_2 + FROM TPCH.ORDERS + WHERE + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 +) +SELECT + O_ORDERDATE AS order_date, + O_ORDERKEY AS key +FROM _T +WHERE + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) <> EXTRACT(YEAR FROM CAST(_W_2 AS DATETIME)) + OR _W IS NULL +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/first_order_per_customer_oracle.sql b/tests/test_sql_refsols/first_order_per_customer_oracle.sql new file mode 100644 index 000000000..e13ddceda --- /dev/null +++ b/tests/test_sql_refsols/first_order_per_customer_oracle.sql @@ -0,0 +1,20 @@ +WITH _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + o_totalprice AS O_TOTALPRICE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_orderdate, o_orderkey) AS _W + FROM TPCH.ORDERS +) +SELECT + CUSTOMER.c_name AS name, + _T.O_ORDERDATE AS first_order_date, + _T.O_TOTALPRICE AS first_order_price +FROM TPCH.CUSTOMER CUSTOMER +JOIN _T _T + ON CUSTOMER.c_custkey = _T.O_CUSTKEY AND _T._W = 1 +WHERE + CUSTOMER.c_acctbal >= 9000.0 +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/floor_and_ceil_2_oracle.sql b/tests/test_sql_refsols/floor_and_ceil_2_oracle.sql new file mode 100644 index 000000000..9bf1dda59 --- /dev/null +++ b/tests/test_sql_refsols/floor_and_ceil_2_oracle.sql @@ -0,0 +1,9 @@ +SELECT + ps_suppkey AS supplier_key, + ps_partkey AS part_key, + FLOOR(ps_availqty) AS complete_parts, + CEIL(ps_supplycost * FLOOR(ps_availqty)) AS total_cost +FROM TPCH.PARTSUPP +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/floor_and_ceil_oracle.sql b/tests/test_sql_refsols/floor_and_ceil_oracle.sql new file mode 100644 index 000000000..fbccc9e04 --- /dev/null +++ b/tests/test_sql_refsols/floor_and_ceil_oracle.sql @@ -0,0 +1,11 @@ +SELECT + FLOOR(5.6) AS floor_frac, + CEIL(5.4) AS ceil_frac, + FLOOR(-5.4) AS floor_frac_neg, + CEIL(-5.6) AS ceil_frac_neg, + FLOOR(6) AS floor_int, + CEIL(6) AS ceil_int, + FLOOR(-6) AS floor_int_neg, + CEIL(-6) AS ceil_int_neg +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/get_part_multiple_oracle.sql b/tests/test_sql_refsols/get_part_multiple_oracle.sql new file mode 100644 index 000000000..67d366df4 --- /dev/null +++ b/tests/test_sql_refsols/get_part_multiple_oracle.sql @@ -0,0 +1,212 @@ +SELECT + CAST(SUBSTR(sbcustid, 2) AS INT) AS _expr0, + REGEXP_SUBSTR( + sbcustname, + '[^ ]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, ' ') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p1, + REGEXP_SUBSTR( + sbcustname, + '[^ ]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, ' ') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p2, + REGEXP_SUBSTR( + sbcustemail, + '[^.]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustemail, '.') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p3, + REGEXP_SUBSTR( + sbcustemail, + '[^.]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustemail, '.') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p4, + REGEXP_SUBSTR( + sbcustphone, + '[^-]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustphone, '-') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p5, + REGEXP_SUBSTR( + sbcustphone, + '[^-]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustphone, '-') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p6, + REGEXP_SUBSTR( + sbcustpostalcode, + '[^00]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustpostalcode, '00') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p7, + REGEXP_SUBSTR( + sbcustpostalcode, + '[^00]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustpostalcode, '00') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p8, + REGEXP_SUBSTR( + sbcustname, + '[^!]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '!') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p9, + REGEXP_SUBSTR( + sbcustname, + '[^@]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '@') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p10, + REGEXP_SUBSTR( + sbcustname, + '[^aa]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, 'aa') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p11, + REGEXP_SUBSTR( + sbcustname, + '[^#$*]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN 0 - CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '#$*') + 1 - CAST(SUBSTR(sbcustid, 2) AS INT) + 1 + END + ) AS p12, + REGEXP_SUBSTR( + sbcustname, + '[^]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustname, '') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p13, + REGEXP_SUBSTR( + '', + '[^ ]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT('', ' ') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p14, + REGEXP_SUBSTR(sbcustname, '[^ ]+', 1, 1) AS p15, + REGEXP_SUBSTR( + sbcuststate, + '[^' || sbcuststate || ']+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcuststate, sbcuststate) + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p16, + REGEXP_SUBSTR( + REGEXP_SUBSTR(sbcustphone, '[^-]+', 1, 1), + '[^5]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(REGEXP_SUBSTR(sbcustphone, '[^-]+', 1, 1), '5') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p17, + REGEXP_SUBSTR( + sbcustpostalcode, + '[^0]+', + 1, + CASE + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) = 0 + THEN 1 + WHEN CAST(SUBSTR(sbcustid, 2) AS INT) > 0 + THEN CAST(SUBSTR(sbcustid, 2) AS INT) + ELSE REGEXP_COUNT(sbcustpostalcode, '0') + 2 + CAST(SUBSTR(sbcustid, 2) AS INT) + END + ) AS p18 +FROM MAIN.SBCUSTOMER +WHERE + CAST(SUBSTR(sbcustid, 2) AS INT) <= 4 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/get_part_single_oracle.sql b/tests/test_sql_refsols/get_part_single_oracle.sql new file mode 100644 index 000000000..5b24c77cb --- /dev/null +++ b/tests/test_sql_refsols/get_part_single_oracle.sql @@ -0,0 +1,49 @@ +WITH _S0 AS ( + SELECT + 0 AS PART_INDEX, + '' AS PART, + SBCUSTNAME AS REST, + ' ' AS DELIM, + -1 AS IDX + UNION ALL + SELECT + part_index + 1 AS PART_INDEX, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN rest + ELSE SUBSTR(rest, 1, INSTR(rest, delim) - 1) + END AS PART, + CASE + WHEN INSTR(rest, delim) = 0 OR delim = '' + THEN '' + ELSE SUBSTR(rest, INSTR(rest, delim) + LENGTH(delim)) + END AS REST, + delim AS DELIM, + idx AS IDX + FROM _S0 + WHERE + rest <> '' +), _S1 AS ( + SELECT + COUNT(*) - 1 AS TOTAL_PARTS + FROM _S0 +) +SELECT + ( + SELECT + _S0.PART + FROM _S0 _S0 + CROSS JOIN _S1 _S1 + WHERE + _S0.PART_INDEX <> 0 + AND _S0.PART_INDEX = CASE + WHEN _S0.IDX > 0 + THEN _S0.IDX + WHEN _S0.IDX < 0 + THEN _S1.TOTAL_PARTS + _S0.IDX + 1 + ELSE 1 + END + ) AS last_name +FROM MAIN.SBCUSTOMER +WHERE + sbcustname = 'Alex Rodriguez' diff --git a/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..5f50f8fab --- /dev/null +++ b/tests/test_sql_refsols/global_acctbal_breakdown_oracle.sql @@ -0,0 +1,51 @@ +WITH _T0 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY CASE WHEN c_acctbal >= 0 THEN c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN c_acctbal >= 0 THEN c_acctbal ELSE NULL END) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN c_acctbal >= 0 THEN c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_5, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(c_acctbal) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN c_acctbal + ELSE NULL + END AS EXPR_6, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY CASE WHEN c_acctbal < 0 THEN c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN c_acctbal < 0 THEN c_acctbal ELSE NULL END) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN c_acctbal < 0 THEN c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_7 + FROM TPCH.CUSTOMER +) +SELECT + COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS n_red_acctbal, + COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS n_black_acctbal, + AVG(EXPR_7) AS median_red_acctbal, + AVG(EXPR_5) AS median_black_acctbal, + AVG(EXPR_6) AS median_overall_acctbal +FROM _T0 diff --git a/tests/test_sql_refsols/highest_priority_per_year_oracle.sql b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql new file mode 100644 index 000000000..a8dc8028e --- /dev/null +++ b/tests/test_sql_refsols/highest_priority_per_year_oracle.sql @@ -0,0 +1,34 @@ +WITH _T3 AS ( + SELECT + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + o_orderpriority AS O_ORDERPRIORITY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), + o_orderpriority +), _T2 AS ( + SELECT + O_ORDERPRIORITY, + YEAR_O_ORDERDATE, + ( + 100.0 * N_ROWS + ) / SUM(N_ROWS) OVER (PARTITION BY YEAR_O_ORDERDATE) AS PRIORITY_PCT + FROM _T3 +), _T AS ( + SELECT + O_ORDERPRIORITY, + YEAR_O_ORDERDATE, + PRIORITY_PCT, + ROW_NUMBER() OVER (PARTITION BY YEAR_O_ORDERDATE ORDER BY PRIORITY_PCT DESC) AS _W + FROM _T2 +) +SELECT + YEAR_O_ORDERDATE AS order_year, + O_ORDERPRIORITY AS highest_priority, + PRIORITY_PCT AS priority_pct +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/hour_minute_day_oracle.sql b/tests/test_sql_refsols/hour_minute_day_oracle.sql new file mode 100644 index 000000000..f61e48ec1 --- /dev/null +++ b/tests/test_sql_refsols/hour_minute_day_oracle.sql @@ -0,0 +1,13 @@ +SELECT + SBTRANSACTION.sbtxid AS transaction_id, + EXTRACT(HOUR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr0, + EXTRACT(MINUTE FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr1, + EXTRACT(SECOND FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) AS _expr2 +FROM MAIN.SBTRANSACTION SBTRANSACTION +JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + AND SBTICKER.sbtickersymbol IN ('AAPL', 'GOOGL', 'NFLX') +WHERE + EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql new file mode 100644 index 000000000..c66d1c7d0 --- /dev/null +++ b/tests/test_sql_refsols/keywords_alias_reserved_word_oracle.sql @@ -0,0 +1,12 @@ +SELECT + NVL("WHERE".default_to, "WHERE".".CALCULATE") AS calculate2, + CALCULATE.".WHERE" AS _where, + CALCULATE."LIKE" AS _like, + CALCULATE.datetime, + "WHERE".abs, + "WHERE".has +FROM KEYWORDS."WHERE" "WHERE" +JOIN KEYWORDS.CALCULATE CALCULATE + ON "WHERE".".CALCULATE" = CALCULATE.".WHERE" +WHERE + "WHERE".".CALCULATE" = 4 AND "WHERE".present IS NULL diff --git a/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql new file mode 100644 index 000000000..2b4d0af84 --- /dev/null +++ b/tests/test_sql_refsols/keywords_cast_alias_and_missing_alias_oracle.sql @@ -0,0 +1,12 @@ +SELECT + "CAST".id2 AS id1, + "CAST".id AS id2, + "lowercase_detail"."select" AS fk1_select, + "lowercase_detail"."as" AS fk1_as, + lowercase_detail_2."two words" AS fk2_two_words +FROM KEYWORDS."CAST" "CAST" +JOIN KEYWORDS."lowercase_detail" "lowercase_detail" + ON "CAST".id2 = "lowercase_detail".id + AND "lowercase_detail"."0 = 0 and '" = '2 "0 = 0 and ''" field name' +JOIN KEYWORDS."lowercase_detail" lowercase_detail_2 + ON "CAST".id = lowercase_detail_2.id AND lowercase_detail_2.id = 1 diff --git a/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql b/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql new file mode 100644 index 000000000..10b3a0514 --- /dev/null +++ b/tests/test_sql_refsols/keywords_column_alias_reserved_oracle.sql @@ -0,0 +1,14 @@ +SELECT + "MixedCase_1:1"."Id" AS id_, + "MixedCase_1:1"."LowerCaseId" AS LowerCaseID, + "UPPERCASE_MASTER"."INTEGER" AS integer, + "lowercase_detail"."as" AS as_, + "UPPERCASE_MASTER"."ORDER BY" AS order_ +FROM KEYWORDS."MixedCase_1:1" "MixedCase_1:1" +JOIN KEYWORDS."lowercase_detail" "lowercase_detail" + ON "MixedCase_1:1"."LowerCaseId" = "lowercase_detail".id + AND "lowercase_detail"."as" = '10 as reserved word' +JOIN KEYWORDS."UPPERCASE_MASTER" "UPPERCASE_MASTER" + ON "MixedCase_1:1"."Id" = "UPPERCASE_MASTER".id +WHERE + "MixedCase_1:1"."(parentheses)" = '5 (parentheses)' diff --git a/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql new file mode 100644 index 000000000..a0bb869cd --- /dev/null +++ b/tests/test_sql_refsols/keywords_expr_call_quoted_names_oracle.sql @@ -0,0 +1,22 @@ +WITH _S0 AS ( + SELECT + MAX("WHERE") AS MAX_WHERE + FROM KEYWORDS."PARTITION" +), _S1 AS ( + SELECT + AVG("= ""QUOTE""") AS AVG_QUOTE, + COUNT("`cast`") AS COUNT_CAST, + MAX("`name""[") AS MAX_NAME, + MIN("= ""QUOTE""") AS MIN_QUOTE, + SUM("`name""[") AS SUM_NAME + FROM KEYWORDS."""QUOTED TABLE_NAME""" +) +SELECT + _S0.MAX_WHERE AS max_where, + _S1.MIN_QUOTE AS min_quote, + _S1.MAX_NAME AS max_name, + _S1.COUNT_CAST AS count_cast, + _S1.AVG_QUOTE AS quote_avg, + NVL(_S1.SUM_NAME, 0) AS sum_name +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql b/tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql new file mode 100644 index 000000000..961b216cd --- /dev/null +++ b/tests/test_sql_refsols/keywords_locals_globals_eval_oracle.sql @@ -0,0 +1,9 @@ +SELECT + "COUNT".node, + "CAST".types, + 2.0 AS expr +FROM KEYWORDS."COUNT" "COUNT" +JOIN KEYWORDS."CAST" "CAST" + ON "CAST".pk_field_name = "COUNT".this +WHERE + "COUNT".node = 4071 diff --git a/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql new file mode 100644 index 000000000..1e6f25015 --- /dev/null +++ b/tests/test_sql_refsols/keywords_python_sql_reserved_oracle.sql @@ -0,0 +1,12 @@ +SELECT + """," AS dbl_quote_dot, + "." AS dot, + "." + NVL("FLOAT", str, 1) AS addition, + "__col__" AS col, + "__col1__" AS col1, + def AS def_, + del AS __del__, + "__init__" +FROM KEYWORDS."COUNT" +WHERE + "int" = 8051 diff --git a/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql b/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql new file mode 100644 index 000000000..632332320 --- /dev/null +++ b/tests/test_sql_refsols/keywords_quoted_table_name_oracle.sql @@ -0,0 +1,12 @@ +SELECT + """QUOTED TABLE_NAME"""."`cast`" AS cast_, + """QUOTED TABLE_NAME"""."`name""[" AS name, + """QUOTED TABLE_NAME"""."= ""QUOTE""" AS quote_, + "lowercase_detail"."0 = 0 and '" AS _0_0_and, + "lowercase_detail"."as" AS as_ +FROM KEYWORDS."""QUOTED TABLE_NAME""" """QUOTED TABLE_NAME""" +JOIN KEYWORDS."lowercase_detail" "lowercase_detail" + ON """QUOTED TABLE_NAME"""."`name""[" = "lowercase_detail".id +WHERE + """QUOTED TABLE_NAME"""."= ""QUOTE""" = 4 + AND """QUOTED TABLE_NAME"""."`name""[" = 7 diff --git a/tests/test_sql_refsols/keywords_single_quote_use_oracle.sql b/tests/test_sql_refsols/keywords_single_quote_use_oracle.sql new file mode 100644 index 000000000..fe99680de --- /dev/null +++ b/tests/test_sql_refsols/keywords_single_quote_use_oracle.sql @@ -0,0 +1,5 @@ +SELECT + description +FROM KEYWORDS.MASTER +WHERE + description <> 'One-One ''master row' AND id1 = 1 AND id2 = 1 diff --git a/tests/test_sql_refsols/many_net_filter_10_oracle.sql b/tests/test_sql_refsols/many_net_filter_10_oracle.sql new file mode 100644 index 000000000..dcdf211d0 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_10_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey AND NATION_2.n_regionkey = 2 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_11_oracle.sql b/tests/test_sql_refsols/many_net_filter_11_oracle.sql new file mode 100644 index 000000000..dfe91cb98 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_11_oracle.sql @@ -0,0 +1,13 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey AND NATION.n_regionkey < 3 +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey AND NATION_2.n_regionkey > 0 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey + AND NOT CUSTOMER.c_nationkey IN (1, 4, 7, 10, 13, 16, 19, 22) +WHERE + NOT SUPPLIER.s_nationkey IN (0, 3, 6, 9, 12, 15, 18, 21, 24) diff --git a/tests/test_sql_refsols/many_net_filter_1_oracle.sql b/tests/test_sql_refsols/many_net_filter_1_oracle.sql new file mode 100644 index 000000000..4855aa6fc --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_1_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = SUPPLIER.s_nationkey +WHERE + SUPPLIER.s_nationkey = 1 diff --git a/tests/test_sql_refsols/many_net_filter_2_oracle.sql b/tests/test_sql_refsols/many_net_filter_2_oracle.sql new file mode 100644 index 000000000..31d53e2ae --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_2_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = SUPPLIER.s_nationkey +WHERE + SUPPLIER.s_nationkey = 2 diff --git a/tests/test_sql_refsols/many_net_filter_3_oracle.sql b/tests/test_sql_refsols/many_net_filter_3_oracle.sql new file mode 100644 index 000000000..345668635 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_3_oracle.sql @@ -0,0 +1,7 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = 3 + AND CUSTOMER.c_nationkey = SUPPLIER.s_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_4_oracle.sql b/tests/test_sql_refsols/many_net_filter_4_oracle.sql new file mode 100644 index 000000000..4d1be14b4 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_4_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN _S1 _S1 + ON SUPPLIER.s_nationkey = _S1.N_NATIONKEY +JOIN _S1 _S3 + ON _S1.N_REGIONKEY = _S3.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY +WHERE + SUPPLIER.s_nationkey = 4 diff --git a/tests/test_sql_refsols/many_net_filter_5_oracle.sql b/tests/test_sql_refsols/many_net_filter_5_oracle.sql new file mode 100644 index 000000000..dc6644eae --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_5_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = 5 AND NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_6_oracle.sql b/tests/test_sql_refsols/many_net_filter_6_oracle.sql new file mode 100644 index 000000000..9b5320dc4 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_6_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey AND NATION_2.n_nationkey = 6 +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_7_oracle.sql b/tests/test_sql_refsols/many_net_filter_7_oracle.sql new file mode 100644 index 000000000..edf363166 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_7_oracle.sql @@ -0,0 +1,17 @@ +WITH _S1 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN _S1 _S1 + ON SUPPLIER.s_nationkey = _S1.N_NATIONKEY +JOIN _S1 _S3 + ON _S1.N_REGIONKEY = _S3.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = 7 + AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY diff --git a/tests/test_sql_refsols/many_net_filter_8_oracle.sql b/tests/test_sql_refsols/many_net_filter_8_oracle.sql new file mode 100644 index 000000000..71d14b5dd --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_8_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey AND NATION.n_regionkey = 0 +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/many_net_filter_9_oracle.sql b/tests/test_sql_refsols/many_net_filter_9_oracle.sql new file mode 100644 index 000000000..7e6408b59 --- /dev/null +++ b/tests/test_sql_refsols/many_net_filter_9_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COUNT(*) AS n +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey AND NATION.n_regionkey = 1 +JOIN TPCH.NATION NATION_2 + ON NATION.n_regionkey = NATION_2.n_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = SUPPLIER.s_suppkey + AND CUSTOMER.c_nationkey = NATION_2.n_nationkey diff --git a/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql new file mode 100644 index 000000000..b35180fcb --- /dev/null +++ b/tests/test_sql_refsols/month_year_sliding_windows_oracle.sql @@ -0,0 +1,52 @@ +WITH _T7 AS ( + SELECT + o_orderdate AS O_ORDERDATE, + o_orderpriority AS O_ORDERPRIORITY, + o_totalprice AS O_TOTALPRICE + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' +), _T5 AS ( + SELECT + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + SUM(O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM _T7 + GROUP BY + EXTRACT(YEAR FROM CAST(O_ORDERDATE AS DATETIME)) +), _T4 AS ( + SELECT + SUM_O_TOTALPRICE, + YEAR_O_ORDERDATE, + LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE) AS NEXT_YEAR_TOTAL_SPENT + FROM _T5 +), _T2 AS ( + SELECT + EXTRACT(MONTH FROM CAST(_T8.O_ORDERDATE AS DATETIME)) AS MONTH_O_ORDERDATE, + EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) AS YEAR_O_ORDERDATE, + SUM(_T8.O_TOTALPRICE) AS SUM_O_TOTALPRICE + FROM _T4 _T4 + JOIN _T7 _T8 + ON _T4.YEAR_O_ORDERDATE = EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) + WHERE + _T4.NEXT_YEAR_TOTAL_SPENT < NVL(_T4.SUM_O_TOTALPRICE, 0) + GROUP BY + EXTRACT(MONTH FROM CAST(_T8.O_ORDERDATE AS DATETIME)), + EXTRACT(YEAR FROM CAST(_T8.O_ORDERDATE AS DATETIME)) +), _T AS ( + SELECT + MONTH_O_ORDERDATE, + YEAR_O_ORDERDATE, + SUM_O_TOTALPRICE, + LEAD(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS _W, + LAG(NVL(SUM_O_TOTALPRICE, 0), 1, 0.0) OVER (ORDER BY YEAR_O_ORDERDATE, MONTH_O_ORDERDATE) AS _W_2 + FROM _T2 +) +SELECT + YEAR_O_ORDERDATE AS year, + MONTH_O_ORDERDATE AS month +FROM _T +WHERE + _W < NVL(SUM_O_TOTALPRICE, 0) AND _W_2 < NVL(SUM_O_TOTALPRICE, 0) +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/n_orders_first_day_oracle.sql b/tests/test_sql_refsols/n_orders_first_day_oracle.sql new file mode 100644 index 000000000..9c364559c --- /dev/null +++ b/tests/test_sql_refsols/n_orders_first_day_oracle.sql @@ -0,0 +1,10 @@ +WITH _T AS ( + SELECT + RANK() OVER (ORDER BY o_orderdate) AS _W + FROM TPCH.ORDERS +) +SELECT + COUNT(*) AS n_orders +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..ef73f8bb2 --- /dev/null +++ b/tests/test_sql_refsols/nation_acctbal_breakdown_oracle.sql @@ -0,0 +1,62 @@ +WITH _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_nationkey AS C_NATIONKEY, + NATION.n_name AS N_NAME, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_5, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_6, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY CUSTOMER.c_nationkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_7 + FROM TPCH.NATION NATION + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AMERICA' + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + ANY_VALUE(N_NAME) AS nation_name, + COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS n_red_acctbal, + COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS n_black_acctbal, + AVG(EXPR_7) AS median_red_acctbal, + AVG(EXPR_5) AS median_black_acctbal, + AVG(EXPR_6) AS median_overall_acctbal +FROM _T1 +GROUP BY + C_NATIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/nation_best_order_oracle.sql b/tests/test_sql_refsols/nation_best_order_oracle.sql new file mode 100644 index 000000000..94b746662 --- /dev/null +++ b/tests/test_sql_refsols/nation_best_order_oracle.sql @@ -0,0 +1,36 @@ +WITH _T3 AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ORDERS.o_totalprice AS O_TOTALPRICE, + ( + 100.0 * ORDERS.o_totalprice + ) / SUM(ORDERS.o_totalprice) OVER (PARTITION BY CUSTOMER.c_nationkey) AS VALUE_PERCENTAGE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T AS ( + SELECT + C_NAME, + C_NATIONKEY, + O_ORDERKEY, + O_TOTALPRICE, + VALUE_PERCENTAGE, + ROW_NUMBER() OVER (PARTITION BY C_NATIONKEY ORDER BY O_TOTALPRICE DESC) AS _W + FROM _T3 +) +SELECT + NATION.n_name AS nation_name, + _T.C_NAME AS customer_name, + _T.O_ORDERKEY AS order_key, + _T.O_TOTALPRICE AS order_value, + _T.VALUE_PERCENTAGE AS value_percentage +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' +JOIN _T _T + ON NATION.n_nationkey = _T.C_NATIONKEY AND _T._W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/numerical_functions_oracle.sql b/tests/test_sql_refsols/numerical_functions_oracle.sql new file mode 100644 index 000000000..beb2c6395 --- /dev/null +++ b/tests/test_sql_refsols/numerical_functions_oracle.sql @@ -0,0 +1,11 @@ +SELECT + ABS(c_acctbal) AS abs_value, + ROUND(c_acctbal, 2) AS round_value, + CEIL(c_acctbal) AS ceil_value, + FLOOR(c_acctbal) AS floor_value, + POWER(c_acctbal, 2) AS power_value, + POWER(c_acctbal, 0.5) AS sqrt_value, + CASE WHEN c_acctbal = 0 THEN 0 ELSE CASE WHEN c_acctbal < 0 THEN -1 ELSE 1 END END AS sign_value, + LEAST(c_acctbal, 0) AS smallest_value, + GREATEST(c_acctbal, 0) AS largest_value +FROM TPCH.CUSTOMER diff --git a/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql new file mode 100644 index 000000000..32fab572f --- /dev/null +++ b/tests/test_sql_refsols/odate_and_rdate_avggap_oracle.sql @@ -0,0 +1,13 @@ +SELECT + AVG( + DATEDIFF( + CAST(LEAST(LINEITEM.l_commitdate, LINEITEM.l_receiptdate) AS DATETIME), + CAST(ORDERS.o_orderdate AS DATETIME), + DAY + ) + ) AS avg_gap +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.ORDERS ORDERS + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +WHERE + LINEITEM.l_shipmode = 'RAIL' diff --git a/tests/test_sql_refsols/order_info_per_priority_oracle.sql b/tests/test_sql_refsols/order_info_per_priority_oracle.sql new file mode 100644 index 000000000..4824c7fde --- /dev/null +++ b/tests/test_sql_refsols/order_info_per_priority_oracle.sql @@ -0,0 +1,19 @@ +WITH _T AS ( + SELECT + o_orderkey AS O_ORDERKEY, + o_orderpriority AS O_ORDERPRIORITY, + o_totalprice AS O_TOTALPRICE, + ROW_NUMBER() OVER (PARTITION BY o_orderpriority ORDER BY o_totalprice DESC) AS _W + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +) +SELECT + O_ORDERPRIORITY AS order_priority, + O_ORDERKEY AS order_key, + O_TOTALPRICE AS order_total_price +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/order_quarter_test_oracle.sql b/tests/test_sql_refsols/order_quarter_test_oracle.sql new file mode 100644 index 000000000..3276ffee3 --- /dev/null +++ b/tests/test_sql_refsols/order_quarter_test_oracle.sql @@ -0,0 +1,18 @@ +SELECT + o_orderdate AS order_date, + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATETIME)) AS quarter, + TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER') AS quarter_start, + DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 1, 'QUARTER') AS next_quarter, + DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 1, QUARTER) AS prev_quarter, + DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 2, 'QUARTER') AS two_quarters_ahead, + DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 2, QUARTER) AS two_quarters_behind, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1995-01-01' AS TIMESTAMP), QUARTER) AS quarters_since_1995, + DATEDIFF(CAST('2000-01-01' AS TIMESTAMP), CAST(o_orderdate AS DATETIME), QUARTER) AS quarters_until_2000, + DATE_SUB(CAST(o_orderdate AS TIMESTAMP), 4, QUARTER) AS same_quarter_prev_year, + DATE_ADD(CAST(o_orderdate AS TIMESTAMP), 4, 'QUARTER') AS same_quarter_next_year +FROM TPCH.ORDERS +WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1995 +ORDER BY + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql new file mode 100644 index 000000000..a76fa5d8e --- /dev/null +++ b/tests/test_sql_refsols/orders_versus_first_orders_oracle.sql @@ -0,0 +1,37 @@ +WITH _S4 AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + o_orderkey AS O_ORDERKEY + FROM TPCH.ORDERS +), _T AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + CUSTOMER.c_name AS C_NAME, + _S3.O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY _S3.O_CUSTKEY ORDER BY _S3.O_ORDERDATE, _S3.O_ORDERKEY) AS _W + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'VIETNAM' + JOIN _S4 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY +), _S5 AS ( + SELECT + C_CUSTKEY, + C_NAME, + O_ORDERDATE + FROM _T + WHERE + _W = 1 +) +SELECT + _S5.C_NAME AS customer_name, + _S4.O_ORDERKEY AS order_key, + DATEDIFF(CAST(_S4.O_ORDERDATE AS DATETIME), CAST(_S5.O_ORDERDATE AS DATETIME), DAY) AS days_since_first_order +FROM _S4 _S4 +LEFT JOIN _S5 _S5 + ON _S4.O_CUSTKEY = _S5.C_CUSTKEY +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/part_cross_part_a_oracle.sql b/tests/test_sql_refsols/part_cross_part_a_oracle.sql new file mode 100644 index 000000000..cb017e43d --- /dev/null +++ b/tests/test_sql_refsols/part_cross_part_a_oracle.sql @@ -0,0 +1,35 @@ +WITH _S0 AS ( + SELECT DISTINCT + sbtickerexchange AS SBTICKEREXCHANGE + FROM MAIN.SBTICKER +), _S9 AS ( + SELECT + SBCUSTOMER.sbcustid AS SBCUSTID, + _S2.SBTICKEREXCHANGE, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + JOIN MAIN.SBTICKER SBTICKER + ON SBTICKER.sbtickerexchange = _S2.SBTICKEREXCHANGE + AND SBTICKER.sbtickerid = SBTRANSACTION.sbtxtickerid + GROUP BY + SBCUSTOMER.sbcustid, + _S2.SBTICKEREXCHANGE +) +SELECT + SBCUSTOMER.sbcuststate AS state, + _S0.SBTICKEREXCHANGE AS exchange, + NVL(SUM(_S9.N_ROWS), 0) AS n +FROM _S0 _S0 +CROSS JOIN MAIN.SBCUSTOMER SBCUSTOMER +LEFT JOIN _S9 _S9 + ON SBCUSTOMER.sbcustid = _S9.SBCUSTID + AND _S0.SBTICKEREXCHANGE = _S9.SBTICKEREXCHANGE +GROUP BY + SBCUSTOMER.sbcuststate, + _S0.SBTICKEREXCHANGE +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_b_oracle.sql b/tests/test_sql_refsols/part_cross_part_b_oracle.sql new file mode 100644 index 000000000..aff0ebb50 --- /dev/null +++ b/tests/test_sql_refsols/part_cross_part_b_oracle.sql @@ -0,0 +1,46 @@ +WITH _S0 AS ( + SELECT DISTINCT + sbcuststate AS SBCUSTSTATE + FROM MAIN.SBCUSTOMER +), _T2 AS ( + SELECT + sbtxdatetime AS SBTXDATETIME + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +), _S1 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S3 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S9 AS ( + SELECT + _S3.MONTH, + _S2.SBCUSTSTATE, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + CROSS JOIN _S3 _S3 + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + AND _S3.MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + AND SBCUSTOMER.sbcuststate = _S2.SBCUSTSTATE + GROUP BY + _S3.MONTH, + _S2.SBCUSTSTATE +) +SELECT + _S0.SBCUSTSTATE AS state, + _S1.MONTH AS month_of_year, + SUM(NVL(_S9.N_ROWS, 0)) OVER (PARTITION BY _S0.SBCUSTSTATE ORDER BY _S1.MONTH ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS n +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +LEFT JOIN _S9 _S9 + ON _S0.SBCUSTSTATE = _S9.SBCUSTSTATE AND _S1.MONTH = _S9.MONTH +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/part_cross_part_c_oracle.sql b/tests/test_sql_refsols/part_cross_part_c_oracle.sql new file mode 100644 index 000000000..44e2df7f9 --- /dev/null +++ b/tests/test_sql_refsols/part_cross_part_c_oracle.sql @@ -0,0 +1,44 @@ +WITH _S0 AS ( + SELECT DISTINCT + sbcuststate AS SBCUSTSTATE + FROM MAIN.SBCUSTOMER +), _T2 AS ( + SELECT + sbtxdatetime AS SBTXDATETIME + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +), _S1 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S3 AS ( + SELECT DISTINCT + TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'MONTH') AS MONTH + FROM _T2 +), _S9 AS ( + SELECT + _S3.MONTH, + _S2.SBCUSTSTATE, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + CROSS JOIN _S3 _S3 + JOIN MAIN.SBTRANSACTION SBTRANSACTION + ON EXTRACT(YEAR FROM CAST(SBTRANSACTION.sbtxdatetime AS DATETIME)) = 2023 + AND _S3.MONTH = TRUNC(CAST(SBTRANSACTION.sbtxdatetime AS TIMESTAMP), 'MONTH') + JOIN MAIN.SBCUSTOMER SBCUSTOMER + ON SBCUSTOMER.sbcustid = SBTRANSACTION.sbtxcustid + AND SBCUSTOMER.sbcuststate = _S2.SBCUSTSTATE + GROUP BY + _S3.MONTH, + _S2.SBCUSTSTATE +) +SELECT + _S0.SBCUSTSTATE AS state, + MAX(NVL(_S9.N_ROWS, 0)) AS max_n +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +LEFT JOIN _S9 _S9 + ON _S0.SBCUSTSTATE = _S9.SBCUSTSTATE AND _S1.MONTH = _S9.MONTH +GROUP BY + _S0.SBCUSTSTATE diff --git a/tests/test_sql_refsols/part_reduced_size_oracle.sql b/tests/test_sql_refsols/part_reduced_size_oracle.sql new file mode 100644 index 000000000..a8675c6dd --- /dev/null +++ b/tests/test_sql_refsols/part_reduced_size_oracle.sql @@ -0,0 +1,25 @@ +WITH _S0 AS ( + SELECT + p_partkey AS P_PARTKEY, + p_retailprice AS P_RETAILPRICE, + p_size AS P_SIZE + FROM TPCH.PART + ORDER BY + CAST(p_retailprice AS INT) NULLS FIRST + FETCH FIRST 2 ROWS ONLY +) +SELECT + CAST(_S0.P_SIZE / 2.5 AS DOUBLE PRECISION) AS reduced_size, + CAST(_S0.P_RETAILPRICE AS INT) AS retail_price_int, + LISTAGG('', 'old size: ', CAST(_S0.P_SIZE AS CLOB)) AS message, + LINEITEM.l_discount AS discount, + TO_CHAR(LINEITEM.l_receiptdate, 'DD-MM-YYYY') AS date_dmy, + TO_CHAR(LINEITEM.l_receiptdate, 'MM/DD') AS date_md, + TO_CHAR(LINEITEM.l_receiptdate, 'HH24:MIP.M.') AS am_pm +FROM _S0 _S0 +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = _S0.P_PARTKEY +ORDER BY + 4 DESC NULLS LAST, + 5 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql new file mode 100644 index 000000000..58ed7cd20 --- /dev/null +++ b/tests/test_sql_refsols/parts_quantity_increase_95_96_oracle.sql @@ -0,0 +1,41 @@ +WITH _T4 AS ( + SELECT + l_orderkey AS L_ORDERKEY, + l_partkey AS L_PARTKEY, + l_quantity AS L_QUANTITY, + l_shipmode AS L_SHIPMODE + FROM TPCH.LINEITEM + WHERE + l_shipmode = 'RAIL' +), _S6 AS ( + SELECT + _T4.L_PARTKEY, + ANY_VALUE(PART.p_name) AS ANYTHING_P_NAME, + SUM(_T4.L_QUANTITY) AS SUM_L_QUANTITY + FROM TPCH.PART PART + JOIN _T4 _T4 + ON PART.p_partkey = _T4.L_PARTKEY + JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 + AND ORDERS.o_orderkey = _T4.L_ORDERKEY + WHERE + PART.p_container LIKE 'SM%' + GROUP BY + _T4.L_PARTKEY +) +SELECT + ANY_VALUE(_S6.ANYTHING_P_NAME) AS name, + NVL(ANY_VALUE(_S6.SUM_L_QUANTITY), 0) AS qty_95, + NVL(SUM(_T6.L_QUANTITY), 0) AS qty_96 +FROM _S6 _S6 +JOIN _T4 _T6 + ON _S6.L_PARTKEY = _T6.L_PARTKEY +JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1996 + AND ORDERS.o_orderkey = _T6.L_ORDERKEY +GROUP BY + _T6.L_PARTKEY +ORDER BY + NVL(SUM(_T6.L_QUANTITY), 0) - NVL(ANY_VALUE(_S6.SUM_L_QUANTITY), 0) DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql new file mode 100644 index 000000000..2e021f3ea --- /dev/null +++ b/tests/test_sql_refsols/percentile_customers_per_region_oracle.sql @@ -0,0 +1,16 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_name AS C_NAME, + CUSTOMER.c_phone AS C_PHONE, + NTILE(100) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + C_NAME AS name +FROM _T +WHERE + C_PHONE LIKE '%00' AND _W = 95 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/percentile_nations_oracle.sql b/tests/test_sql_refsols/percentile_nations_oracle.sql new file mode 100644 index 000000000..02fa060e6 --- /dev/null +++ b/tests/test_sql_refsols/percentile_nations_oracle.sql @@ -0,0 +1,5 @@ +SELECT + n_name AS name, + NTILE(5) OVER (ORDER BY n_name) AS p1, + NTILE(5) OVER (ORDER BY n_name) AS p2 +FROM TPCH.NATION diff --git a/tests/test_sql_refsols/prev_next_regions_oracle.sql b/tests/test_sql_refsols/prev_next_regions_oracle.sql new file mode 100644 index 000000000..95d25b1a2 --- /dev/null +++ b/tests/test_sql_refsols/prev_next_regions_oracle.sql @@ -0,0 +1,9 @@ +SELECT + LAG(r_name, 2) OVER (ORDER BY r_name) AS two_preceding, + LAG(r_name, 1) OVER (ORDER BY r_name) AS one_preceding, + r_name AS current_region, + LEAD(r_name, 1) OVER (ORDER BY r_name) AS one_following, + LEAD(r_name, 2) OVER (ORDER BY r_name) AS two_following +FROM TPCH.REGION +ORDER BY + 3 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_1_oracle.sql b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql new file mode 100644 index 000000000..e44b1431c --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_1_oracle.sql @@ -0,0 +1,14 @@ +WITH _T0 AS ( + SELECT + CASE + WHEN FLOOR(0.3 * COUNT(o_totalprice) OVER ()) < ROW_NUMBER() OVER (ORDER BY o_totalprice DESC NULLS LAST) + THEN o_totalprice + ELSE NULL + END AS EXPR_1 + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 +) +SELECT + MAX(EXPR_1) AS seventieth_order_price +FROM _T0 diff --git a/tests/test_sql_refsols/quantile_function_test_2_oracle.sql b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql new file mode 100644 index 000000000..3c129aed5 --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_2_oracle.sql @@ -0,0 +1,81 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_3_oracle.sql b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql new file mode 100644 index 000000000..3c129aed5 --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_3_oracle.sql @@ -0,0 +1,81 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_function_test_4_oracle.sql b/tests/test_sql_refsols/quantile_function_test_4_oracle.sql new file mode 100644 index 000000000..1e74b3980 --- /dev/null +++ b/tests/test_sql_refsols/quantile_function_test_4_oracle.sql @@ -0,0 +1,80 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000272' +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quantile_test_1_oracle.sql b/tests/test_sql_refsols/quantile_test_1_oracle.sql new file mode 100644 index 000000000..e44b1431c --- /dev/null +++ b/tests/test_sql_refsols/quantile_test_1_oracle.sql @@ -0,0 +1,14 @@ +WITH _T0 AS ( + SELECT + CASE + WHEN FLOOR(0.3 * COUNT(o_totalprice) OVER ()) < ROW_NUMBER() OVER (ORDER BY o_totalprice DESC NULLS LAST) + THEN o_totalprice + ELSE NULL + END AS EXPR_1 + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 +) +SELECT + MAX(EXPR_1) AS seventieth_order_price +FROM _T0 diff --git a/tests/test_sql_refsols/quantile_test_2_oracle.sql b/tests/test_sql_refsols/quantile_test_2_oracle.sql new file mode 100644 index 000000000..3c129aed5 --- /dev/null +++ b/tests/test_sql_refsols/quantile_test_2_oracle.sql @@ -0,0 +1,81 @@ +WITH _S0 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + ORDER BY + 1 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _S5 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_totalprice AS O_TOTALPRICE + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 +), _T1 AS ( + SELECT + _S0.N_NAME, + _S0.N_NATIONKEY, + _S5.O_TOTALPRICE, + REGION.r_name AS R_NAME, + CASE + WHEN FLOOR(0.99 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_10, + CASE + WHEN FLOOR(0.75 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_11, + CASE + WHEN FLOOR(0.25 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_12, + CASE + WHEN FLOOR(0.1 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_13, + CASE + WHEN FLOOR(0.01 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_14, + CASE + WHEN FLOOR(0.5 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_15, + CASE + WHEN FLOOR(0.9 * COUNT(_S5.O_TOTALPRICE) OVER (PARTITION BY _S5.C_NATIONKEY)) < ROW_NUMBER() OVER (PARTITION BY _S5.C_NATIONKEY ORDER BY _S5.O_TOTALPRICE DESC NULLS LAST) + THEN _S5.O_TOTALPRICE + ELSE NULL + END AS EXPR_9 + FROM _S0 _S0 + JOIN TPCH.REGION REGION + ON REGION.r_regionkey = _S0.N_REGIONKEY + LEFT JOIN _S5 _S5 + ON _S0.N_NATIONKEY = _S5.C_NATIONKEY +) +SELECT + ANY_VALUE(R_NAME) AS region_name, + ANY_VALUE(N_NAME) AS nation_name, + MIN(O_TOTALPRICE) AS orders_min, + MAX(EXPR_10) AS orders_1_percent, + MAX(EXPR_9) AS orders_10_percent, + MAX(EXPR_11) AS orders_25_percent, + MAX(EXPR_15) AS orders_median, + MAX(EXPR_12) AS orders_75_percent, + MAX(EXPR_13) AS orders_90_percent, + MAX(EXPR_14) AS orders_99_percent, + MAX(O_TOTALPRICE) AS orders_max +FROM _T1 +GROUP BY + N_NATIONKEY +ORDER BY + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql new file mode 100644 index 000000000..6ffb981b0 --- /dev/null +++ b/tests/test_sql_refsols/quarter_cum_ir_analysis_oracle.sql @@ -0,0 +1,83 @@ +WITH _T2 AS ( + SELECT + pr_name AS PR_NAME, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'RubyCopper-Star' +), _S1 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _S7 AS ( + SELECT + _S3.CA_DT, + COUNT(*) AS N_ROWS + FROM _T2 _T4 + JOIN _S1 _S3 + ON _S3.CA_DT < TRUNC(DATE_ADD(CAST(_T4.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S3.CA_DT >= _T4.PR_RELEASE + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_product_id = 800544 + AND _S3.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + GROUP BY + _S3.CA_DT +), _S22 AS ( + SELECT + TRUNC(CAST(_S1.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER, + SUM(_S7.N_ROWS) AS SUM_N_ROWS + FROM _T2 _T2 + JOIN _S1 _S1 + ON _S1.CA_DT < TRUNC(DATE_ADD(CAST(_T2.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S1.CA_DT >= _T2.PR_RELEASE + LEFT JOIN _S7 _S7 + ON _S1.CA_DT = _S7.CA_DT + GROUP BY + TRUNC(CAST(_S1.CA_DT AS TIMESTAMP), 'QUARTER') +), _S13 AS ( + SELECT DISTINCT + TRUNC(CAST(_S11.CA_DT AS TIMESTAMP), 'QUARTER') AS QUARTER + FROM _T2 _T10 + JOIN _S1 _S11 + ON _S11.CA_DT < TRUNC(DATE_ADD(CAST(_T10.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S11.CA_DT >= _T10.PR_RELEASE +), _S17 AS ( + SELECT + _S15.CA_DT + FROM _T2 _T11 + JOIN _S1 _S15 + ON _S15.CA_DT < TRUNC(DATE_ADD(CAST(_T11.PR_RELEASE AS TIMESTAMP), 2, 'YEAR'), 'QUARTER') + AND _S15.CA_DT >= _T11.PR_RELEASE +), _S23 AS ( + SELECT + _S13.QUARTER, + COUNT(DISTINCT INCIDENTS.in_device_id) AS NDISTINCT_IN_DEVICE_ID + FROM MAIN.PRODUCTS PRODUCTS + JOIN MAIN.COUNTRIES COUNTRIES + ON COUNTRIES.co_name = 'CN' + CROSS JOIN _S13 _S13 + JOIN _S17 _S17 + ON _S13.QUARTER = TRUNC(CAST(_S17.CA_DT AS TIMESTAMP), 'QUARTER') + JOIN MAIN.INCIDENTS INCIDENTS + ON COUNTRIES.co_id = INCIDENTS.in_repair_country_id + AND _S17.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id AND DEVICES.de_product_id = 800544 + WHERE + PRODUCTS.pr_name = 'RubyCopper-Star' + GROUP BY + _S13.QUARTER +) +SELECT + _S22.QUARTER AS quarter, + NVL(_S23.NDISTINCT_IN_DEVICE_ID, 0) AS n_incidents, + NVL(_S22.SUM_N_ROWS, 0) AS n_sold, + ROUND( + SUM(NVL(_S23.NDISTINCT_IN_DEVICE_ID, 0)) OVER (ORDER BY _S22.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S22.SUM_N_ROWS, 0)) OVER (ORDER BY _S22.QUARTER ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS quarter_cum +FROM _S22 _S22 +LEFT JOIN _S23 _S23 + ON _S22.QUARTER = _S23.QUARTER +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/quarter_function_test_oracle.sql b/tests/test_sql_refsols/quarter_function_test_oracle.sql new file mode 100644 index 000000000..09ae15616 --- /dev/null +++ b/tests/test_sql_refsols/quarter_function_test_oracle.sql @@ -0,0 +1,58 @@ +SELECT + 1 AS _expr0, + 1 AS _expr1, + 1 AS _expr2, + 2 AS _expr3, + 2 AS _expr4, + 2 AS _expr5, + 3 AS _expr6, + 3 AS _expr7, + 3 AS _expr8, + 4 AS _expr9, + 4 AS _expr10, + 4 AS _expr11, + 1 AS _expr12, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_jan, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_feb, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS q1_mar, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS q2_apr, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS q2_may, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS q2_jun, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS q3_jul, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS q3_aug, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS q3_sep, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS q4_oct, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS q4_nov, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS q4_dec, + TO_DATE('2024-01-01', 'YYYY-MM-DD') AS ts_q1, + TO_DATE('2023-04-01', 'YYYY-MM-DD') AS alias1, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS alias2, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS alias3, + TO_DATE('2023-01-01', 'YYYY-MM-DD') AS alias4, + TIME_STR_TO_TIME('2023-04-02 02:00:00') AS chain1, + TO_DATE('2023-07-01', 'YYYY-MM-DD') AS chain2, + TO_DATE('2023-10-01', 'YYYY-MM-DD') AS chain3, + TIME_STR_TO_TIME('2023-04-15 12:30:45') AS plus_1q, + TIME_STR_TO_TIME('2023-07-15 12:30:45') AS plus_2q, + TO_DATE('2023-10-15', 'YYYY-MM-DD') AS plus_3q, + TIME_STR_TO_TIME('2022-10-15 12:30:45') AS minus_1q, + TIME_STR_TO_TIME('2022-07-15 12:30:45') AS minus_2q, + TO_DATE('2022-04-15', 'YYYY-MM-DD') AS minus_3q, + TO_DATE('2023-08-15', 'YYYY-MM-DD') AS syntax1, + TO_DATE('2024-02-15', 'YYYY-MM-DD') AS syntax2, + TO_DATE('2024-08-15', 'YYYY-MM-DD') AS syntax3, + TO_DATE('2022-08-15', 'YYYY-MM-DD') AS syntax4, + DATEDIFF(CAST('2023-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff1, + DATEDIFF(CAST('2023-07-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff2, + DATEDIFF(CAST('2023-10-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff3, + DATEDIFF(CAST('2023-12-31' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff4, + DATEDIFF(CAST('2024-01-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff5, + DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2023-01-15' AS TIMESTAMP), QUARTER) AS q_diff6, + DATEDIFF(CAST('2024-04-15' AS TIMESTAMP), CAST('2022-10-15' AS TIMESTAMP), QUARTER) AS q_diff7, + DATEDIFF(CAST('2025-01-01' AS TIMESTAMP), CAST('2020-01-01' AS TIMESTAMP), QUARTER) AS q_diff8, + DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2023-04-15' AS TIMESTAMP), QUARTER) AS q_diff9, + DATEDIFF(CAST('2023-01-15' AS TIMESTAMP), CAST('2024-01-15' AS TIMESTAMP), QUARTER) AS q_diff10, + DATEDIFF(CAST('2023-04-01' AS TIMESTAMP), CAST('2023-03-31' AS TIMESTAMP), QUARTER) AS q_diff11, + DATEDIFF(CAST('2024-01-01' AS TIMESTAMP), CAST('2023-12-31' AS TIMESTAMP), QUARTER) AS q_diff12 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/rank_a_oracle.sql b/tests/test_sql_refsols/rank_a_oracle.sql new file mode 100644 index 000000000..9a7f14d7c --- /dev/null +++ b/tests/test_sql_refsols/rank_a_oracle.sql @@ -0,0 +1,4 @@ +SELECT + c_custkey AS id, + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC) AS rk +FROM TPCH.CUSTOMER diff --git a/tests/test_sql_refsols/rank_b_oracle.sql b/tests/test_sql_refsols/rank_b_oracle.sql new file mode 100644 index 000000000..b323162a0 --- /dev/null +++ b/tests/test_sql_refsols/rank_b_oracle.sql @@ -0,0 +1,4 @@ +SELECT + o_orderkey AS order_key, + RANK() OVER (ORDER BY o_orderpriority) AS rank +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/rank_c_oracle.sql b/tests/test_sql_refsols/rank_c_oracle.sql new file mode 100644 index 000000000..8b019c54b --- /dev/null +++ b/tests/test_sql_refsols/rank_c_oracle.sql @@ -0,0 +1,4 @@ +SELECT + o_orderdate AS order_date, + DENSE_RANK() OVER (ORDER BY o_orderdate) AS rank +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/rank_nations_by_region_oracle.sql b/tests/test_sql_refsols/rank_nations_by_region_oracle.sql new file mode 100644 index 000000000..216c55810 --- /dev/null +++ b/tests/test_sql_refsols/rank_nations_by_region_oracle.sql @@ -0,0 +1,6 @@ +SELECT + NATION.n_name AS name, + RANK() OVER (ORDER BY REGION.r_name) AS rank +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey diff --git a/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql new file mode 100644 index 000000000..fcfa12355 --- /dev/null +++ b/tests/test_sql_refsols/rank_nations_per_region_by_customers_oracle.sql @@ -0,0 +1,19 @@ +WITH _S1 AS ( + SELECT + c_nationkey AS C_NATIONKEY, + COUNT(*) AS N_ROWS + FROM TPCH.CUSTOMER + GROUP BY + c_nationkey +) +SELECT + NATION.n_name AS nation_name, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY _S1.N_ROWS DESC, REGION.r_name) AS rank +FROM TPCH.NATION NATION +JOIN _S1 _S1 + ON NATION.n_nationkey = _S1.C_NATIONKEY +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey +ORDER BY + 2 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql b/tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql new file mode 100644 index 000000000..4ccacb14e --- /dev/null +++ b/tests/test_sql_refsols/rank_parts_per_supplier_region_by_size_oracle.sql @@ -0,0 +1,17 @@ +SELECT + PART.p_partkey AS key, + REGION.r_name AS region, + DENSE_RANK() OVER (PARTITION BY NATION.n_regionkey ORDER BY PART.p_size DESC, PART.p_container DESC, PART.p_type DESC) AS rank +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.PARTSUPP PARTSUPP + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.PART PART + ON PART.p_partkey = PARTSUPP.ps_partkey +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST +FETCH FIRST 15 ROWS ONLY diff --git a/tests/test_sql_refsols/rank_with_filters_a_oracle.sql b/tests/test_sql_refsols/rank_with_filters_a_oracle.sql new file mode 100644 index 000000000..1fbbd4d7d --- /dev/null +++ b/tests/test_sql_refsols/rank_with_filters_a_oracle.sql @@ -0,0 +1,12 @@ +WITH _T0 AS ( + SELECT + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC, c_name) AS R, + c_name AS C_NAME + FROM TPCH.CUSTOMER +) +SELECT + C_NAME AS n, + R AS r +FROM _T0 +WHERE + C_NAME LIKE '%0' AND R <= 30 diff --git a/tests/test_sql_refsols/rank_with_filters_b_oracle.sql b/tests/test_sql_refsols/rank_with_filters_b_oracle.sql new file mode 100644 index 000000000..1fbbd4d7d --- /dev/null +++ b/tests/test_sql_refsols/rank_with_filters_b_oracle.sql @@ -0,0 +1,12 @@ +WITH _T0 AS ( + SELECT + ROW_NUMBER() OVER (ORDER BY c_acctbal DESC, c_name) AS R, + c_name AS C_NAME + FROM TPCH.CUSTOMER +) +SELECT + C_NAME AS n, + R AS r +FROM _T0 +WHERE + C_NAME LIKE '%0' AND R <= 30 diff --git a/tests/test_sql_refsols/rank_with_filters_c_oracle.sql b/tests/test_sql_refsols/rank_with_filters_c_oracle.sql new file mode 100644 index 000000000..d113d63e3 --- /dev/null +++ b/tests/test_sql_refsols/rank_with_filters_c_oracle.sql @@ -0,0 +1,22 @@ +WITH _S0 AS ( + SELECT DISTINCT + p_size AS P_SIZE + FROM TPCH.PART + ORDER BY + 1 DESC NULLS LAST + FETCH FIRST 5 ROWS ONLY +), _T AS ( + SELECT + PART.p_size AS SIZE_1, + PART.p_name AS P_NAME, + ROW_NUMBER() OVER (PARTITION BY _S0.P_SIZE ORDER BY PART.p_retailprice DESC, PART.p_partkey) AS _W + FROM _S0 _S0 + JOIN TPCH.PART PART + ON PART.p_size = _S0.P_SIZE +) +SELECT + P_NAME AS pname, + SIZE_1 AS psize +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql new file mode 100644 index 000000000..e91ee8eb7 --- /dev/null +++ b/tests/test_sql_refsols/region_acctbal_breakdown_oracle.sql @@ -0,0 +1,70 @@ +WITH _T1 AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + NATION.n_regionkey AS N_REGIONKEY, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY NATION.n_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal >= 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_5, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CUSTOMER.c_acctbal) OVER (PARTITION BY NATION.n_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CUSTOMER.c_acctbal + ELSE NULL + END AS EXPR_6, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER (PARTITION BY NATION.n_regionkey) - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN CASE WHEN CUSTOMER.c_acctbal < 0 THEN CUSTOMER.c_acctbal ELSE NULL END + ELSE NULL + END AS EXPR_7 + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +), _S3 AS ( + SELECT + N_REGIONKEY, + AVG(EXPR_5) AS AVG_EXPR_5, + AVG(EXPR_6) AS AVG_EXPR_6, + AVG(EXPR_7) AS AVG_EXPR_7, + COUNT(CASE WHEN C_ACCTBAL < 0 THEN C_ACCTBAL ELSE NULL END) AS COUNT_NEGATIVE_ACCTBAL, + COUNT(CASE WHEN C_ACCTBAL >= 0 THEN C_ACCTBAL ELSE NULL END) AS COUNT_NON_NEGATIVE_ACCTBAL + FROM _T1 + GROUP BY + N_REGIONKEY +) +SELECT + REGION.r_name AS region_name, + _S3.COUNT_NEGATIVE_ACCTBAL AS n_red_acctbal, + _S3.COUNT_NON_NEGATIVE_ACCTBAL AS n_black_acctbal, + _S3.AVG_EXPR_7 AS median_red_acctbal, + _S3.AVG_EXPR_5 AS median_black_acctbal, + _S3.AVG_EXPR_6 AS median_overall_acctbal +FROM TPCH.REGION REGION +JOIN _S3 _S3 + ON REGION.r_regionkey = _S3.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql new file mode 100644 index 000000000..9474cda47 --- /dev/null +++ b/tests/test_sql_refsols/region_orders_from_nations_richest_oracle.sql @@ -0,0 +1,35 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + NATION.n_regionkey AS N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +), _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +), _S5 AS ( + SELECT + _T.N_REGIONKEY, + SUM(_S3.N_ROWS) AS SUM_N_ROWS + FROM _T _T + JOIN _S3 _S3 + ON _S3.O_CUSTKEY = _T.C_CUSTKEY + WHERE + _T._W = 1 + GROUP BY + _T.N_REGIONKEY +) +SELECT + REGION.r_name AS region_name, + NVL(_S5.SUM_N_ROWS, 0) AS n_orders +FROM TPCH.REGION REGION +LEFT JOIN _S5 _S5 + ON REGION.r_regionkey = _S5.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql new file mode 100644 index 000000000..d00707e28 --- /dev/null +++ b/tests/test_sql_refsols/regional_first_order_best_line_part_oracle.sql @@ -0,0 +1,40 @@ +WITH _T AS ( + SELECT + NATION.n_regionkey AS N_REGIONKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY ORDERS.o_orderdate, ORDERS.o_orderkey) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 +), _T_2 AS ( + SELECT + LINEITEM.l_partkey AS L_PARTKEY, + _T.N_REGIONKEY, + ROW_NUMBER() OVER (PARTITION BY _T.N_REGIONKEY ORDER BY LINEITEM.l_quantity DESC, LINEITEM.l_linenumber) AS _W + FROM _T _T + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 + AND LINEITEM.l_orderkey = _T.O_ORDERKEY + WHERE + _T._W = 1 +), _S9 AS ( + SELECT + _T.N_REGIONKEY, + PART.p_name AS P_NAME + FROM _T_2 _T + JOIN TPCH.PART PART + ON PART.p_partkey = _T.L_PARTKEY + WHERE + _T._W = 1 +) +SELECT + REGION.r_name AS region_name, + _S9.P_NAME AS part_name +FROM TPCH.REGION REGION +LEFT JOIN _S9 _S9 + ON REGION.r_regionkey = _S9.N_REGIONKEY +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql b/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql new file mode 100644 index 000000000..89e211219 --- /dev/null +++ b/tests/test_sql_refsols/regional_suppliers_percentile_oracle.sql @@ -0,0 +1,22 @@ +WITH _S3 AS ( + SELECT + ps_suppkey AS PS_SUPPKEY, + COUNT(*) AS N_ROWS + FROM TPCH.PARTSUPP + GROUP BY + ps_suppkey +), _T AS ( + SELECT + SUPPLIER.s_name AS S_NAME, + NTILE(1000) OVER (PARTITION BY NATION.n_regionkey ORDER BY _S3.N_ROWS, SUPPLIER.s_name) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey + JOIN _S3 _S3 + ON SUPPLIER.s_suppkey = _S3.PS_SUPPKEY +) +SELECT + S_NAME AS name +FROM _T +WHERE + _W = 1000 diff --git a/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql b/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql new file mode 100644 index 000000000..2a70de0b6 --- /dev/null +++ b/tests/test_sql_refsols/richest_customer_key_per_region_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC) AS _W + FROM TPCH.NATION NATION + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + C_CUSTKEY AS key +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/richest_customer_per_region_oracle.sql b/tests/test_sql_refsols/richest_customer_per_region_oracle.sql new file mode 100644 index 000000000..ee2c3e38b --- /dev/null +++ b/tests/test_sql_refsols/richest_customer_per_region_oracle.sql @@ -0,0 +1,21 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + CUSTOMER.c_name AS C_NAME, + NATION.n_name AS N_NAME, + REGION.r_name AS R_NAME, + ROW_NUMBER() OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal DESC, CUSTOMER.c_name) AS _W + FROM TPCH.REGION REGION + JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +) +SELECT + R_NAME AS region_name, + N_NAME AS nation_name, + C_NAME AS customer_name, + C_ACCTBAL AS balance +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/simple_cross_11_oracle.sql b/tests/test_sql_refsols/simple_cross_11_oracle.sql new file mode 100644 index 000000000..02b789cc3 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_11_oracle.sql @@ -0,0 +1,14 @@ +WITH _S0 AS ( + SELECT + o_orderdate AS O_ORDERDATE + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + MIN(O_ORDERDATE) AS MIN_O_ORDERDATE + FROM _S0 +) +SELECT + COUNT(*) AS n +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.O_ORDERDATE = _S1.MIN_O_ORDERDATE diff --git a/tests/test_sql_refsols/simple_cross_12_oracle.sql b/tests/test_sql_refsols/simple_cross_12_oracle.sql new file mode 100644 index 000000000..321a655d8 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_12_oracle.sql @@ -0,0 +1,17 @@ +WITH _S0 AS ( + SELECT DISTINCT + o_orderpriority AS O_ORDERPRIORITY + FROM TPCH.ORDERS +), _S1 AS ( + SELECT DISTINCT + c_mktsegment AS C_MKTSEGMENT + FROM TPCH.CUSTOMER +) +SELECT + _S0.O_ORDERPRIORITY AS order_priority, + _S1.C_MKTSEGMENT AS market_segment +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_13_oracle.sql b/tests/test_sql_refsols/simple_cross_13_oracle.sql new file mode 100644 index 000000000..13cd201da --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_13_oracle.sql @@ -0,0 +1,10 @@ +SELECT + 'foo' AS a, + 'bar' AS b, + 'fizz' AS c, + 'buzz' AS d, + 'foobar' AS e, + 'fizzbuzz' AS f, + 'yay' AS g +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/simple_cross_15_oracle.sql b/tests/test_sql_refsols/simple_cross_15_oracle.sql new file mode 100644 index 000000000..bfbf7ff38 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_15_oracle.sql @@ -0,0 +1,35 @@ +WITH _T1 AS ( + SELECT + r_name AS R_NAME + FROM TPCH.REGION +), _S0 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%A%' THEN 'A' ELSE '*' END AS A + FROM _T1 +), _S1 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%E%' THEN 'E' ELSE '*' END AS E + FROM _T1 +), _S3 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%I%' THEN 'I' ELSE '*' END AS I + FROM _T1 +), _S5 AS ( + SELECT DISTINCT + CASE WHEN R_NAME LIKE '%O%' THEN 'O' ELSE '*' END AS O + FROM _T1 +) +SELECT + _S0.A AS a, + _S1.E AS e, + _S3.I AS i, + _S5.O AS o +FROM _S0 _S0 +CROSS JOIN _S1 _S1 +CROSS JOIN _S3 _S3 +CROSS JOIN _S5 _S5 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST, + 3 NULLS FIRST, + 4 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_16_oracle.sql b/tests/test_sql_refsols/simple_cross_16_oracle.sql new file mode 100644 index 000000000..bc1b82df7 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_16_oracle.sql @@ -0,0 +1,38 @@ +WITH _S0 AS ( + SELECT + c_acctbal AS C_ACCTBAL + FROM TPCH.CUSTOMER +), _S1 AS ( + SELECT + MIN(C_ACCTBAL) AS MIN_C_ACCTBAL + FROM _S0 +), _S4 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON _S0.C_ACCTBAL <= ( + _S1.MIN_C_ACCTBAL + 10.0 + ) +), _S2 AS ( + SELECT + s_acctbal AS S_ACCTBAL + FROM TPCH.SUPPLIER +), _S3 AS ( + SELECT + MAX(S_ACCTBAL) AS MAX_S_ACCTBAL + FROM _S2 +), _S5 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM _S2 _S2 + JOIN _S3 _S3 + ON _S2.S_ACCTBAL >= ( + _S3.MAX_S_ACCTBAL - 10.0 + ) +) +SELECT + _S4.N_ROWS AS n1, + _S5.N_ROWS AS n2 +FROM _S4 _S4 +CROSS JOIN _S5 _S5 diff --git a/tests/test_sql_refsols/simple_cross_1_oracle.sql b/tests/test_sql_refsols/simple_cross_1_oracle.sql new file mode 100644 index 000000000..ef278726f --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_1_oracle.sql @@ -0,0 +1,13 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME + FROM TPCH.REGION +) +SELECT + _S0.R_NAME AS r1, + _S1.R_NAME AS r2 +FROM _S0 _S0 +CROSS JOIN _S0 _S1 +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_2_oracle.sql b/tests/test_sql_refsols/simple_cross_2_oracle.sql new file mode 100644 index 000000000..6c2142a43 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_2_oracle.sql @@ -0,0 +1,14 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME + FROM TPCH.REGION +) +SELECT + _S0.R_NAME AS r1, + _S1.R_NAME AS r2 +FROM _S0 _S0 +JOIN _S0 _S1 + ON _S0.R_NAME <> _S1.R_NAME +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_3_oracle.sql b/tests/test_sql_refsols/simple_cross_3_oracle.sql new file mode 100644 index 000000000..25e3ec054 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_3_oracle.sql @@ -0,0 +1,36 @@ +WITH _S1 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + ANY_VALUE(_S1.N_NAME) AS supplier_nation, + ANY_VALUE(_S5.N_NAME) AS customer_nation, + COUNT(*) AS nation_combinations +FROM TPCH.REGION REGION +JOIN _S1 _S1 + ON REGION.r_regionkey = _S1.N_REGIONKEY +JOIN TPCH.REGION REGION_2 + ON REGION_2.r_name = 'AMERICA' +JOIN _S1 _S5 + ON REGION_2.r_regionkey = _S5.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_acctbal < 0 AND CUSTOMER.c_nationkey = _S5.N_NATIONKEY +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 4 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_shipmode = 'SHIP' +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey + AND SUPPLIER.s_nationkey = _S1.N_NATIONKEY +WHERE + REGION.r_name = 'ASIA' +GROUP BY + REGION_2.r_regionkey, + _S5.N_NATIONKEY, + _S1.N_NATIONKEY, + REGION.r_regionkey diff --git a/tests/test_sql_refsols/simple_cross_5_oracle.sql b/tests/test_sql_refsols/simple_cross_5_oracle.sql new file mode 100644 index 000000000..2bc07e3f9 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_5_oracle.sql @@ -0,0 +1,79 @@ +WITH _T1 AS ( + SELECT + p_container AS P_CONTAINER, + p_size AS P_SIZE + FROM TPCH.PART + WHERE + p_container LIKE 'LG%' +), _S6 AS ( + SELECT DISTINCT + P_SIZE + FROM _T1 + ORDER BY + 1 NULLS FIRST + FETCH FIRST 10 ROWS ONLY +), _S0 AS ( + SELECT DISTINCT + P_SIZE + FROM _T1 + ORDER BY + 1 NULLS FIRST + FETCH FIRST 10 ROWS ONLY +), _T4 AS ( + SELECT + ORDERS.o_orderpriority AS O_ORDERPRIORITY, + _S0.P_SIZE, + SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY + FROM _S0 _S0 + JOIN TPCH.ORDERS ORDERS + ON EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1 + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1998 + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_discount = 0 + AND LINEITEM.l_orderkey = ORDERS.o_orderkey + AND LINEITEM.l_shipmode = 'SHIP' + AND LINEITEM.l_tax = 0 + JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey + AND PART.p_container LIKE 'LG%' + AND PART.p_size = _S0.P_SIZE + GROUP BY + ORDERS.o_orderpriority, + _S0.P_SIZE +), _T AS ( + SELECT + O_ORDERPRIORITY, + P_SIZE, + SUM_L_QUANTITY, + ROW_NUMBER() OVER (PARTITION BY P_SIZE ORDER BY CASE + WHEN ( + NOT SUM_L_QUANTITY IS NULL AND SUM_L_QUANTITY > 0 + ) + THEN NVL(SUM_L_QUANTITY, 0) + ELSE NULL + END DESC) AS _W + FROM _T4 +), _S7 AS ( + SELECT + CASE + WHEN ( + NOT SUM_L_QUANTITY IS NULL AND SUM_L_QUANTITY > 0 + ) + THEN NVL(SUM_L_QUANTITY, 0) + ELSE NULL + END AS TOTAL_QTY, + O_ORDERPRIORITY, + P_SIZE + FROM _T + WHERE + _W = 1 +) +SELECT + _S6.P_SIZE AS part_size, + _S7.O_ORDERPRIORITY AS best_order_priority, + _S7.TOTAL_QTY AS best_order_priority_qty +FROM _S6 _S6 +LEFT JOIN _S7 _S7 + ON _S6.P_SIZE = _S7.P_SIZE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_cross_6_oracle.sql b/tests/test_sql_refsols/simple_cross_6_oracle.sql new file mode 100644 index 000000000..8dcae710f --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_6_oracle.sql @@ -0,0 +1,17 @@ +WITH _T1 AS ( + SELECT + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY, + c_mktsegment AS C_MKTSEGMENT, + c_nationkey AS C_NATIONKEY + FROM TPCH.CUSTOMER + WHERE + c_acctbal > 9990 +) +SELECT + COUNT(*) AS n_pairs +FROM _T1 _T1 +JOIN _T1 _T2 + ON _T1.C_CUSTKEY < _T2.C_CUSTKEY + AND _T1.C_MKTSEGMENT = _T2.C_MKTSEGMENT + AND _T1.C_NATIONKEY = _T2.C_NATIONKEY diff --git a/tests/test_sql_refsols/simple_cross_7_oracle.sql b/tests/test_sql_refsols/simple_cross_7_oracle.sql new file mode 100644 index 000000000..811e73f42 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_7_oracle.sql @@ -0,0 +1,32 @@ +WITH _S3 AS ( + SELECT + PART.p_partkey AS P_PARTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.PART PART + JOIN TPCH.PART PART_2 + ON ABS(PART_2.p_retailprice - PART.p_retailprice) < 5.0 + AND PART.p_brand = PART_2.p_brand + AND PART.p_mfgr = PART_2.p_mfgr + AND PART.p_partkey < PART_2.p_partkey + AND PART_2.p_name LIKE '%tomato%' + WHERE + PART.p_brand = 'Brand#35' + AND PART.p_mfgr = 'Manufacturer#3' + AND PART.p_name LIKE '%tomato%' + GROUP BY + PART.p_partkey +) +SELECT + PART.p_partkey AS original_part_key, + NVL(_S3.N_ROWS, 0) AS n_other_parts +FROM TPCH.PART PART +LEFT JOIN _S3 _S3 + ON PART.p_partkey = _S3.P_PARTKEY +WHERE + PART.p_brand = 'Brand#35' + AND PART.p_mfgr = 'Manufacturer#3' + AND PART.p_name LIKE '%tomato%' +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_cross_8_oracle.sql b/tests/test_sql_refsols/simple_cross_8_oracle.sql new file mode 100644 index 000000000..53e6d09d3 --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_8_oracle.sql @@ -0,0 +1,43 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S3 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), _S15 AS ( + SELECT + _S13.R_NAME, + SUPPLIER.s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER SUPPLIER + JOIN _S3 _S11 + ON SUPPLIER.s_nationkey = _S11.N_NATIONKEY + JOIN _S0 _S13 + ON _S11.N_REGIONKEY = _S13.R_REGIONKEY + WHERE + SUPPLIER.s_acctbal < 0 +) +SELECT + ANY_VALUE(_S0.R_NAME) AS supplier_region, + ANY_VALUE(_S1.R_NAME) AS customer_region, + COUNT(*) AS region_combinations +FROM _S0 _S0 +CROSS JOIN _S0 _S1 +JOIN _S3 _S3 + ON _S1.R_REGIONKEY = _S3.N_REGIONKEY +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_mktsegment = 'AUTOMOBILE' AND CUSTOMER.c_nationkey = _S3.N_NATIONKEY +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_clerk = 'Clerk#000000007' +JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 3 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1998 + AND LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN _S15 _S15 + ON LINEITEM.l_suppkey = _S15.S_SUPPKEY AND _S0.R_NAME = _S15.R_NAME +GROUP BY + _S1.R_REGIONKEY, + _S0.R_REGIONKEY diff --git a/tests/test_sql_refsols/simple_cross_9_oracle.sql b/tests/test_sql_refsols/simple_cross_9_oracle.sql new file mode 100644 index 000000000..222c97abc --- /dev/null +++ b/tests/test_sql_refsols/simple_cross_9_oracle.sql @@ -0,0 +1,25 @@ +WITH _S0 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S1 AS ( + SELECT + n_name AS N_NAME, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +) +SELECT + _S1.N_NAME AS n1, + _S5.N_NAME AS n2 +FROM _S0 _S0 +JOIN _S1 _S1 + ON _S0.R_REGIONKEY = _S1.N_REGIONKEY +JOIN _S0 _S3 + ON _S0.R_NAME = _S3.R_NAME +JOIN _S1 _S5 + ON _S1.N_NAME <> _S5.N_NAME AND _S3.R_REGIONKEY = _S5.N_REGIONKEY +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_filter_oracle.sql b/tests/test_sql_refsols/simple_filter_oracle.sql new file mode 100644 index 000000000..dfa0ed0dd --- /dev/null +++ b/tests/test_sql_refsols/simple_filter_oracle.sql @@ -0,0 +1,7 @@ +SELECT + o_orderdate AS order_date, + o_orderkey, + o_totalprice +FROM TPCH.ORDERS +WHERE + o_totalprice < 1000.0 diff --git a/tests/test_sql_refsols/simple_filter_top_five_oracle.sql b/tests/test_sql_refsols/simple_filter_top_five_oracle.sql new file mode 100644 index 000000000..822a6cbdb --- /dev/null +++ b/tests/test_sql_refsols/simple_filter_top_five_oracle.sql @@ -0,0 +1,8 @@ +SELECT + o_orderkey AS key +FROM TPCH.ORDERS +WHERE + o_totalprice < 1000.0 +ORDER BY + 1 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql new file mode 100644 index 000000000..fecf9d3d9 --- /dev/null +++ b/tests/test_sql_refsols/simple_int_float_string_cast_oracle.sql @@ -0,0 +1,25 @@ +SELECT + 1 AS i1, + CAST(2.2 AS INT) AS i2, + CAST('3' AS INT) AS i3, + CAST('4.3' AS INT) AS i4, + CAST('-5.888' AS INT) AS i5, + CAST(-6.0 AS INT) AS i6, + 1.0 AS f1, + 2.2 AS f2, + CAST('3' AS DOUBLE PRECISION) AS f3, + CAST('4.3' AS DOUBLE PRECISION) AS f4, + CAST('-5.888' AS DOUBLE PRECISION) AS f5, + -6.0 AS f6, + 0.0 AS f7, + CAST(1 AS CLOB) AS s1, + CAST(2.2 AS CLOB) AS s2, + CAST('3' AS CLOB) AS s3, + CAST('4.3' AS CLOB) AS s4, + CAST('-5.888' AS CLOB) AS s5, + CAST(-6.1 AS CLOB) AS s6, + CAST(0.1 AS CLOB) AS s7, + CAST('0.0' AS CLOB) AS s8, + CAST('abc def' AS CLOB) AS s9 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/simple_range_1_oracle.sql b/tests/test_sql_refsols/simple_range_1_oracle.sql new file mode 100644 index 000000000..e3dc5a95d --- /dev/null +++ b/tests/test_sql_refsols/simple_range_1_oracle.sql @@ -0,0 +1,13 @@ +SELECT + COLUMN1 AS value +FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS SIMPLE_RANGE(VALUE) diff --git a/tests/test_sql_refsols/simple_range_2_oracle.sql b/tests/test_sql_refsols/simple_range_2_oracle.sql new file mode 100644 index 000000000..c28da3cb0 --- /dev/null +++ b/tests/test_sql_refsols/simple_range_2_oracle.sql @@ -0,0 +1,15 @@ +SELECT + COLUMN1 AS value +FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS SIMPLE_RANGE(VALUE) +ORDER BY + 1 DESC NULLS LAST diff --git a/tests/test_sql_refsols/simple_range_3_oracle.sql b/tests/test_sql_refsols/simple_range_3_oracle.sql new file mode 100644 index 000000000..f4e33756e --- /dev/null +++ b/tests/test_sql_refsols/simple_range_3_oracle.sql @@ -0,0 +1,10 @@ +SELECT + COLUMN1 AS foo +FROM (VALUES + (15), + (16), + (17), + (18), + (19)) AS T1(FOO) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_range_4_oracle.sql b/tests/test_sql_refsols/simple_range_4_oracle.sql new file mode 100644 index 000000000..9afff215a --- /dev/null +++ b/tests/test_sql_refsols/simple_range_4_oracle.sql @@ -0,0 +1,15 @@ +SELECT + COLUMN1 AS N +FROM (VALUES + (10), + (9), + (8), + (7), + (6), + (5), + (4), + (3), + (2), + (1)) AS T2(N) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/simple_range_5_oracle.sql b/tests/test_sql_refsols/simple_range_5_oracle.sql new file mode 100644 index 000000000..e4f7b84dd --- /dev/null +++ b/tests/test_sql_refsols/simple_range_5_oracle.sql @@ -0,0 +1,4 @@ +SELECT + CAST(NULL AS INT) AS x +WHERE + FALSE diff --git a/tests/test_sql_refsols/simple_scan_oracle.sql b/tests/test_sql_refsols/simple_scan_oracle.sql new file mode 100644 index 000000000..e0125c3c4 --- /dev/null +++ b/tests/test_sql_refsols/simple_scan_oracle.sql @@ -0,0 +1,3 @@ +SELECT + o_orderkey AS key +FROM TPCH.ORDERS diff --git a/tests/test_sql_refsols/simple_scan_top_five_oracle.sql b/tests/test_sql_refsols/simple_scan_top_five_oracle.sql new file mode 100644 index 000000000..fcb9ec0a9 --- /dev/null +++ b/tests/test_sql_refsols/simple_scan_top_five_oracle.sql @@ -0,0 +1,6 @@ +SELECT + o_orderkey AS key +FROM TPCH.ORDERS +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql new file mode 100644 index 000000000..c7c17cd9d --- /dev/null +++ b/tests/test_sql_refsols/simple_smallest_or_largest_oracle.sql @@ -0,0 +1,29 @@ +SELECT + LEAST(20, 10) AS s1, + LEAST(20, 20) AS s2, + LEAST(20, 10, 0) AS s3, + LEAST(20, 10, 10, -1, -2, 100, -200) AS s4, + NULL AS s5, + LEAST(20.22, 10.22, -0.34) AS s6, + LEAST( + TIME_STR_TO_TIME('2025-01-01 00:00:00'), + TIME_STR_TO_TIME('2024-01-01 00:00:00'), + TIME_STR_TO_TIME('2023-01-01 00:00:00') + ) AS s7, + LEAST('', 'alphabet soup', 'Hello World') AS s8, + NULL AS s9, + GREATEST(20, 10) AS l1, + GREATEST(20, 20) AS l2, + GREATEST(20, 10, 0) AS l3, + GREATEST(20, 10, 10, -1, -2, 100, -200, 300) AS l4, + NULL AS l5, + GREATEST(20.22, 100.22, -0.34) AS l6, + GREATEST( + TIME_STR_TO_TIME('2025-01-01 00:00:00'), + TIME_STR_TO_TIME('2024-01-01 00:00:00'), + TIME_STR_TO_TIME('2023-01-01 00:00:00') + ) AS l7, + GREATEST('', 'alphabet soup', 'Hello World') AS l8, + NULL AS l9 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/simple_var_std_oracle.sql b/tests/test_sql_refsols/simple_var_std_oracle.sql new file mode 100644 index 000000000..a188907b7 --- /dev/null +++ b/tests/test_sql_refsols/simple_var_std_oracle.sql @@ -0,0 +1,15 @@ +SELECT + ANY_VALUE(NATION.n_name) AS name, + VARIANCE_POP(SUPPLIER.s_acctbal) AS var, + STDDEV_POP(SUPPLIER.s_acctbal) AS std, + VARIANCE(SUPPLIER.s_acctbal) AS sample_var, + STDDEV(SUPPLIER.s_acctbal) AS sample_std, + VARIANCE_POP(SUPPLIER.s_acctbal) AS pop_var, + STDDEV_POP(SUPPLIER.s_acctbal) AS pop_std +FROM TPCH.NATION NATION +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +WHERE + NATION.n_name IN ('ALGERIA', 'ARGENTINA') +GROUP BY + SUPPLIER.s_nationkey diff --git a/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql new file mode 100644 index 000000000..d8ee22aff --- /dev/null +++ b/tests/test_sql_refsols/simple_var_std_with_nulls_oracle.sql @@ -0,0 +1,16 @@ +SELECT + VARIANCE(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_samp_0_nnull, + VARIANCE(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_samp_1_nnull, + VARIANCE(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_samp_2_nnull, + VARIANCE_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS var_pop_0_nnull, + VARIANCE_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS var_pop_1_nnull, + VARIANCE_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS var_pop_2_nnull, + STDDEV(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS std_samp_0_nnull, + STDDEV(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS std_samp_1_nnull, + STDDEV(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS std_samp_2_nnull, + STDDEV_POP(CASE WHEN c_custkey > 3 THEN c_acctbal ELSE NULL END) AS std_pop_0_nnull, + STDDEV_POP(CASE WHEN c_custkey > 2 THEN c_acctbal ELSE NULL END) AS std_pop_1_nnull, + STDDEV_POP(CASE WHEN c_custkey > 1 THEN c_acctbal ELSE NULL END) AS std_pop_2_nnull +FROM TPCH.CUSTOMER +WHERE + c_custkey IN (1, 2, 3) diff --git a/tests/test_sql_refsols/simplification_1_oracle.sql b/tests/test_sql_refsols/simplification_1_oracle.sql new file mode 100644 index 000000000..ad3f7197f --- /dev/null +++ b/tests/test_sql_refsols/simplification_1_oracle.sql @@ -0,0 +1,26 @@ +SELECT + 13 AS s00, + 0 AS s01, + COUNT(*) AS s02, + COUNT(*) + 5 AS s03, + COUNT(*) * 2 AS s04, + COUNT(*) / 8.0 AS s05, + 10 AS s06, + COUNT(*) AS s07, + ABS(COUNT(*) - 25) AS s08, + COUNT(*) + 1 AS s09, + COUNT(*) - 3 AS s10, + COUNT(*) * -1 AS s11, + COUNT(*) / 2.5 AS s12, + COUNT(*) > 10 AS s13, + COUNT(*) >= 10 AS s14, + COUNT(*) = 20 AS s15, + COUNT(*) <> 25 AS s16, + COUNT(*) < 25 AS s17, + COUNT(*) <= 25 AS s18, + COUNT(*) AS s19, + AVG(NVL(LENGTH(sbcustname), 0)) AS s20, + TRUE AS s21, + TRUE AS s22, + TRUE AS s23 +FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_2_oracle.sql b/tests/test_sql_refsols/simplification_2_oracle.sql new file mode 100644 index 000000000..9dbcca858 --- /dev/null +++ b/tests/test_sql_refsols/simplification_2_oracle.sql @@ -0,0 +1,50 @@ +SELECT + TRUE AS s00, + FALSE AS s01, + TRUE AS s02, + FALSE AS s03, + TRUE AS s04, + FALSE AS s05, + NULL AS s06, + NULL AS s07, + NULL AS s08, + NULL AS s09, + NULL AS s10, + NULL AS s11, + FALSE AS s12, + TRUE AS s13, + FALSE AS s14, + FALSE AS s15, + TRUE AS s16, + TRUE AS s17, + TRUE AS s18, + FALSE AS s19, + TRUE AS s20, + FALSE AS s21, + TRUE AS s22, + FALSE AS s23, + FALSE AS s24, + TRUE AS s25, + TRUE AS s26, + FALSE AS s27, + TRUE AS s28, + FALSE AS s29, + 8 AS s30, + 'alphabet' AS s31, + 'SOUP' AS s32, + TRUE AS s33, + FALSE AS s34, + FALSE AS s35, + TRUE AS s36, + 3.0 AS s37, + NULL AS s38, + NULL AS s39, + NULL AS s40, + NULL AS s41, + NULL AS s42, + NULL AS s43, + NULL AS s44, + NULL AS s45, + NULL AS s46, + NVL(MAX(sbcustname), '') LIKE '%r%' AS s47 +FROM MAIN.SBCUSTOMER diff --git a/tests/test_sql_refsols/simplification_3_oracle.sql b/tests/test_sql_refsols/simplification_3_oracle.sql new file mode 100644 index 000000000..222dd74fb --- /dev/null +++ b/tests/test_sql_refsols/simplification_3_oracle.sql @@ -0,0 +1,95 @@ +WITH _T2 AS ( + SELECT + ABS(CAST(sbcustpostalcode AS INT)) AS EXPR_13, + ROW_NUMBER() OVER (ORDER BY sbcustname) AS RANK, + AVG(CAST(ABS(NVL(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER () AS RAVG1, + NVL( + AVG(CAST(ABS(NVL(CAST(sbcustpostalcode AS INT), 0)) AS DOUBLE PRECISION)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), + 0.1 + ) AS RAVG2, + COUNT(CAST(sbcustpostalcode AS INT)) OVER () AS RCNT1, + NVL( + COUNT(CAST(sbcustpostalcode AS INT)) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 0.1 + ) AS RCNT2, + COUNT(*) OVER () AS RSIZ1, + NVL( + COUNT(*) OVER (ORDER BY sbcustname ROWS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING), + 0.1 + ) AS RSIZ2, + SUM(ABS(NVL(CAST(sbcustpostalcode AS INT), 0))) OVER () AS RSUM1, + NVL( + SUM(ABS(NVL(CAST(sbcustpostalcode AS INT), 0))) OVER (ORDER BY sbcustname ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 0.1 + ) AS RSUM2 + FROM MAIN.SBCUSTOMER +), _T1 AS ( + SELECT + RANK, + RAVG1, + RAVG2, + RCNT1, + RCNT2, + RSIZ1, + RSIZ2, + RSUM1, + RSUM2, + CASE + WHEN FLOOR(0.75 * COUNT(EXPR_13) OVER ()) < ROW_NUMBER() OVER (ORDER BY EXPR_13 DESC NULLS LAST) + THEN EXPR_13 + ELSE NULL + END AS EXPR_15, + CASE + WHEN ABS( + ( + ROW_NUMBER() OVER (ORDER BY EXPR_13 DESC NULLS LAST) - 1.0 + ) - ( + ( + COUNT(EXPR_13) OVER () - 1.0 + ) / 2.0 + ) + ) < 1.0 + THEN EXPR_13 + ELSE NULL + END AS EXPR_16 + FROM _T2 +) +SELECT + TRUE AS s00, + TRUE AS s01, + FALSE AS s02, + FALSE AS s03, + FALSE AS s04, + FALSE AS s05, + COUNT(*) >= 3 AS s06, + FALSE AS s07, + COUNT(*) <= 6 AS s08, + FALSE AS s09, + 91 AS s10, + 0 AS s11, + 50 AS s12, + 35 AS s13, + 25.0 AS s14, + ABS(COUNT(*) * -0.75) AS s15, + 10 AS s16, + COUNT(*) AS s17, + COUNT(*) AS s18, + FALSE AS s19, + TRUE AS s20, + FALSE AS s21, + TRUE AS s22, + FALSE AS s23, + TRUE AS s24, + MAX(EXPR_15) AS s25, + AVG(EXPR_16) AS s26, + MIN(RANK) AS s27, + MAX(RANK) AS s28, + ANY_VALUE(RSUM1) AS s29, + ROUND(SUM(RSUM2), 2) AS s30, + ANY_VALUE(RAVG1) AS s31, + ROUND(SUM(RAVG2), 2) AS s32, + ANY_VALUE(RCNT1) AS s33, + ROUND(SUM(RCNT2), 2) AS s34, + ANY_VALUE(RSIZ1) AS s35, + ROUND(SUM(RSIZ2), 2) AS s36 +FROM _T1 diff --git a/tests/test_sql_refsols/simplification_4_oracle.sql b/tests/test_sql_refsols/simplification_4_oracle.sql new file mode 100644 index 000000000..c455e3934 --- /dev/null +++ b/tests/test_sql_refsols/simplification_4_oracle.sql @@ -0,0 +1,119 @@ +WITH _T AS ( + SELECT + sbtxdatetime AS SBTXDATETIME, + ROW_NUMBER() OVER (ORDER BY sbtxdatetime) AS _W, + ROW_NUMBER() OVER (ORDER BY sbtxdatetime DESC) AS _W_2 + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +) +SELECT + SBTXDATETIME AS date_time, + DATE_SUB(TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'WEEK'), 8, WEEK) AS s00, + FALSE AS s01, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (1, 2, 3) AS s02, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (4, 5, 6) AS s03, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (7, 8, 9) AS s04, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (10, 11, 12) AS s05, + FALSE AS s06, + FALSE AS s07, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 4 AS s08, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 7 AS s09, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) < 10 AS s10, + TRUE AS s11, + FALSE AS s12, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 3 AS s13, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 6 AS s14, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) <= 9 AS s15, + TRUE AS s16, + TRUE AS s17, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 3 AS s18, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 6 AS s19, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) > 9 AS s20, + FALSE AS s21, + TRUE AS s22, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 4 AS s23, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 7 AS s24, + EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) >= 10 AS s25, + FALSE AS s26, + TRUE AS s27, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (1, 2, 3) AS s28, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (4, 5, 6) AS s29, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (7, 8, 9) AS s30, + NOT EXTRACT(MONTH FROM CAST(SBTXDATETIME AS DATETIME)) IN (10, 11, 12) AS s31, + TRUE AS s32, + 2024 AS s33, + 3 AS s34, + 8 AS s35, + 13 AS s36, + 12 AS s37, + 45 AS s38, + 59 AS s39, + 2020 AS s40, + 1 AS s41, + 1 AS s42, + 31 AS s43, + 0 AS s44, + 0 AS s45, + 0 AS s46, + 2023 AS s47, + 3 AS s48, + 7 AS s49, + 4 AS s50, + 6 AS s51, + 55 AS s52, + 0 AS s53, + 1999 AS s54, + 4 AS s55, + 12 AS s56, + 31 AS s57, + 23 AS s58, + 59 AS s59, + 58 AS s60, + FALSE AS s61, + FALSE AS s62, + FALSE AS s63, + TRUE AS s64, + TRUE AS s65, + TRUE AS s66, + FALSE AS s67, + FALSE AS s68, + FALSE AS s69, + TRUE AS s70, + TRUE AS s71, + TRUE AS s72, + FALSE AS s73, + FALSE AS s74, + TRUE AS s75, + TRUE AS s76, + FALSE AS s77, + TRUE AS s78, + FALSE AS s79, + TRUE AS s80, + TRUE AS s81, + FALSE AS s82, + TRUE AS s83, + FALSE AS s84, + FALSE AS s85, + TRUE AS s86, + FALSE AS s87, + FALSE AS s88, + TRUE AS s89, + TRUE AS s90, + FALSE AS s91, + TRUE AS s92, + FALSE AS s93, + FALSE AS s94, + TRUE AS s95, + TRUE AS s96, + TO_DATE('2025-02-28', 'YYYY-MM-DD') AS s97, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s98, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s99, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s100, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s101, + TO_DATE('2024-12-30', 'YYYY-MM-DD') AS s102, + TO_DATE('2025-01-06', 'YYYY-MM-DD') AS s103, + TO_DATE('2025-01-06', 'YYYY-MM-DD') AS s104 +FROM _T +WHERE + _W = 1 OR _W_2 = 1 diff --git a/tests/test_sql_refsols/singular1_oracle.sql b/tests/test_sql_refsols/singular1_oracle.sql new file mode 100644 index 000000000..111125469 --- /dev/null +++ b/tests/test_sql_refsols/singular1_oracle.sql @@ -0,0 +1,14 @@ +WITH _S1 AS ( + SELECT + n_name AS N_NAME, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION + WHERE + n_nationkey = 4 +) +SELECT + REGION.r_name AS name, + _S1.N_NAME AS nation_4_name +FROM TPCH.REGION REGION +LEFT JOIN _S1 _S1 + ON REGION.r_regionkey = _S1.N_REGIONKEY diff --git a/tests/test_sql_refsols/singular2_oracle.sql b/tests/test_sql_refsols/singular2_oracle.sql new file mode 100644 index 000000000..295390f8d --- /dev/null +++ b/tests/test_sql_refsols/singular2_oracle.sql @@ -0,0 +1,16 @@ +WITH _S3 AS ( + SELECT + CUSTOMER.c_nationkey AS C_NATIONKEY, + ORDERS.o_orderkey AS O_ORDERKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_orderkey = 454791 + WHERE + CUSTOMER.c_custkey = 1 +) +SELECT + NATION.n_name AS name, + _S3.O_ORDERKEY AS okey +FROM TPCH.NATION NATION +LEFT JOIN _S3 _S3 + ON NATION.n_nationkey = _S3.C_NATIONKEY diff --git a/tests/test_sql_refsols/singular3_oracle.sql b/tests/test_sql_refsols/singular3_oracle.sql new file mode 100644 index 000000000..f56d232d2 --- /dev/null +++ b/tests/test_sql_refsols/singular3_oracle.sql @@ -0,0 +1,29 @@ +WITH _S0 AS ( + SELECT + c_custkey AS C_CUSTKEY, + c_name AS C_NAME + FROM TPCH.CUSTOMER + ORDER BY + 2 NULLS FIRST + FETCH FIRST 5 ROWS ONLY +), _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS _W + FROM TPCH.ORDERS +), _S1 AS ( + SELECT + O_CUSTKEY, + O_ORDERDATE + FROM _T + WHERE + _W = 1 +) +SELECT + _S0.C_NAME AS name +FROM _S0 _S0 +LEFT JOIN _S1 _S1 + ON _S0.C_CUSTKEY = _S1.O_CUSTKEY +ORDER BY + _S1.O_ORDERDATE diff --git a/tests/test_sql_refsols/singular4_oracle.sql b/tests/test_sql_refsols/singular4_oracle.sql new file mode 100644 index 000000000..679675cac --- /dev/null +++ b/tests/test_sql_refsols/singular4_oracle.sql @@ -0,0 +1,26 @@ +WITH _T AS ( + SELECT + o_custkey AS O_CUSTKEY, + o_orderdate AS O_ORDERDATE, + ROW_NUMBER() OVER (PARTITION BY o_custkey ORDER BY o_totalprice DESC) AS _W + FROM TPCH.ORDERS + WHERE + o_orderpriority = '1-URGENT' +), _S1 AS ( + SELECT + O_CUSTKEY, + O_ORDERDATE + FROM _T + WHERE + _W = 1 +) +SELECT + CUSTOMER.c_name AS name +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +WHERE + CUSTOMER.c_nationkey = 6 +ORDER BY + NVL(_S1.O_ORDERDATE, TO_DATE('2000-01-01', 'YYYY-MM-DD')) +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular5_oracle.sql b/tests/test_sql_refsols/singular5_oracle.sql new file mode 100644 index 000000000..63c7d6a08 --- /dev/null +++ b/tests/test_sql_refsols/singular5_oracle.sql @@ -0,0 +1,49 @@ +WITH _T3 AS ( + SELECT + p_brand AS P_BRAND, + p_container AS P_CONTAINER, + p_partkey AS P_PARTKEY + FROM TPCH.PART + WHERE + p_brand = 'Brand#13' +), _T AS ( + SELECT + LINEITEM.l_shipdate AS L_SHIPDATE, + _T7.P_PARTKEY, + ROW_NUMBER() OVER (PARTITION BY _T7.P_CONTAINER ORDER BY LINEITEM.l_extendedprice DESC, LINEITEM.l_shipdate) AS _W + FROM _T3 _T7 + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = _T7.P_PARTKEY + AND LINEITEM.l_shipmode = 'RAIL' + AND LINEITEM.l_tax = 0 +), _S3 AS ( + SELECT + P_PARTKEY, + ANY_VALUE(L_SHIPDATE) AS ANYTHING_L_SHIPDATE, + COUNT(*) AS N_ROWS + FROM _T + WHERE + _W = 1 + GROUP BY + P_PARTKEY +), _T1 AS ( + SELECT + _T3.P_CONTAINER, + MAX(_S3.ANYTHING_L_SHIPDATE) AS MAX_ANYTHING_L_SHIPDATE, + SUM(_S3.N_ROWS) AS SUM_N_ROWS + FROM _T3 _T3 + LEFT JOIN _S3 _S3 + ON _S3.P_PARTKEY = _T3.P_PARTKEY + GROUP BY + _T3.P_CONTAINER +) +SELECT + P_CONTAINER AS container, + MAX_ANYTHING_L_SHIPDATE AS highest_price_ship_date +FROM _T1 +WHERE + SUM_N_ROWS <> 0 +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular6_oracle.sql b/tests/test_sql_refsols/singular6_oracle.sql new file mode 100644 index 000000000..ea0c68aed --- /dev/null +++ b/tests/test_sql_refsols/singular6_oracle.sql @@ -0,0 +1,31 @@ +WITH _T AS ( + SELECT + LINEITEM.l_receiptdate AS L_RECEIPTDATE, + LINEITEM.l_suppkey AS L_SUPPKEY, + ORDERS.o_custkey AS O_CUSTKEY, + ROW_NUMBER() OVER (PARTITION BY ORDERS.o_custkey ORDER BY LINEITEM.l_receiptdate, LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) DESC) AS _W + FROM TPCH.ORDERS ORDERS + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey + WHERE + ORDERS.o_clerk = 'Clerk#000000017' +) +SELECT + CUSTOMER.c_name AS name, + _T.L_RECEIPTDATE AS receipt_date, + NATION.n_name AS nation_name +FROM TPCH.CUSTOMER CUSTOMER +JOIN _T _T + ON CUSTOMER.c_custkey = _T.O_CUSTKEY AND _T._W = 1 +JOIN TPCH.SUPPLIER SUPPLIER + ON SUPPLIER.s_suppkey = _T.L_SUPPKEY +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +WHERE + CUSTOMER.c_nationkey = 4 +ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/singular7_oracle.sql b/tests/test_sql_refsols/singular7_oracle.sql new file mode 100644 index 000000000..7764a3836 --- /dev/null +++ b/tests/test_sql_refsols/singular7_oracle.sql @@ -0,0 +1,49 @@ +WITH _S3 AS ( + SELECT + l_partkey AS L_PARTKEY, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + WHERE + EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 +), _T4 AS ( + SELECT + PARTSUPP.ps_suppkey AS PS_SUPPKEY, + ANY_VALUE(PART.p_name) AS ANYTHING_P_NAME, + COUNT(_S3.L_SUPPKEY) AS COUNT_L_SUPPKEY + FROM TPCH.PARTSUPP PARTSUPP + JOIN TPCH.PART PART + ON PART.p_brand = 'Brand#13' AND PART.p_partkey = PARTSUPP.ps_partkey + LEFT JOIN _S3 _S3 + ON PARTSUPP.ps_partkey = _S3.L_PARTKEY AND PARTSUPP.ps_suppkey = _S3.L_SUPPKEY + GROUP BY + PARTSUPP.ps_partkey, + PARTSUPP.ps_suppkey +), _T AS ( + SELECT + PS_SUPPKEY, + ANYTHING_P_NAME, + COUNT_L_SUPPKEY, + ROW_NUMBER() OVER (PARTITION BY PS_SUPPKEY ORDER BY NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) DESC, ANYTHING_P_NAME) AS _W + FROM _T4 +), _S5 AS ( + SELECT + NVL(NULLIF(COUNT_L_SUPPKEY, 0), 0) AS N_ORDERS, + ANYTHING_P_NAME, + PS_SUPPKEY + FROM _T + WHERE + _W = 1 +) +SELECT + SUPPLIER.s_name AS supplier_name, + _S5.ANYTHING_P_NAME AS part_name, + _S5.N_ORDERS AS n_orders +FROM TPCH.SUPPLIER SUPPLIER +LEFT JOIN _S5 _S5 + ON SUPPLIER.s_suppkey = _S5.PS_SUPPKEY +WHERE + SUPPLIER.s_nationkey = 20 +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/smoke_b_oracle.sql b/tests/test_sql_refsols/smoke_b_oracle.sql new file mode 100644 index 000000000..d41b0d971 --- /dev/null +++ b/tests/test_sql_refsols/smoke_b_oracle.sql @@ -0,0 +1,50 @@ +SELECT + o_orderkey AS key, + LISTAGG( + '_', + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(QUARTER FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)), + EXTRACT(DAY FROM CAST(o_orderdate AS DATETIME)) + ) AS a, + LISTAGG( + ':', + CASE + WHEN DAY_OF_WEEK(o_orderdate) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(o_orderdate) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(o_orderdate) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(o_orderdate) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(o_orderdate) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(o_orderdate) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(o_orderdate) = 6 + THEN 'Saturday' + END, + DAY_OF_WEEK(o_orderdate) + ) AS b, + DATE_SUB(DATE_ADD(TRUNC(CAST(o_orderdate AS TIMESTAMP), 'YEAR'), 6, 'MONTH'), 13, DAY) AS c, + DATE_ADD(DATE_ADD(TRUNC(CAST(o_orderdate AS TIMESTAMP), 'QUARTER'), 1, 'YEAR'), 25, 'HOUR') AS d, + TIME_STR_TO_TIME('2025-01-01 12:35:00') AS e, + TIME_STR_TO_TIME('2025-07-22 12:00:00') AS f, + TO_DATE('2025-01-01', 'YYYY-MM-DD') AS g, + LISTAGG(';', 12, 20, 6) AS h, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), YEAR) AS i, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), QUARTER) AS j, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), MONTH) AS k, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), WEEK) AS l, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), DAY) AS m, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), HOUR) AS n, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), MINUTE) AS o, + DATEDIFF(CAST(o_orderdate AS DATETIME), CAST('1993-05-25 12:45:36' AS TIMESTAMP), SECOND) AS p, + TRUNC(CAST(o_orderdate AS TIMESTAMP), 'WEEK') AS q +FROM TPCH.ORDERS +WHERE + o_clerk LIKE '%5' AND o_comment LIKE '%fo%' AND o_orderpriority LIKE '3%' +ORDER BY + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/smoke_d_oracle.sql b/tests/test_sql_refsols/smoke_d_oracle.sql new file mode 100644 index 000000000..4d35b673c --- /dev/null +++ b/tests/test_sql_refsols/smoke_d_oracle.sql @@ -0,0 +1,29 @@ +SELECT + CUSTOMER.c_custkey AS key, + ROW_NUMBER() OVER (ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS a, + ROW_NUMBER() OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS b, + RANK() OVER (ORDER BY CUSTOMER.c_mktsegment) AS c, + DENSE_RANK() OVER (ORDER BY CUSTOMER.c_mktsegment) AS d, + NTILE(100) OVER (ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS e, + NTILE(12) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal, CUSTOMER.c_custkey) AS f, + LAG(CUSTOMER.c_custkey, 1) OVER (ORDER BY CUSTOMER.c_custkey) AS g, + LAG(CUSTOMER.c_custkey, 2, -1) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS h, + LEAD(CUSTOMER.c_custkey, 1) OVER (ORDER BY CUSTOMER.c_custkey) AS i, + LEAD(CUSTOMER.c_custkey, 6000) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey) AS j, + SUM(CUSTOMER.c_acctbal) OVER (PARTITION BY CUSTOMER.c_nationkey) AS k, + SUM(CUSTOMER.c_acctbal) OVER (ORDER BY CUSTOMER.c_custkey ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS l, + ROUND(AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER (), 2) AS m, + ROUND( + AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_custkey ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING), + 2 + ) AS n, + COUNT(CASE WHEN CUSTOMER.c_acctbal > 0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER () AS o, + COUNT(*) OVER () AS p +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +ORDER BY + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql new file mode 100644 index 000000000..040bd90a6 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 2 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql new file mode 100644 index 000000000..eabd3e5ac --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_friday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 2 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql new file mode 100644 index 000000000..1fc16f17f --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 6 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql new file mode 100644 index 000000000..b4d67c626 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_monday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 6 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql new file mode 100644 index 000000000..584872c0b --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 1 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql new file mode 100644 index 000000000..e9836ebc8 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_saturday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 1 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql new file mode 100644 index 000000000..f7f489a92 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_one_oracle.sql @@ -0,0 +1,24 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + DAY_OF_WEEK(sbtxdatetime) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql new file mode 100644 index 000000000..d4f0b58ab --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_sunday_zero_oracle.sql @@ -0,0 +1,24 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + DAY_OF_WEEK(sbtxdatetime) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql new file mode 100644 index 000000000..9d515872c --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 3 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql new file mode 100644 index 000000000..955c36257 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_thursday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 3 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql new file mode 100644 index 000000000..0c10a5870 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 5 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql new file mode 100644 index 000000000..2cc7da32c --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_tuesday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 5 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql new file mode 100644 index 000000000..66d595c70 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_one_oracle.sql @@ -0,0 +1,28 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + ( + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 4 + ), 7) + ) + 1 AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql new file mode 100644 index 000000000..74b1fee96 --- /dev/null +++ b/tests/test_sql_refsols/sql_transaction_week_sampler_wednesday_zero_oracle.sql @@ -0,0 +1,26 @@ +SELECT + sbtxdatetime AS date_time, + TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'WEEK') AS sow, + CASE + WHEN DAY_OF_WEEK(sbtxdatetime) = 0 + THEN 'Sunday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 1 + THEN 'Monday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 2 + THEN 'Tuesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 3 + THEN 'Wednesday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 4 + THEN 'Thursday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 5 + THEN 'Friday' + WHEN DAY_OF_WEEK(sbtxdatetime) = 6 + THEN 'Saturday' + END AS dayname, + MOD(( + DAY_OF_WEEK(sbtxdatetime) + 4 + ), 7) AS dayofweek +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/string_format_specifiers_oracle.sql b/tests/test_sql_refsols/string_format_specifiers_oracle.sql new file mode 100644 index 000000000..3b50033b2 --- /dev/null +++ b/tests/test_sql_refsols/string_format_specifiers_oracle.sql @@ -0,0 +1,18 @@ +SELECT + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'YYYY') AS d1, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'YY') AS d2, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MM') AS d3, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'Mon') AS d4, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MMMM') AS d5, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DD') AS d6, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DY') AS d7, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'DYDY') AS d8, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'HH24') AS d9, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'HH12') AS d10, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'MI') AS d11, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'SS') AS d12, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'P.M.') AS d13, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), '.FF') AS d14, + TO_CHAR(TIME_STR_TO_TIME('2023-07-15 14:30:45'), 'TZH:TZM') AS d15 +FROM (VALUES + (NULL)) AS _Q_0(_COL_0) diff --git a/tests/test_sql_refsols/string_functions_oracle.sql b/tests/test_sql_refsols/string_functions_oracle.sql new file mode 100644 index 000000000..86bedce30 --- /dev/null +++ b/tests/test_sql_refsols/string_functions_oracle.sql @@ -0,0 +1,30 @@ +SELECT + LOWER(CUSTOMER.c_name) AS lowercase_name, + UPPER(CUSTOMER.c_name) AS uppercase_name, + LENGTH(CUSTOMER.c_name) AS name_length, + CUSTOMER.c_name LIKE 'A%' AS starts_with_A, + CUSTOMER.c_name LIKE '%z' AS ends_with_z, + CUSTOMER.c_name LIKE '%sub%' AS contains_sub, + CUSTOMER.c_name LIKE '%test%' AS matches_like, + LISTAGG('::', CUSTOMER.c_name, NATION.n_name) AS joined_string, + CASE + WHEN LENGTH(CUSTOMER.c_name) >= 20 + THEN SUBSTR(CUSTOMER.c_name, 1, 20) + ELSE SUBSTR(CONCAT('********************', CUSTOMER.c_name), -20) + END AS lpad_name, + SUBSTR(CONCAT(CUSTOMER.c_name, '--------------------'), 1, 20) AS rpad_name, + TRIM(CUSTOMER.c_name) AS stripped, + TRIM('aeiou' FROM CUSTOMER.c_name) AS stripped_vowels, + REPLACE(CUSTOMER.c_name, 'Corp', 'Inc') AS replaced_name, + REPLACE(CUSTOMER.c_name, 'Ltd', '') AS removed_substr, + CASE + WHEN LENGTH('e') = 0 + THEN 0 + ELSE CAST(( + LENGTH(CUSTOMER.c_name) - LENGTH(REPLACE(CUSTOMER.c_name, 'e', '')) + ) / LENGTH('e') AS INT) + END AS count_e, + INSTR(CUSTOMER.c_name, 'Alex') AS idx_Alex +FROM TPCH.CUSTOMER CUSTOMER +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey diff --git a/tests/test_sql_refsols/supplier_best_part_oracle.sql b/tests/test_sql_refsols/supplier_best_part_oracle.sql new file mode 100644 index 000000000..369d48ea3 --- /dev/null +++ b/tests/test_sql_refsols/supplier_best_part_oracle.sql @@ -0,0 +1,37 @@ +WITH _S2 AS ( + SELECT + l_partkey AS L_PARTKEY, + l_suppkey AS L_SUPPKEY, + COUNT(*) AS N_ROWS, + SUM(l_quantity) AS SUM_L_QUANTITY + FROM TPCH.LINEITEM + WHERE + EXTRACT(YEAR FROM CAST(l_shipdate AS DATETIME)) = 1994 AND l_tax = 0 + GROUP BY + l_partkey, + l_suppkey +), _T AS ( + SELECT + _S2.L_SUPPKEY, + _S2.N_ROWS, + PART.p_name AS P_NAME, + _S2.SUM_L_QUANTITY, + ROW_NUMBER() OVER (PARTITION BY _S2.L_SUPPKEY ORDER BY NVL(_S2.SUM_L_QUANTITY, 0) DESC) AS _W + FROM _S2 _S2 + JOIN TPCH.PART PART + ON PART.p_partkey = _S2.L_PARTKEY +) +SELECT + SUPPLIER.s_name AS supplier_name, + _T.P_NAME AS part_name, + NVL(_T.SUM_L_QUANTITY, 0) AS total_quantity, + _T.N_ROWS AS n_shipments +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_name = 'FRANCE' AND NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN _T _T + ON SUPPLIER.s_suppkey = _T.L_SUPPKEY AND _T._W = 1 +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 3 ROWS ONLY diff --git a/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql new file mode 100644 index 000000000..be7ec1a8b --- /dev/null +++ b/tests/test_sql_refsols/supplier_pct_national_qty_oracle.sql @@ -0,0 +1,46 @@ +WITH _S7 AS ( + SELECT + LINEITEM.l_quantity AS L_QUANTITY, + LINEITEM.l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM LINEITEM + JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey + AND PART.p_container LIKE 'LG%' + AND PART.p_name LIKE '%tomato%' + WHERE + EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) < 7 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 + AND LINEITEM.l_shipmode = 'SHIP' +), _T0 AS ( + SELECT + ANY_VALUE(NATION.n_name) AS ANYTHING_N_NAME, + ANY_VALUE(SUPPLIER.s_name) AS ANYTHING_S_NAME, + ANY_VALUE(SUPPLIER.s_nationkey) AS ANYTHING_S_NATIONKEY, + SUM(_S7.L_QUANTITY) AS SUM_L_QUANTITY + FROM TPCH.NATION NATION + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AFRICA' + JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey + AND SUPPLIER.s_acctbal >= 8000.0 + AND SUPPLIER.s_comment LIKE '%careful%' + LEFT JOIN _S7 _S7 + ON SUPPLIER.s_suppkey = _S7.L_SUPPKEY + GROUP BY + SUPPLIER.s_suppkey +) +SELECT + ANYTHING_S_NAME AS supplier_name, + ANYTHING_N_NAME AS nation_name, + NVL(SUM_L_QUANTITY, 0) AS supplier_quantity, + ( + 100.0 * NVL(SUM_L_QUANTITY, 0) + ) / CASE + WHEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) > 0 + THEN SUM(NVL(SUM_L_QUANTITY, 0)) OVER (PARTITION BY ANYTHING_S_NATIONKEY) + ELSE NULL + END AS national_qty_pct +FROM _T0 +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql b/tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql new file mode 100644 index 000000000..e9d4f949f --- /dev/null +++ b/tests/test_sql_refsols/suppliers_bal_diffs_oracle.sql @@ -0,0 +1,12 @@ +SELECT + SUPPLIER.s_name AS name, + REGION.r_name AS region_name, + SUPPLIER.s_acctbal - LAG(SUPPLIER.s_acctbal, 1) OVER (PARTITION BY NATION.n_regionkey ORDER BY SUPPLIER.s_acctbal) AS acctbal_delta +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql b/tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql new file mode 100644 index 000000000..1d86c4628 --- /dev/null +++ b/tests/test_sql_refsols/synthea_most_common_conditions_oracle.sql @@ -0,0 +1,13 @@ +SELECT + CONDITIONS.description AS condition_description +FROM MAIN.PATIENTS PATIENTS +JOIN MAIN.CONDITIONS CONDITIONS + ON CONDITIONS.patient = PATIENTS.patient +WHERE + PATIENTS.ethnicity = 'italian' AND PATIENTS.gender = 'F' +GROUP BY + CONDITIONS.description +ORDER BY + COUNT(*) DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql new file mode 100644 index 000000000..6968355a0 --- /dev/null +++ b/tests/test_sql_refsols/technograph_battery_failure_rates_anomalies_oracle.sql @@ -0,0 +1,29 @@ +WITH _S7 AS ( + SELECT + INCIDENTS.in_device_id AS IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS INCIDENTS + JOIN MAIN.ERRORS ERRORS + ON ERRORS.er_id = INCIDENTS.in_error_id AND ERRORS.er_name = 'Battery Failure' + GROUP BY + INCIDENTS.in_device_id +) +SELECT + COUNTRIES.co_name AS country_name, + PRODUCTS.pr_name AS product_name, + ROUND(NVL(SUM(_S7.N_ROWS), 0) / COUNT(*), 2) AS ir +FROM MAIN.COUNTRIES COUNTRIES +JOIN MAIN.DEVICES DEVICES + ON COUNTRIES.co_id = DEVICES.de_production_country_id +JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id +LEFT JOIN _S7 _S7 + ON DEVICES.de_id = _S7.IN_DEVICE_ID +GROUP BY + COUNTRIES.co_name, + PRODUCTS.pr_name +ORDER BY + 3 DESC NULLS LAST, + 2 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql b/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql new file mode 100644 index 000000000..a392b1a3c --- /dev/null +++ b/tests/test_sql_refsols/technograph_country_cartesian_oddball_oracle.sql @@ -0,0 +1,12 @@ +WITH _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.COUNTRIES +) +SELECT + COUNTRIES.co_name AS name, + _S1.N_ROWS AS n_other_countries +FROM MAIN.COUNTRIES COUNTRIES +CROSS JOIN _S1 _S1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql new file mode 100644 index 000000000..3fc67dd77 --- /dev/null +++ b/tests/test_sql_refsols/technograph_country_combination_analysis_oracle.sql @@ -0,0 +1,45 @@ +WITH _S0 AS ( + SELECT + co_id AS CO_ID, + co_name AS CO_NAME + FROM MAIN.COUNTRIES +), _S2 AS ( + SELECT + co_id AS CO_ID + FROM MAIN.COUNTRIES +), _T1 AS ( + SELECT + ANY_VALUE(_S3.CO_ID) AS ANYTHING__ID_3, + ANY_VALUE(_S2.CO_ID) AS ANYTHING_CO_ID, + COUNT(INCIDENTS.in_device_id) AS COUNT_IN_DEVICE_ID + FROM _S2 _S2 + CROSS JOIN _S2 _S3 + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_production_country_id = _S2.CO_ID + AND DEVICES.de_purchase_country_id = _S3.CO_ID + LEFT JOIN MAIN.INCIDENTS INCIDENTS + ON DEVICES.de_id = INCIDENTS.in_device_id + GROUP BY + DEVICES.de_id +), _S9 AS ( + SELECT + ANYTHING__ID_3, + ANYTHING_CO_ID, + COUNT(*) AS N_ROWS, + SUM(COUNT_IN_DEVICE_ID) AS SUM_N_ROWS + FROM _T1 + GROUP BY + ANYTHING__ID_3, + ANYTHING_CO_ID +) +SELECT + _S0.CO_NAME AS factory_country, + _S1.CO_NAME AS purchase_country, + ROUND(NVL(_S9.SUM_N_ROWS, 0) / NVL(_S9.N_ROWS, 0), 2) AS ir +FROM _S0 _S0 +CROSS JOIN _S0 _S1 +LEFT JOIN _S9 _S9 + ON _S0.CO_ID = _S9.ANYTHING_CO_ID AND _S1.CO_ID = _S9.ANYTHING__ID_3 +ORDER BY + 3 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql new file mode 100644 index 000000000..015d0f98f --- /dev/null +++ b/tests/test_sql_refsols/technograph_country_incident_rate_analysis_oracle.sql @@ -0,0 +1,72 @@ +WITH _T2 AS ( + SELECT + in_device_id AS IN_DEVICE_ID + FROM MAIN.INCIDENTS +), _S1 AS ( + SELECT + IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + IN_DEVICE_ID +), _S3 AS ( + SELECT + DEVICES.de_production_country_id AS DE_PRODUCTION_COUNTRY_ID, + COUNT(*) AS N_ROWS, + SUM(_S1.N_ROWS) AS SUM_N_ROWS + FROM MAIN.DEVICES DEVICES + LEFT JOIN _S1 _S1 + ON DEVICES.de_id = _S1.IN_DEVICE_ID + GROUP BY + DEVICES.de_production_country_id +), _S5 AS ( + SELECT + IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + IN_DEVICE_ID +), _S7 AS ( + SELECT + DEVICES.de_purchase_country_id AS DE_PURCHASE_COUNTRY_ID, + COUNT(*) AS N_ROWS, + SUM(_S5.N_ROWS) AS SUM_N_ROWS + FROM MAIN.DEVICES DEVICES + LEFT JOIN _S5 _S5 + ON DEVICES.de_id = _S5.IN_DEVICE_ID + GROUP BY + DEVICES.de_purchase_country_id +), _T5 AS ( + SELECT + ANY_VALUE(USERS.us_country_id) AS ANYTHING_US_COUNTRY_ID, + COUNT(_S11.IN_DEVICE_ID) AS COUNT_IN_DEVICE_ID + FROM MAIN.USERS USERS + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_owner_id = USERS.us_id + LEFT JOIN _T2 _S11 + ON DEVICES.de_id = _S11.IN_DEVICE_ID + GROUP BY + DEVICES.de_id +), _S13 AS ( + SELECT + ANYTHING_US_COUNTRY_ID, + COUNT(*) AS N_ROWS, + SUM(COUNT_IN_DEVICE_ID) AS SUM_N_ROWS + FROM _T5 + GROUP BY + ANYTHING_US_COUNTRY_ID +) +SELECT + COUNTRIES.co_name AS country_name, + ROUND(NVL(_S3.SUM_N_ROWS, 0) / _S3.N_ROWS, 2) AS made_ir, + ROUND(NVL(_S7.SUM_N_ROWS, 0) / _S7.N_ROWS, 2) AS sold_ir, + ROUND(NVL(_S13.SUM_N_ROWS, 0) / NVL(_S13.N_ROWS, 0), 2) AS user_ir +FROM MAIN.COUNTRIES COUNTRIES +JOIN _S3 _S3 + ON COUNTRIES.co_id = _S3.DE_PRODUCTION_COUNTRY_ID +JOIN _S7 _S7 + ON COUNTRIES.co_id = _S7.DE_PURCHASE_COUNTRY_ID +LEFT JOIN _S13 _S13 + ON COUNTRIES.co_id = _S13.ANYTHING_US_COUNTRY_ID +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql new file mode 100644 index 000000000..453472e15 --- /dev/null +++ b/tests/test_sql_refsols/technograph_error_percentages_sun_set_by_error_oracle.sql @@ -0,0 +1,22 @@ +WITH _S5 AS ( + SELECT + INCIDENTS.in_error_id AS IN_ERROR_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS INCIDENTS + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id + JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'Sun-Set' + GROUP BY + INCIDENTS.in_error_id +) +SELECT + ERRORS.er_name AS error, + ROUND(( + 100.0 * NVL(_S5.N_ROWS, 0) + ) / SUM(NVL(_S5.N_ROWS, 0)) OVER (), 2) AS pct +FROM MAIN.ERRORS ERRORS +LEFT JOIN _S5 _S5 + ON ERRORS.er_id = _S5.IN_ERROR_ID +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql new file mode 100644 index 000000000..bd6ad7122 --- /dev/null +++ b/tests/test_sql_refsols/technograph_error_rate_sun_set_by_factory_country_oracle.sql @@ -0,0 +1,28 @@ +WITH _T2 AS ( + SELECT + ANY_VALUE(DEVICES.de_production_country_id) AS ANYTHING_DE_PRODUCTION_COUNTRY_ID, + COUNT(INCIDENTS.in_device_id) AS COUNT_IN_DEVICE_ID + FROM MAIN.DEVICES DEVICES + JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id AND PRODUCTS.pr_name = 'Sun-Set' + LEFT JOIN MAIN.INCIDENTS INCIDENTS + ON DEVICES.de_id = INCIDENTS.in_device_id + GROUP BY + DEVICES.de_id +), _S5 AS ( + SELECT + NVL(SUM(COUNT_IN_DEVICE_ID), 0) AS SUM_N_INCIDENTS, + ANYTHING_DE_PRODUCTION_COUNTRY_ID, + COUNT(*) AS N_ROWS + FROM _T2 + GROUP BY + ANYTHING_DE_PRODUCTION_COUNTRY_ID +) +SELECT + COUNTRIES.co_name AS country, + ROUND(NVL(_S5.SUM_N_INCIDENTS, 0) / NVL(_S5.N_ROWS, 0), 2) AS ir +FROM MAIN.COUNTRIES COUNTRIES +LEFT JOIN _S5 _S5 + ON COUNTRIES.co_id = _S5.ANYTHING_DE_PRODUCTION_COUNTRY_ID +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql new file mode 100644 index 000000000..d95ee89cb --- /dev/null +++ b/tests/test_sql_refsols/technograph_global_incident_rate_oracle.sql @@ -0,0 +1,13 @@ +WITH _S0 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS +), _S1 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM MAIN.DEVICES +) +SELECT + ROUND(_S0.N_ROWS / _S1.N_ROWS, 2) AS ir +FROM _S0 _S0 +CROSS JOIN _S1 _S1 diff --git a/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql new file mode 100644 index 000000000..b3fa5f7ca --- /dev/null +++ b/tests/test_sql_refsols/technograph_hot_purchase_window_oracle.sql @@ -0,0 +1,17 @@ +SELECT + CALENDAR.ca_dt AS start_of_period, + COUNT(*) AS n_purchases +FROM MAIN.CALENDAR CALENDAR +JOIN MAIN.CALENDAR CALENDAR_2 + ON CALENDAR.ca_dt <= CALENDAR_2.ca_dt + AND CALENDAR_2.ca_dt < DATE_ADD(CAST(CALENDAR.ca_dt AS TIMESTAMP), 5, 'DAY') +JOIN MAIN.DEVICES DEVICES + ON CALENDAR_2.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') +WHERE + EXTRACT(YEAR FROM CAST(CALENDAR.ca_dt AS DATETIME)) = 2024 +GROUP BY + CALENDAR.ca_dt +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 1 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql new file mode 100644 index 000000000..ddcd91706 --- /dev/null +++ b/tests/test_sql_refsols/technograph_incident_rate_by_release_year_oracle.sql @@ -0,0 +1,41 @@ +WITH _S0 AS ( + SELECT + de_product_id AS DE_PRODUCT_ID, + COUNT(*) AS N_ROWS + FROM MAIN.DEVICES + GROUP BY + de_product_id +), _S1 AS ( + SELECT + pr_id AS PR_ID, + pr_release AS PR_RELEASE + FROM MAIN.PRODUCTS +), _S6 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S1.PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + SUM(_S0.N_ROWS) AS SUM_N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON _S0.DE_PRODUCT_ID = _S1.PR_ID + GROUP BY + EXTRACT(YEAR FROM CAST(_S1.PR_RELEASE AS DATETIME)) +), _S7 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S3.PR_RELEASE AS DATETIME)) AS YEAR_PR_RELEASE, + COUNT(*) AS N_ROWS + FROM MAIN.DEVICES DEVICES + JOIN _S1 _S3 + ON DEVICES.de_product_id = _S3.PR_ID + JOIN MAIN.INCIDENTS INCIDENTS + ON DEVICES.de_id = INCIDENTS.in_device_id + GROUP BY + EXTRACT(YEAR FROM CAST(_S3.PR_RELEASE AS DATETIME)) +) +SELECT + _S6.YEAR_PR_RELEASE AS year, + ROUND(NVL(_S7.N_ROWS, 0) / _S6.SUM_N_ROWS, 2) AS ir +FROM _S6 _S6 +LEFT JOIN _S7 _S7 + ON _S6.YEAR_PR_RELEASE = _S7.YEAR_PR_RELEASE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql new file mode 100644 index 000000000..84a771042 --- /dev/null +++ b/tests/test_sql_refsols/technograph_incident_rate_per_brand_oracle.sql @@ -0,0 +1,20 @@ +WITH _S3 AS ( + SELECT + in_device_id AS IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS + GROUP BY + in_device_id +) +SELECT + PRODUCTS.pr_brand AS brand, + ROUND(NVL(SUM(_S3.N_ROWS), 0) / COUNT(*), 2) AS ir +FROM MAIN.DEVICES DEVICES +JOIN MAIN.PRODUCTS PRODUCTS + ON DEVICES.de_product_id = PRODUCTS.pr_id +LEFT JOIN _S3 _S3 + ON DEVICES.de_id = _S3.IN_DEVICE_ID +GROUP BY + PRODUCTS.pr_brand +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql new file mode 100644 index 000000000..7e5e503b8 --- /dev/null +++ b/tests/test_sql_refsols/technograph_monthly_incident_rate_oracle.sql @@ -0,0 +1,70 @@ +WITH _T2 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR + WHERE + EXTRACT(YEAR FROM CAST(ca_dt AS DATETIME)) IN (2020, 2021) +), _T5 AS ( + SELECT + co_id AS CO_ID, + co_name AS CO_NAME + FROM MAIN.COUNTRIES + WHERE + co_name = 'CN' +), _S7 AS ( + SELECT + _T4.CA_DT, + COUNT(*) AS N_ROWS + FROM _T2 _T4 + JOIN MAIN.CALENDAR CALENDAR + ON CALENDAR.ca_dt >= DATE_SUB(CAST(_T4.CA_DT AS TIMESTAMP), 6, MONTH) + JOIN MAIN.DEVICES DEVICES + ON CALENDAR.ca_dt = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN _T5 _T5 + ON DEVICES.de_production_country_id = _T5.CO_ID + GROUP BY + _T4.CA_DT +), _S15 AS ( + SELECT + _T7.CA_DT, + COUNT(*) AS N_ROWS + FROM _T2 _T7 + JOIN MAIN.INCIDENTS INCIDENTS + ON _T7.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id + JOIN _T5 _T8 + ON DEVICES.de_production_country_id = _T8.CO_ID + GROUP BY + _T7.CA_DT +), _T0 AS ( + SELECT + EXTRACT(MONTH FROM CAST(_T2.CA_DT AS DATETIME)) AS MONTH_CA_DT, + EXTRACT(YEAR FROM CAST(_T2.CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM(_S7.N_ROWS) AS SUM_EXPR_3, + SUM(_S15.N_ROWS) AS SUM_N_ROWS + FROM _T2 _T2 + LEFT JOIN _S7 _S7 + ON _S7.CA_DT = _T2.CA_DT + LEFT JOIN _S15 _S15 + ON _S15.CA_DT = _T2.CA_DT + GROUP BY + EXTRACT(MONTH FROM CAST(_T2.CA_DT AS DATETIME)), + EXTRACT(YEAR FROM CAST(_T2.CA_DT AS DATETIME)) +) +SELECT + LISTAGG( + '-', + YEAR_CA_DT, + CASE + WHEN LENGTH(MONTH_CA_DT) >= 2 + THEN SUBSTR(MONTH_CA_DT, 1, 2) + ELSE SUBSTR(CONCAT('00', MONTH_CA_DT), -2) + END + ) AS month, + ROUND(( + 1000000.0 * NVL(SUM_N_ROWS, 0) + ) / NVL(SUM_EXPR_3, 0), 2) AS ir +FROM _T0 +ORDER BY + MONTH_CA_DT NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql new file mode 100644 index 000000000..17ed6ecf1 --- /dev/null +++ b/tests/test_sql_refsols/technograph_most_unreliable_products_oracle.sql @@ -0,0 +1,29 @@ +WITH _S1 AS ( + SELECT + in_device_id AS IN_DEVICE_ID, + COUNT(*) AS N_ROWS + FROM MAIN.INCIDENTS + GROUP BY + in_device_id +), _S3 AS ( + SELECT + DEVICES.de_product_id AS DE_PRODUCT_ID, + COUNT(*) AS N_ROWS, + SUM(_S1.N_ROWS) AS SUM_N_ROWS + FROM MAIN.DEVICES DEVICES + LEFT JOIN _S1 _S1 + ON DEVICES.de_id = _S1.IN_DEVICE_ID + GROUP BY + DEVICES.de_product_id +) +SELECT + PRODUCTS.pr_name AS product, + PRODUCTS.pr_brand AS product_brand, + PRODUCTS.pr_type AS product_type, + ROUND(NVL(_S3.SUM_N_ROWS, 0) / _S3.N_ROWS, 2) AS ir +FROM MAIN.PRODUCTS PRODUCTS +JOIN _S3 _S3 + ON PRODUCTS.pr_id = _S3.DE_PRODUCT_ID +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql new file mode 100644 index 000000000..f53d9460f --- /dev/null +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_goldcopperstar_oracle.sql @@ -0,0 +1,83 @@ +WITH _S14 AS ( + SELECT + ANY_VALUE(pr_release) AS ANYTHING_PR_RELEASE + FROM MAIN.PRODUCTS + WHERE + pr_name = 'GoldCopper-Star' +), _S6 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _T5 AS ( + SELECT + pr_id AS PR_ID, + pr_name AS PR_NAME + FROM MAIN.PRODUCTS + WHERE + pr_name = 'GoldCopper-Star' +), _S7 AS ( + SELECT + _S0.CA_DT, + COUNT(*) AS N_ROWS + FROM _S6 _S0 + JOIN MAIN.INCIDENTS INCIDENTS + ON _S0.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + JOIN MAIN.DEVICES DEVICES + ON DEVICES.de_id = INCIDENTS.in_device_id + JOIN _T5 _T5 + ON DEVICES.de_product_id = _T5.PR_ID + GROUP BY + _S0.CA_DT +), _S13 AS ( + SELECT + _S8.CA_DT, + COUNT(*) AS N_ROWS + FROM _S6 _S8 + JOIN MAIN.DEVICES DEVICES + ON _S8.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + JOIN _T5 _T7 + ON DEVICES.de_product_id = _T7.PR_ID + GROUP BY + _S8.CA_DT +), _S15 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S6.CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM(_S7.N_ROWS) AS SUM_EXPR_4, + SUM(_S13.N_ROWS) AS SUM_N_ROWS + FROM _S6 _S6 + LEFT JOIN _S7 _S7 + ON _S6.CA_DT = _S7.CA_DT + LEFT JOIN _S13 _S13 + ON _S13.CA_DT = _S6.CA_DT + GROUP BY + EXTRACT(YEAR FROM CAST(_S6.CA_DT AS DATETIME)) +) +SELECT + _S15.YEAR_CA_DT - EXTRACT(YEAR FROM CAST(_S14.ANYTHING_PR_RELEASE AS DATETIME)) AS years_since_release, + ROUND( + SUM(NVL(_S15.SUM_EXPR_4, 0)) OVER (ORDER BY _S15.YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(NVL(_S15.SUM_N_ROWS, 0)) OVER (ORDER BY _S15.YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS cum_ir, + ROUND( + ( + 100.0 * ( + NVL(_S15.SUM_N_ROWS, 0) - LAG(NVL(_S15.SUM_N_ROWS, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT) + ) + ) / LAG(NVL(_S15.SUM_N_ROWS, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT), + 2 + ) AS pct_bought_change, + ROUND( + ( + 100.0 * ( + NVL(_S15.SUM_EXPR_4, 0) - LAG(NVL(_S15.SUM_EXPR_4, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT) + ) + ) / LAG(NVL(_S15.SUM_EXPR_4, 0), 1) OVER (ORDER BY _S15.YEAR_CA_DT), + 2 + ) AS pct_incident_change, + NVL(_S15.SUM_N_ROWS, 0) AS bought, + NVL(_S15.SUM_EXPR_4, 0) AS incidents +FROM _S14 _S14 +JOIN _S15 _S15 + ON _S15.YEAR_CA_DT >= EXTRACT(YEAR FROM CAST(_S14.ANYTHING_PR_RELEASE AS DATETIME)) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql new file mode 100644 index 000000000..175af7a5c --- /dev/null +++ b/tests/test_sql_refsols/technograph_year_cumulative_incident_rate_overall_oracle.sql @@ -0,0 +1,64 @@ +WITH _S2 AS ( + SELECT + ca_dt AS CA_DT + FROM MAIN.CALENDAR +), _S3 AS ( + SELECT + _S0.CA_DT, + COUNT(*) AS N_ROWS + FROM _S2 _S0 + JOIN MAIN.DEVICES DEVICES + ON _S0.CA_DT = TRUNC(CAST(DEVICES.de_purchase_ts AS TIMESTAMP), 'DAY') + GROUP BY + _S0.CA_DT +), _S7 AS ( + SELECT + _S4.CA_DT, + COUNT(*) AS N_ROWS + FROM _S2 _S4 + JOIN MAIN.INCIDENTS INCIDENTS + ON _S4.CA_DT = TRUNC(CAST(INCIDENTS.in_error_report_ts AS TIMESTAMP), 'DAY') + GROUP BY + _S4.CA_DT +), _T1 AS ( + SELECT + EXTRACT(YEAR FROM CAST(_S2.CA_DT AS DATETIME)) AS YEAR_CA_DT, + SUM(_S3.N_ROWS) AS SUM_EXPR_3, + SUM(_S7.N_ROWS) AS SUM_N_ROWS + FROM _S2 _S2 + LEFT JOIN _S3 _S3 + ON _S2.CA_DT = _S3.CA_DT + LEFT JOIN _S7 _S7 + ON _S2.CA_DT = _S7.CA_DT + GROUP BY + EXTRACT(YEAR FROM CAST(_S2.CA_DT AS DATETIME)) +) +SELECT + YEAR_CA_DT AS yr, + ROUND( + SUM(NVL(SUM_N_ROWS, 0)) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) / SUM(SUM_EXPR_3) OVER (ORDER BY YEAR_CA_DT ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW), + 2 + ) AS cum_ir, + ROUND( + ( + 100.0 * ( + SUM_EXPR_3 - LAG(SUM_EXPR_3, 1) OVER (ORDER BY YEAR_CA_DT) + ) + ) / LAG(SUM_EXPR_3, 1) OVER (ORDER BY YEAR_CA_DT), + 2 + ) AS pct_bought_change, + ROUND( + ( + 100.0 * ( + NVL(SUM_N_ROWS, 0) - LAG(NVL(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT) + ) + ) / LAG(NVL(SUM_N_ROWS, 0), 1) OVER (ORDER BY YEAR_CA_DT), + 2 + ) AS pct_incident_change, + SUM_EXPR_3 AS bought, + NVL(SUM_N_ROWS, 0) AS incidents +FROM _T1 +WHERE + NOT SUM_EXPR_3 IS NULL AND SUM_EXPR_3 <> 0 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/time_threshold_reached_oracle.sql b/tests/test_sql_refsols/time_threshold_reached_oracle.sql new file mode 100644 index 000000000..3d399735d --- /dev/null +++ b/tests/test_sql_refsols/time_threshold_reached_oracle.sql @@ -0,0 +1,24 @@ +WITH _T3 AS ( + SELECT + sbtxdatetime AS SBTXDATETIME, + ( + 100.0 * SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY') ORDER BY sbtxdatetime ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) + ) / SUM(sbtxshares) OVER (PARTITION BY TRUNC(CAST(sbtxdatetime AS TIMESTAMP), 'DAY')) AS PCT_OF_DAY + FROM MAIN.SBTRANSACTION + WHERE + EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) = 2023 +), _T AS ( + SELECT + SBTXDATETIME, + ROW_NUMBER() OVER (PARTITION BY TRUNC(CAST(SBTXDATETIME AS TIMESTAMP), 'DAY') ORDER BY PCT_OF_DAY) AS _W + FROM _T3 + WHERE + PCT_OF_DAY >= 50.0 +) +SELECT + SBTXDATETIME AS date_time +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/top_customers_by_orders_oracle.sql b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql new file mode 100644 index 000000000..f42e449d6 --- /dev/null +++ b/tests/test_sql_refsols/top_customers_by_orders_oracle.sql @@ -0,0 +1,18 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + o_custkey +) +SELECT + CUSTOMER.c_custkey AS customer_key, + NVL(_S1.N_ROWS, 0) AS n_orders +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql b/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql new file mode 100644 index 000000000..93cc2f7a8 --- /dev/null +++ b/tests/test_sql_refsols/top_lineitems_info_1_oracle.sql @@ -0,0 +1,34 @@ +WITH _S2 AS ( + SELECT + l_linenumber AS L_LINENUMBER, + l_orderkey AS L_ORDERKEY, + l_partkey AS L_PARTKEY, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + ORDER BY + 2 NULLS FIRST, + 1 NULLS FIRST + FETCH FIRST 7 ROWS ONLY +), _S0 AS ( + SELECT + ps_partkey AS PS_PARTKEY, + ps_suppkey AS PS_SUPPKEY + FROM TPCH.PARTSUPP +) +SELECT + _S2.L_ORDERKEY AS order_key, + _S2.L_LINENUMBER AS line_number, + PART.p_size AS part_size, + SUPPLIER.s_nationkey AS supplier_nation +FROM _S2 _S2 +JOIN _S0 _S0 + ON _S0.PS_PARTKEY = _S2.L_PARTKEY AND _S0.PS_SUPPKEY = _S2.L_SUPPKEY +JOIN TPCH.PART PART + ON PART.p_partkey = _S0.PS_PARTKEY +JOIN _S0 _S4 + ON _S2.L_PARTKEY = _S4.PS_PARTKEY AND _S2.L_SUPPKEY = _S4.PS_SUPPKEY +JOIN TPCH.SUPPLIER SUPPLIER + ON SUPPLIER.s_suppkey = _S4.PS_SUPPKEY +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql b/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql new file mode 100644 index 000000000..2ba9d5bfe --- /dev/null +++ b/tests/test_sql_refsols/top_lineitems_info_2_oracle.sql @@ -0,0 +1,28 @@ +WITH _S1 AS ( + SELECT + ps_partkey AS PS_PARTKEY, + ps_suppkey AS PS_SUPPKEY + FROM TPCH.PARTSUPP +) +SELECT + LINEITEM.l_orderkey AS order_key, + LINEITEM.l_linenumber AS line_number, + PART.p_size AS part_size, + NATION.n_nationkey AS supplier_nation +FROM TPCH.PART PART +JOIN _S1 _S1 + ON PART.p_partkey = _S1.PS_PARTKEY +CROSS JOIN TPCH.NATION NATION +JOIN TPCH.SUPPLIER SUPPLIER + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN _S1 _S7 + ON SUPPLIER.s_suppkey = _S7.PS_SUPPKEY +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = PART.p_partkey + AND LINEITEM.l_partkey = _S7.PS_PARTKEY + AND LINEITEM.l_suppkey = _S1.PS_SUPPKEY + AND LINEITEM.l_suppkey = _S7.PS_SUPPKEY +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST +FETCH FIRST 7 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q10_oracle.sql b/tests/test_sql_refsols/tpch_q10_oracle.sql new file mode 100644 index 000000000..36805543d --- /dev/null +++ b/tests/test_sql_refsols/tpch_q10_oracle.sql @@ -0,0 +1,33 @@ +WITH _S3 AS ( + SELECT + ORDERS.o_custkey AS O_CUSTKEY, + SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )) AS SUM_EXPR + FROM TPCH.ORDERS ORDERS + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_returnflag = 'R' + WHERE + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (10, 11, 12) + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1993 + GROUP BY + ORDERS.o_custkey +) +SELECT + CUSTOMER.c_custkey AS C_CUSTKEY, + CUSTOMER.c_name AS C_NAME, + NVL(_S3.SUM_EXPR, 0) AS REVENUE, + CUSTOMER.c_acctbal AS C_ACCTBAL, + NATION.n_name AS N_NAME, + CUSTOMER.c_address AS C_ADDRESS, + CUSTOMER.c_phone AS C_PHONE, + CUSTOMER.c_comment AS C_COMMENT +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +ORDER BY + 3 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 20 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q11_oracle.sql b/tests/test_sql_refsols/tpch_q11_oracle.sql new file mode 100644 index 000000000..97d323b64 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q11_oracle.sql @@ -0,0 +1,43 @@ +WITH _S0 AS ( + SELECT + s_nationkey AS S_NATIONKEY, + s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER +), _T2 AS ( + SELECT + n_name AS N_NAME, + n_nationkey AS N_NATIONKEY + FROM TPCH.NATION + WHERE + n_name = 'GERMANY' +), _S8 AS ( + SELECT + SUM(PARTSUPP.ps_supplycost * PARTSUPP.ps_availqty) AS SUM_METRIC + FROM TPCH.PARTSUPP PARTSUPP + JOIN _S0 _S0 + ON PARTSUPP.ps_suppkey = _S0.S_SUPPKEY + JOIN _T2 _T2 + ON _S0.S_NATIONKEY = _T2.N_NATIONKEY +), _S9 AS ( + SELECT + PARTSUPP.ps_partkey AS PS_PARTKEY, + SUM(PARTSUPP.ps_supplycost * PARTSUPP.ps_availqty) AS SUM_EXPR + FROM TPCH.PARTSUPP PARTSUPP + JOIN _S0 _S4 + ON PARTSUPP.ps_suppkey = _S4.S_SUPPKEY + JOIN _T2 _T4 + ON _S4.S_NATIONKEY = _T4.N_NATIONKEY + GROUP BY + PARTSUPP.ps_partkey +) +SELECT + _S9.PS_PARTKEY, + NVL(_S9.SUM_EXPR, 0) AS VALUE +FROM _S8 _S8 +JOIN _S9 _S9 + ON ( + NVL(_S8.SUM_METRIC, 0) * 0.0001 + ) < NVL(_S9.SUM_EXPR, 0) +ORDER BY + 2 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q12_oracle.sql b/tests/test_sql_refsols/tpch_q12_oracle.sql new file mode 100644 index 000000000..26b980c89 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q12_oracle.sql @@ -0,0 +1,18 @@ +SELECT + LINEITEM.l_shipmode AS L_SHIPMODE, + NVL(SUM(ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS HIGH_LINE_COUNT, + NVL(SUM(NOT ORDERS.o_orderpriority IN ('1-URGENT', '2-HIGH')), 0) AS LOW_LINE_COUNT +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.ORDERS ORDERS + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +WHERE + EXTRACT(YEAR FROM CAST(LINEITEM.l_receiptdate AS DATETIME)) = 1994 + AND LINEITEM.l_commitdate < LINEITEM.l_receiptdate + AND LINEITEM.l_commitdate > LINEITEM.l_shipdate + AND ( + LINEITEM.l_shipmode = 'MAIL' OR LINEITEM.l_shipmode = 'SHIP' + ) +GROUP BY + LINEITEM.l_shipmode +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q13_oracle.sql b/tests/test_sql_refsols/tpch_q13_oracle.sql new file mode 100644 index 000000000..299744cfc --- /dev/null +++ b/tests/test_sql_refsols/tpch_q13_oracle.sql @@ -0,0 +1,22 @@ +WITH _S1 AS ( + SELECT + o_custkey AS O_CUSTKEY, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + WHERE + NOT o_comment LIKE '%special%requests%' + GROUP BY + o_custkey +) +SELECT + NVL(_S1.N_ROWS, 0) AS C_COUNT, + COUNT(*) AS CUSTDIST +FROM TPCH.CUSTOMER CUSTOMER +LEFT JOIN _S1 _S1 + ON CUSTOMER.c_custkey = _S1.O_CUSTKEY +GROUP BY + NVL(_S1.N_ROWS, 0) +ORDER BY + 2 DESC NULLS LAST, + 1 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q14_oracle.sql b/tests/test_sql_refsols/tpch_q14_oracle.sql new file mode 100644 index 000000000..c624de595 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q14_oracle.sql @@ -0,0 +1,23 @@ +SELECT + ( + 100.0 * NVL( + SUM( + CASE + WHEN PART.p_type LIKE 'PROMO%' + THEN LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) + ELSE 0 + END + ), + 0 + ) + ) / NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS PROMO_REVENUE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey +WHERE + EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 9 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1995 diff --git a/tests/test_sql_refsols/tpch_q15_oracle.sql b/tests/test_sql_refsols/tpch_q15_oracle.sql new file mode 100644 index 000000000..a684e9527 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q15_oracle.sql @@ -0,0 +1,45 @@ +WITH _T3 AS ( + SELECT + l_discount AS L_DISCOUNT, + l_extendedprice AS L_EXTENDEDPRICE, + l_shipdate AS L_SHIPDATE, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + WHERE + l_shipdate < TO_DATE('1996-04-01', 'YYYY-MM-DD') + AND l_shipdate >= TO_DATE('1996-01-01', 'YYYY-MM-DD') +), _T1 AS ( + SELECT + SUM(L_EXTENDEDPRICE * ( + 1 - L_DISCOUNT + )) AS SUM_EXPR + FROM _T3 + GROUP BY + L_SUPPKEY +), _S0 AS ( + SELECT + MAX(NVL(SUM_EXPR, 0)) AS MAX_TOTAL_REVENUE + FROM _T1 +), _S3 AS ( + SELECT + L_SUPPKEY, + SUM(L_EXTENDEDPRICE * ( + 1 - L_DISCOUNT + )) AS SUM_EXPR + FROM _T3 + GROUP BY + L_SUPPKEY +) +SELECT + SUPPLIER.s_suppkey AS S_SUPPKEY, + SUPPLIER.s_name AS S_NAME, + SUPPLIER.s_address AS S_ADDRESS, + SUPPLIER.s_phone AS S_PHONE, + NVL(_S3.SUM_EXPR, 0) AS TOTAL_REVENUE +FROM _S0 _S0 +CROSS JOIN TPCH.SUPPLIER SUPPLIER +JOIN _S3 _S3 + ON SUPPLIER.s_suppkey = _S3.L_SUPPKEY + AND _S0.MAX_TOTAL_REVENUE = NVL(_S3.SUM_EXPR, 0) +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q16_oracle.sql b/tests/test_sql_refsols/tpch_q16_oracle.sql new file mode 100644 index 000000000..29deb419f --- /dev/null +++ b/tests/test_sql_refsols/tpch_q16_oracle.sql @@ -0,0 +1,24 @@ +SELECT + PART.p_brand AS P_BRAND, + PART.p_type AS P_TYPE, + PART.p_size AS P_SIZE, + COUNT(DISTINCT PARTSUPP.ps_suppkey) AS SUPPLIER_COUNT +FROM TPCH.PARTSUPP PARTSUPP +JOIN TPCH.SUPPLIER SUPPLIER + ON NOT SUPPLIER.s_comment LIKE '%Customer%Complaints%' + AND PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.PART PART + ON NOT PART.p_type LIKE 'MEDIUM POLISHED%%' + AND PART.p_brand <> 'BRAND#45' + AND PART.p_partkey = PARTSUPP.ps_partkey + AND PART.p_size IN (49, 14, 23, 45, 19, 3, 36, 9) +GROUP BY + PART.p_brand, + PART.p_size, + PART.p_type +ORDER BY + 4 DESC NULLS LAST, + 1 NULLS FIRST, + 2 NULLS FIRST, + 3 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q17_oracle.sql b/tests/test_sql_refsols/tpch_q17_oracle.sql new file mode 100644 index 000000000..553a5444e --- /dev/null +++ b/tests/test_sql_refsols/tpch_q17_oracle.sql @@ -0,0 +1,18 @@ +WITH _T AS ( + SELECT + LINEITEM.l_extendedprice AS L_EXTENDEDPRICE, + LINEITEM.l_quantity AS L_QUANTITY, + AVG(CAST(LINEITEM.l_quantity AS DOUBLE PRECISION)) OVER (PARTITION BY LINEITEM.l_partkey) AS _W + FROM TPCH.PART PART + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_partkey = PART.p_partkey + WHERE + PART.p_brand = 'Brand#23' AND PART.p_container = 'MED BOX' +) +SELECT + NVL(SUM(L_EXTENDEDPRICE), 0) / 7.0 AS AVG_YEARLY +FROM _T +WHERE + L_QUANTITY < ( + 0.2 * _W + ) diff --git a/tests/test_sql_refsols/tpch_q18_oracle.sql b/tests/test_sql_refsols/tpch_q18_oracle.sql new file mode 100644 index 000000000..56cc887f6 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q18_oracle.sql @@ -0,0 +1,26 @@ +WITH _T1 AS ( + SELECT + l_orderkey AS L_ORDERKEY, + SUM(l_quantity) AS SUM_L_QUANTITY + FROM TPCH.LINEITEM + GROUP BY + l_orderkey +) +SELECT + CUSTOMER.c_name AS C_NAME, + CUSTOMER.c_custkey AS C_CUSTKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ORDERS.o_orderdate AS O_ORDERDATE, + ORDERS.o_totalprice AS O_TOTALPRICE, + _T1.SUM_L_QUANTITY AS TOTAL_QUANTITY +FROM TPCH.ORDERS ORDERS +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey +JOIN _T1 _T1 + ON NOT _T1.SUM_L_QUANTITY IS NULL + AND ORDERS.o_orderkey = _T1.L_ORDERKEY + AND _T1.SUM_L_QUANTITY > 300 +ORDER BY + 5 DESC NULLS LAST, + 4 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q19_oracle.sql b/tests/test_sql_refsols/tpch_q19_oracle.sql new file mode 100644 index 000000000..8d61bd47f --- /dev/null +++ b/tests/test_sql_refsols/tpch_q19_oracle.sql @@ -0,0 +1,36 @@ +SELECT + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON ( + ( + LINEITEM.l_quantity <= 11 + AND LINEITEM.l_quantity >= 1 + AND PART.p_brand = 'Brand#12' + AND PART.p_container IN ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') + AND PART.p_size <= 5 + AND PART.p_size >= 1 + ) + OR ( + LINEITEM.l_quantity <= 20 + AND LINEITEM.l_quantity >= 10 + AND PART.p_brand = 'Brand#23' + AND PART.p_container IN ('MED BAG', 'MED BOX', 'MED PACK', 'MED PKG') + AND PART.p_size <= 10 + AND PART.p_size >= 1 + ) + OR ( + LINEITEM.l_quantity <= 30 + AND LINEITEM.l_quantity >= 20 + AND PART.p_brand = 'Brand#34' + AND PART.p_container IN ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') + AND PART.p_size <= 15 + AND PART.p_size >= 1 + ) + ) + AND LINEITEM.l_partkey = PART.p_partkey +WHERE + LINEITEM.l_shipinstruct = 'DELIVER IN PERSON' + AND LINEITEM.l_shipmode IN ('AIR', 'AIR REG') diff --git a/tests/test_sql_refsols/tpch_q1_oracle.sql b/tests/test_sql_refsols/tpch_q1_oracle.sql new file mode 100644 index 000000000..cd723794a --- /dev/null +++ b/tests/test_sql_refsols/tpch_q1_oracle.sql @@ -0,0 +1,26 @@ +SELECT + l_returnflag AS L_RETURNFLAG, + l_linestatus AS L_LINESTATUS, + NVL(SUM(l_quantity), 0) AS SUM_QTY, + NVL(SUM(l_extendedprice), 0) AS SUM_BASE_PRICE, + NVL(SUM(l_extendedprice * ( + 1 - l_discount + )), 0) AS SUM_DISC_PRICE, + NVL(SUM(l_extendedprice * ( + 1 - l_discount + ) * ( + 1 + l_tax + )), 0) AS SUM_CHARGE, + AVG(l_quantity) AS AVG_QTY, + AVG(l_extendedprice) AS AVG_PRICE, + AVG(l_discount) AS AVG_DISC, + COUNT(*) AS COUNT_ORDER +FROM TPCH.LINEITEM +WHERE + l_shipdate <= TO_DATE('1998-12-01', 'YYYY-MM-DD') +GROUP BY + l_linestatus, + l_returnflag +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q20_oracle.sql b/tests/test_sql_refsols/tpch_q20_oracle.sql new file mode 100644 index 000000000..b331574c2 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q20_oracle.sql @@ -0,0 +1,31 @@ +WITH _S5 AS ( + SELECT + LINEITEM.l_partkey AS L_PARTKEY, + SUM(LINEITEM.l_quantity) AS SUM_L_QUANTITY + FROM TPCH.PART PART + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1994 + AND LINEITEM.l_partkey = PART.p_partkey + WHERE + PART.p_name LIKE 'forest%' + GROUP BY + LINEITEM.l_partkey +) +SELECT + ANY_VALUE(SUPPLIER.s_name) AS S_NAME, + ANY_VALUE(SUPPLIER.s_address) AS S_ADDRESS +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_name = 'CANADA' AND NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.PARTSUPP PARTSUPP + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey +JOIN _S5 _S5 + ON PARTSUPP.ps_availqty > ( + 0.5 * NVL(_S5.SUM_L_QUANTITY, 0) + ) + AND PARTSUPP.ps_partkey = _S5.L_PARTKEY +GROUP BY + PARTSUPP.ps_suppkey +ORDER BY + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q21_oracle.sql b/tests/test_sql_refsols/tpch_q21_oracle.sql new file mode 100644 index 000000000..691c66c38 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q21_oracle.sql @@ -0,0 +1,55 @@ +WITH _T5 AS ( + SELECT + l_commitdate AS L_COMMITDATE, + l_linenumber AS L_LINENUMBER, + l_orderkey AS L_ORDERKEY, + l_receiptdate AS L_RECEIPTDATE, + l_suppkey AS L_SUPPKEY + FROM TPCH.LINEITEM + WHERE + l_commitdate < l_receiptdate +), _T3 AS ( + SELECT + _T5.L_LINENUMBER, + _T5.L_ORDERKEY, + ORDERS.o_orderkey AS O_ORDERKEY, + ANY_VALUE(_T5.L_SUPPKEY) AS ANYTHING_L_SUPPKEY, + ANY_VALUE(ORDERS.o_orderstatus) AS ANYTHING_O_ORDERSTATUS + FROM _T5 _T5 + JOIN TPCH.ORDERS ORDERS + ON ORDERS.o_orderkey = _T5.L_ORDERKEY + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey AND LINEITEM.l_suppkey <> _T5.L_SUPPKEY + GROUP BY + _T5.L_LINENUMBER, + _T5.L_ORDERKEY, + ORDERS.o_orderkey +), _S11 AS ( + SELECT + _T3.ANYTHING_L_SUPPKEY + FROM _T3 _T3 + JOIN _T5 _T6 + ON _T3.L_LINENUMBER = _T6.L_LINENUMBER + AND _T3.L_ORDERKEY = _T6.L_ORDERKEY + AND _T3.O_ORDERKEY = _T6.L_ORDERKEY + JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate + AND LINEITEM.l_orderkey = _T6.L_ORDERKEY + AND LINEITEM.l_suppkey <> _T6.L_SUPPKEY + WHERE + _T3.ANYTHING_O_ORDERSTATUS = 'F' +) +SELECT + ANY_VALUE(SUPPLIER.s_name) AS S_NAME, + NVL(NULLIF(COUNT(_S11.ANYTHING_L_SUPPKEY), 0), 0) AS NUMWAIT +FROM TPCH.SUPPLIER SUPPLIER +JOIN TPCH.NATION NATION + ON NATION.n_name = 'SAUDI ARABIA' AND NATION.n_nationkey = SUPPLIER.s_nationkey +LEFT JOIN _S11 _S11 + ON SUPPLIER.s_suppkey = _S11.ANYTHING_L_SUPPKEY +GROUP BY + SUPPLIER.s_suppkey +ORDER BY + 2 DESC NULLS LAST, + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q2_oracle.sql b/tests/test_sql_refsols/tpch_q2_oracle.sql new file mode 100644 index 000000000..cc7b59fcd --- /dev/null +++ b/tests/test_sql_refsols/tpch_q2_oracle.sql @@ -0,0 +1,41 @@ +WITH _T AS ( + SELECT + NATION.n_name AS N_NAME, + PART.p_mfgr AS P_MFGR, + PART.p_partkey AS P_PARTKEY, + SUPPLIER.s_acctbal AS S_ACCTBAL, + SUPPLIER.s_address AS S_ADDRESS, + SUPPLIER.s_comment AS S_COMMENT, + SUPPLIER.s_name AS S_NAME, + SUPPLIER.s_phone AS S_PHONE, + RANK() OVER (PARTITION BY PARTSUPP.ps_partkey ORDER BY PARTSUPP.ps_supplycost) AS _W + FROM TPCH.PART PART + JOIN TPCH.PARTSUPP PARTSUPP + ON PART.p_partkey = PARTSUPP.ps_partkey + JOIN TPCH.SUPPLIER SUPPLIER + ON PARTSUPP.ps_suppkey = SUPPLIER.s_suppkey + JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey + JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'EUROPE' + WHERE + PART.p_size = 15 AND PART.p_type LIKE '%BRASS' +) +SELECT + S_ACCTBAL, + S_NAME, + N_NAME, + P_PARTKEY, + P_MFGR, + S_ADDRESS, + S_PHONE, + S_COMMENT +FROM _T +WHERE + _W = 1 +ORDER BY + 1 DESC NULLS LAST, + 3 NULLS FIRST, + 2 NULLS FIRST, + 4 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q3_oracle.sql b/tests/test_sql_refsols/tpch_q3_oracle.sql new file mode 100644 index 000000000..d4595b0ac --- /dev/null +++ b/tests/test_sql_refsols/tpch_q3_oracle.sql @@ -0,0 +1,24 @@ +SELECT + LINEITEM.l_orderkey AS L_ORDERKEY, + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE, + ORDERS.o_orderdate AS O_ORDERDATE, + ORDERS.o_shippriority AS O_SHIPPRIORITY +FROM TPCH.ORDERS ORDERS +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey + AND LINEITEM.l_shipdate > TO_DATE('1995-03-15', 'YYYY-MM-DD') +WHERE + ORDERS.o_orderdate < TO_DATE('1995-03-15', 'YYYY-MM-DD') +GROUP BY + LINEITEM.l_orderkey, + ORDERS.o_orderdate, + ORDERS.o_shippriority +ORDER BY + 2 DESC NULLS LAST, + 3 NULLS FIRST, + 1 NULLS FIRST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/tpch_q4_oracle.sql b/tests/test_sql_refsols/tpch_q4_oracle.sql new file mode 100644 index 000000000..3dba2c4f5 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q4_oracle.sql @@ -0,0 +1,14 @@ +SELECT + ORDERS.o_orderpriority AS O_ORDERPRIORITY, + COUNT(*) AS ORDER_COUNT +FROM TPCH.ORDERS ORDERS +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_commitdate < LINEITEM.l_receiptdate + AND LINEITEM.l_orderkey = ORDERS.o_orderkey +WHERE + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (7, 8, 9) + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1993 +GROUP BY + ORDERS.o_orderpriority +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q5_oracle.sql b/tests/test_sql_refsols/tpch_q5_oracle.sql new file mode 100644 index 000000000..0054cdbc7 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q5_oracle.sql @@ -0,0 +1,30 @@ +WITH _S11 AS ( + SELECT + NATION.n_name AS N_NAME, + SUPPLIER.s_suppkey AS S_SUPPKEY + FROM TPCH.SUPPLIER SUPPLIER + JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +) +SELECT + ANY_VALUE(NATION.n_name) AS N_NAME, + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE +FROM TPCH.NATION NATION +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'ASIA' +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND ORDERS.o_orderdate < TO_DATE('1995-01-01', 'YYYY-MM-DD') + AND ORDERS.o_orderdate >= TO_DATE('1994-01-01', 'YYYY-MM-DD') +JOIN TPCH.LINEITEM LINEITEM + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN _S11 _S11 + ON LINEITEM.l_suppkey = _S11.S_SUPPKEY AND NATION.n_name = _S11.N_NAME +GROUP BY + NATION.n_nationkey +ORDER BY + 2 DESC NULLS LAST diff --git a/tests/test_sql_refsols/tpch_q6_oracle.sql b/tests/test_sql_refsols/tpch_q6_oracle.sql new file mode 100644 index 000000000..80f156bc9 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q6_oracle.sql @@ -0,0 +1,9 @@ +SELECT + NVL(SUM(l_extendedprice * l_discount), 0) AS REVENUE +FROM TPCH.LINEITEM +WHERE + l_discount <= 0.07 + AND l_discount >= 0.05 + AND l_quantity < 24 + AND l_shipdate < TO_DATE('1995-01-01', 'YYYY-MM-DD') + AND l_shipdate >= TO_DATE('1994-01-01', 'YYYY-MM-DD') diff --git a/tests/test_sql_refsols/tpch_q7_oracle.sql b/tests/test_sql_refsols/tpch_q7_oracle.sql new file mode 100644 index 000000000..765fcc3ea --- /dev/null +++ b/tests/test_sql_refsols/tpch_q7_oracle.sql @@ -0,0 +1,46 @@ +WITH _S9 AS ( + SELECT + NATION.n_name AS N_NAME, + ORDERS.o_orderkey AS O_ORDERKEY + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey + AND ( + NATION.n_name = 'FRANCE' OR NATION.n_name = 'GERMANY' + ) +) +SELECT + NATION.n_name AS SUPP_NATION, + _S9.N_NAME AS CUST_NATION, + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) AS L_YEAR, + NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS REVENUE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN _S9 _S9 + ON LINEITEM.l_orderkey = _S9.O_ORDERKEY + AND ( + NATION.n_name = 'FRANCE' OR NATION.n_name = 'GERMANY' + ) + AND ( + NATION.n_name = 'FRANCE' OR _S9.N_NAME = 'FRANCE' + ) + AND ( + NATION.n_name = 'GERMANY' OR _S9.N_NAME = 'GERMANY' + ) +WHERE + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) IN (1995, 1996) +GROUP BY + EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)), + _S9.N_NAME, + NATION.n_name +ORDER BY + 1 NULLS FIRST, + 2 NULLS FIRST, + 3 NULLS FIRST diff --git a/tests/test_sql_refsols/tpch_q8_oracle.sql b/tests/test_sql_refsols/tpch_q8_oracle.sql new file mode 100644 index 000000000..4bf2f76b9 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q8_oracle.sql @@ -0,0 +1,34 @@ +SELECT + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS O_YEAR, + NVL( + SUM( + CASE + WHEN NATION_2.n_name = 'BRAZIL' + THEN LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) + ELSE 0 + END + ), + 0 + ) / NVL(SUM(LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + )), 0) AS MKT_SHARE +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey AND PART.p_type = 'ECONOMY ANODIZED STEEL' +JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) IN (1995, 1996) + AND LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey +JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.REGION REGION + ON NATION.n_regionkey = REGION.r_regionkey AND REGION.r_name = 'AMERICA' +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.NATION NATION_2 + ON NATION_2.n_nationkey = SUPPLIER.s_nationkey +GROUP BY + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) diff --git a/tests/test_sql_refsols/tpch_q9_oracle.sql b/tests/test_sql_refsols/tpch_q9_oracle.sql new file mode 100644 index 000000000..f8bb56e29 --- /dev/null +++ b/tests/test_sql_refsols/tpch_q9_oracle.sql @@ -0,0 +1,30 @@ +SELECT + NATION.n_name AS NATION, + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS O_YEAR, + NVL( + SUM( + LINEITEM.l_extendedprice * ( + 1 - LINEITEM.l_discount + ) - PARTSUPP.ps_supplycost * LINEITEM.l_quantity + ), + 0 + ) AS AMOUNT +FROM TPCH.LINEITEM LINEITEM +JOIN TPCH.PART PART + ON LINEITEM.l_partkey = PART.p_partkey AND PART.p_name LIKE '%green%' +JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey +JOIN TPCH.NATION NATION + ON NATION.n_nationkey = SUPPLIER.s_nationkey +JOIN TPCH.ORDERS ORDERS + ON LINEITEM.l_orderkey = ORDERS.o_orderkey +JOIN TPCH.PARTSUPP PARTSUPP + ON LINEITEM.l_partkey = PARTSUPP.ps_partkey + AND LINEITEM.l_suppkey = PARTSUPP.ps_suppkey +GROUP BY + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)), + NATION.n_name +ORDER BY + 1 NULLS FIRST, + 2 DESC NULLS LAST +FETCH FIRST 10 ROWS ONLY diff --git a/tests/test_sql_refsols/triple_partition_oracle.sql b/tests/test_sql_refsols/triple_partition_oracle.sql new file mode 100644 index 000000000..e6f47e422 --- /dev/null +++ b/tests/test_sql_refsols/triple_partition_oracle.sql @@ -0,0 +1,72 @@ +WITH _S3 AS ( + SELECT + n_nationkey AS N_NATIONKEY, + n_regionkey AS N_REGIONKEY + FROM TPCH.NATION +), _S5 AS ( + SELECT + r_name AS R_NAME, + r_regionkey AS R_REGIONKEY + FROM TPCH.REGION +), _S14 AS ( + SELECT + ORDERS.o_custkey AS O_CUSTKEY, + PART.p_type AS P_TYPE, + _S5.R_NAME, + COUNT(*) AS N_ROWS + FROM TPCH.PART PART + JOIN TPCH.LINEITEM LINEITEM + ON EXTRACT(MONTH FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 6 + AND EXTRACT(YEAR FROM CAST(LINEITEM.l_shipdate AS DATETIME)) = 1992 + AND LINEITEM.l_partkey = PART.p_partkey + JOIN TPCH.SUPPLIER SUPPLIER + ON LINEITEM.l_suppkey = SUPPLIER.s_suppkey + JOIN _S3 _S3 + ON SUPPLIER.s_nationkey = _S3.N_NATIONKEY + JOIN _S5 _S5 + ON _S3.N_REGIONKEY = _S5.R_REGIONKEY + JOIN TPCH.ORDERS ORDERS + ON EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + AND LINEITEM.l_orderkey = ORDERS.o_orderkey + WHERE + PART.p_container LIKE 'SM%' + GROUP BY + ORDERS.o_custkey, + PART.p_type, + _S5.R_NAME +), _T2 AS ( + SELECT + _S13.R_NAME AS CUST_REGION, + _S14.R_NAME, + SUM(_S14.N_ROWS) AS SUM_N_ROWS + FROM _S14 _S14 + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = _S14.O_CUSTKEY + JOIN _S3 _S11 + ON CUSTOMER.c_nationkey = _S11.N_NATIONKEY + JOIN _S5 _S13 + ON _S11.N_REGIONKEY = _S13.R_REGIONKEY + GROUP BY + _S13.R_NAME, + _S14.P_TYPE, + _S14.R_NAME +), _T1 AS ( + SELECT + R_NAME, + MAX(SUM_N_ROWS) AS MAX_SUM_N_ROWS, + SUM(SUM_N_ROWS) AS SUM_SUM_N_ROWS + FROM _T2 + GROUP BY + CUST_REGION, + R_NAME +) +SELECT + R_NAME AS region, + AVG(( + 100.0 * MAX_SUM_N_ROWS + ) / SUM_SUM_N_ROWS) AS avgpct +FROM _T1 +GROUP BY + R_NAME +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_1_oracle.sql b/tests/test_sql_refsols/user_range_collection_1_oracle.sql new file mode 100644 index 000000000..d59e1e4ab --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_1_oracle.sql @@ -0,0 +1,36 @@ +WITH _S1 AS ( + SELECT + p_size AS P_SIZE, + COUNT(*) AS N_ROWS + FROM TPCH.PART + WHERE + p_name LIKE '%turquoise%' + GROUP BY + p_size +) +SELECT + COLUMN1 AS part_size, + NVL(_S1.N_ROWS, 0) AS n_parts +FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56), + (61), + (66), + (71), + (76), + (81), + (86), + (91), + (96)) AS SIZES(PART_SIZE) +LEFT JOIN _S1 _S1 + ON COLUMN1 = _S1.P_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_2_oracle.sql b/tests/test_sql_refsols/user_range_collection_2_oracle.sql new file mode 100644 index 000000000..6a404df08 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_2_oracle.sql @@ -0,0 +1,547 @@ +WITH _S0 AS ( + SELECT + COLUMN1 AS X + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A(X) +), _S1 AS ( + SELECT + COLUMN1 AS Y + FROM (VALUES + (0), + (2), + (4), + (6), + (8), + (10), + (12), + (14), + (16), + (18), + (20), + (22), + (24), + (26), + (28), + (30), + (32), + (34), + (36), + (38), + (40), + (42), + (44), + (46), + (48), + (50), + (52), + (54), + (56), + (58), + (60), + (62), + (64), + (66), + (68), + (70), + (72), + (74), + (76), + (78), + (80), + (82), + (84), + (86), + (88), + (90), + (92), + (94), + (96), + (98), + (100), + (102), + (104), + (106), + (108), + (110), + (112), + (114), + (116), + (118), + (120), + (122), + (124), + (126), + (128), + (130), + (132), + (134), + (136), + (138), + (140), + (142), + (144), + (146), + (148), + (150), + (152), + (154), + (156), + (158), + (160), + (162), + (164), + (166), + (168), + (170), + (172), + (174), + (176), + (178), + (180), + (182), + (184), + (186), + (188), + (190), + (192), + (194), + (196), + (198), + (200), + (202), + (204), + (206), + (208), + (210), + (212), + (214), + (216), + (218), + (220), + (222), + (224), + (226), + (228), + (230), + (232), + (234), + (236), + (238), + (240), + (242), + (244), + (246), + (248), + (250), + (252), + (254), + (256), + (258), + (260), + (262), + (264), + (266), + (268), + (270), + (272), + (274), + (276), + (278), + (280), + (282), + (284), + (286), + (288), + (290), + (292), + (294), + (296), + (298), + (300), + (302), + (304), + (306), + (308), + (310), + (312), + (314), + (316), + (318), + (320), + (322), + (324), + (326), + (328), + (330), + (332), + (334), + (336), + (338), + (340), + (342), + (344), + (346), + (348), + (350), + (352), + (354), + (356), + (358), + (360), + (362), + (364), + (366), + (368), + (370), + (372), + (374), + (376), + (378), + (380), + (382), + (384), + (386), + (388), + (390), + (392), + (394), + (396), + (398), + (400), + (402), + (404), + (406), + (408), + (410), + (412), + (414), + (416), + (418), + (420), + (422), + (424), + (426), + (428), + (430), + (432), + (434), + (436), + (438), + (440), + (442), + (444), + (446), + (448), + (450), + (452), + (454), + (456), + (458), + (460), + (462), + (464), + (466), + (468), + (470), + (472), + (474), + (476), + (478), + (480), + (482), + (484), + (486), + (488), + (490), + (492), + (494), + (496), + (498), + (500), + (502), + (504), + (506), + (508), + (510), + (512), + (514), + (516), + (518), + (520), + (522), + (524), + (526), + (528), + (530), + (532), + (534), + (536), + (538), + (540), + (542), + (544), + (546), + (548), + (550), + (552), + (554), + (556), + (558), + (560), + (562), + (564), + (566), + (568), + (570), + (572), + (574), + (576), + (578), + (580), + (582), + (584), + (586), + (588), + (590), + (592), + (594), + (596), + (598), + (600), + (602), + (604), + (606), + (608), + (610), + (612), + (614), + (616), + (618), + (620), + (622), + (624), + (626), + (628), + (630), + (632), + (634), + (636), + (638), + (640), + (642), + (644), + (646), + (648), + (650), + (652), + (654), + (656), + (658), + (660), + (662), + (664), + (666), + (668), + (670), + (672), + (674), + (676), + (678), + (680), + (682), + (684), + (686), + (688), + (690), + (692), + (694), + (696), + (698), + (700), + (702), + (704), + (706), + (708), + (710), + (712), + (714), + (716), + (718), + (720), + (722), + (724), + (726), + (728), + (730), + (732), + (734), + (736), + (738), + (740), + (742), + (744), + (746), + (748), + (750), + (752), + (754), + (756), + (758), + (760), + (762), + (764), + (766), + (768), + (770), + (772), + (774), + (776), + (778), + (780), + (782), + (784), + (786), + (788), + (790), + (792), + (794), + (796), + (798), + (800), + (802), + (804), + (806), + (808), + (810), + (812), + (814), + (816), + (818), + (820), + (822), + (824), + (826), + (828), + (830), + (832), + (834), + (836), + (838), + (840), + (842), + (844), + (846), + (848), + (850), + (852), + (854), + (856), + (858), + (860), + (862), + (864), + (866), + (868), + (870), + (872), + (874), + (876), + (878), + (880), + (882), + (884), + (886), + (888), + (890), + (892), + (894), + (896), + (898), + (900), + (902), + (904), + (906), + (908), + (910), + (912), + (914), + (916), + (918), + (920), + (922), + (924), + (926), + (928), + (930), + (932), + (934), + (936), + (938), + (940), + (942), + (944), + (946), + (948), + (950), + (952), + (954), + (956), + (958), + (960), + (962), + (964), + (966), + (968), + (970), + (972), + (974), + (976), + (978), + (980), + (982), + (984), + (986), + (988), + (990), + (992), + (994), + (996), + (998), + (1000)) AS B(Y) +), _S4 AS ( + SELECT + _S0.X, + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON CAST(_S1.Y AS CLOB) LIKE CONCAT(CAST(_S0.X AS CLOB), '%') + GROUP BY + _S0.X +), _S5 AS ( + SELECT + _S2.X, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + JOIN _S1 _S3 + ON CAST(_S3.Y AS CLOB) LIKE CONCAT('%', CAST(_S2.X AS CLOB)) + GROUP BY + _S2.X +) +SELECT + _S4.X AS x, + _S4.N_ROWS AS n_prefix, + _S5.N_ROWS AS n_suffix +FROM _S4 _S4 +JOIN _S5 _S5 + ON _S4.X = _S5.X +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_3_oracle.sql b/tests/test_sql_refsols/user_range_collection_3_oracle.sql new file mode 100644 index 000000000..6a404df08 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_3_oracle.sql @@ -0,0 +1,547 @@ +WITH _S0 AS ( + SELECT + COLUMN1 AS X + FROM (VALUES + (0), + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9)) AS A(X) +), _S1 AS ( + SELECT + COLUMN1 AS Y + FROM (VALUES + (0), + (2), + (4), + (6), + (8), + (10), + (12), + (14), + (16), + (18), + (20), + (22), + (24), + (26), + (28), + (30), + (32), + (34), + (36), + (38), + (40), + (42), + (44), + (46), + (48), + (50), + (52), + (54), + (56), + (58), + (60), + (62), + (64), + (66), + (68), + (70), + (72), + (74), + (76), + (78), + (80), + (82), + (84), + (86), + (88), + (90), + (92), + (94), + (96), + (98), + (100), + (102), + (104), + (106), + (108), + (110), + (112), + (114), + (116), + (118), + (120), + (122), + (124), + (126), + (128), + (130), + (132), + (134), + (136), + (138), + (140), + (142), + (144), + (146), + (148), + (150), + (152), + (154), + (156), + (158), + (160), + (162), + (164), + (166), + (168), + (170), + (172), + (174), + (176), + (178), + (180), + (182), + (184), + (186), + (188), + (190), + (192), + (194), + (196), + (198), + (200), + (202), + (204), + (206), + (208), + (210), + (212), + (214), + (216), + (218), + (220), + (222), + (224), + (226), + (228), + (230), + (232), + (234), + (236), + (238), + (240), + (242), + (244), + (246), + (248), + (250), + (252), + (254), + (256), + (258), + (260), + (262), + (264), + (266), + (268), + (270), + (272), + (274), + (276), + (278), + (280), + (282), + (284), + (286), + (288), + (290), + (292), + (294), + (296), + (298), + (300), + (302), + (304), + (306), + (308), + (310), + (312), + (314), + (316), + (318), + (320), + (322), + (324), + (326), + (328), + (330), + (332), + (334), + (336), + (338), + (340), + (342), + (344), + (346), + (348), + (350), + (352), + (354), + (356), + (358), + (360), + (362), + (364), + (366), + (368), + (370), + (372), + (374), + (376), + (378), + (380), + (382), + (384), + (386), + (388), + (390), + (392), + (394), + (396), + (398), + (400), + (402), + (404), + (406), + (408), + (410), + (412), + (414), + (416), + (418), + (420), + (422), + (424), + (426), + (428), + (430), + (432), + (434), + (436), + (438), + (440), + (442), + (444), + (446), + (448), + (450), + (452), + (454), + (456), + (458), + (460), + (462), + (464), + (466), + (468), + (470), + (472), + (474), + (476), + (478), + (480), + (482), + (484), + (486), + (488), + (490), + (492), + (494), + (496), + (498), + (500), + (502), + (504), + (506), + (508), + (510), + (512), + (514), + (516), + (518), + (520), + (522), + (524), + (526), + (528), + (530), + (532), + (534), + (536), + (538), + (540), + (542), + (544), + (546), + (548), + (550), + (552), + (554), + (556), + (558), + (560), + (562), + (564), + (566), + (568), + (570), + (572), + (574), + (576), + (578), + (580), + (582), + (584), + (586), + (588), + (590), + (592), + (594), + (596), + (598), + (600), + (602), + (604), + (606), + (608), + (610), + (612), + (614), + (616), + (618), + (620), + (622), + (624), + (626), + (628), + (630), + (632), + (634), + (636), + (638), + (640), + (642), + (644), + (646), + (648), + (650), + (652), + (654), + (656), + (658), + (660), + (662), + (664), + (666), + (668), + (670), + (672), + (674), + (676), + (678), + (680), + (682), + (684), + (686), + (688), + (690), + (692), + (694), + (696), + (698), + (700), + (702), + (704), + (706), + (708), + (710), + (712), + (714), + (716), + (718), + (720), + (722), + (724), + (726), + (728), + (730), + (732), + (734), + (736), + (738), + (740), + (742), + (744), + (746), + (748), + (750), + (752), + (754), + (756), + (758), + (760), + (762), + (764), + (766), + (768), + (770), + (772), + (774), + (776), + (778), + (780), + (782), + (784), + (786), + (788), + (790), + (792), + (794), + (796), + (798), + (800), + (802), + (804), + (806), + (808), + (810), + (812), + (814), + (816), + (818), + (820), + (822), + (824), + (826), + (828), + (830), + (832), + (834), + (836), + (838), + (840), + (842), + (844), + (846), + (848), + (850), + (852), + (854), + (856), + (858), + (860), + (862), + (864), + (866), + (868), + (870), + (872), + (874), + (876), + (878), + (880), + (882), + (884), + (886), + (888), + (890), + (892), + (894), + (896), + (898), + (900), + (902), + (904), + (906), + (908), + (910), + (912), + (914), + (916), + (918), + (920), + (922), + (924), + (926), + (928), + (930), + (932), + (934), + (936), + (938), + (940), + (942), + (944), + (946), + (948), + (950), + (952), + (954), + (956), + (958), + (960), + (962), + (964), + (966), + (968), + (970), + (972), + (974), + (976), + (978), + (980), + (982), + (984), + (986), + (988), + (990), + (992), + (994), + (996), + (998), + (1000)) AS B(Y) +), _S4 AS ( + SELECT + _S0.X, + COUNT(*) AS N_ROWS + FROM _S0 _S0 + JOIN _S1 _S1 + ON CAST(_S1.Y AS CLOB) LIKE CONCAT(CAST(_S0.X AS CLOB), '%') + GROUP BY + _S0.X +), _S5 AS ( + SELECT + _S2.X, + COUNT(*) AS N_ROWS + FROM _S0 _S2 + JOIN _S1 _S3 + ON CAST(_S3.Y AS CLOB) LIKE CONCAT('%', CAST(_S2.X AS CLOB)) + GROUP BY + _S2.X +) +SELECT + _S4.X AS x, + _S4.N_ROWS AS n_prefix, + _S5.N_ROWS AS n_suffix +FROM _S4 _S4 +JOIN _S5 _S5 + ON _S4.X = _S5.X +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_4_oracle.sql b/tests/test_sql_refsols/user_range_collection_4_oracle.sql new file mode 100644 index 000000000..917651b58 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_4_oracle.sql @@ -0,0 +1,32 @@ +WITH _T AS ( + SELECT + PART.p_name AS P_NAME, + PART.p_retailprice AS P_RETAILPRICE, + COLUMN1 AS PART_SIZE, + ROW_NUMBER() OVER (PARTITION BY COLUMN1 ORDER BY PART.p_retailprice) AS _W + FROM (VALUES + (1), + (2), + (3), + (4), + (5), + (6), + (7), + (8), + (9), + (10)) AS SIZES(PART_SIZE) + JOIN TPCH.PART PART + ON COLUMN1 = PART.p_size + AND PART.p_container LIKE '%SM DRUM%' + AND PART.p_name LIKE '%azure%' + AND PART.p_type LIKE '%PLATED%' +) +SELECT + PART_SIZE AS part_size, + P_NAME AS name, + P_RETAILPRICE AS retail_price +FROM _T +WHERE + _W = 1 +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/user_range_collection_5_oracle.sql b/tests/test_sql_refsols/user_range_collection_5_oracle.sql new file mode 100644 index 000000000..c00aa9e8a --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_5_oracle.sql @@ -0,0 +1,36 @@ +WITH _S2 AS ( + SELECT + COLUMN1 AS PART_SIZE + FROM (VALUES + (1), + (6), + (11), + (16), + (21), + (26), + (31), + (36), + (41), + (46), + (51), + (56)) AS SIZES(PART_SIZE) +), _S3 AS ( + SELECT + _S0.PART_SIZE, + COUNT(*) AS N_ROWS + FROM _S2 _S0 + JOIN TPCH.PART PART + ON PART.p_name LIKE '%almond%' + AND PART.p_size <= ( + _S0.PART_SIZE + 4 + ) + AND PART.p_size >= _S0.PART_SIZE + GROUP BY + _S0.PART_SIZE +) +SELECT + _S2.PART_SIZE AS part_size, + NVL(_S3.N_ROWS, 0) AS n_parts +FROM _S2 _S2 +LEFT JOIN _S3 _S3 + ON _S2.PART_SIZE = _S3.PART_SIZE diff --git a/tests/test_sql_refsols/user_range_collection_6_oracle.sql b/tests/test_sql_refsols/user_range_collection_6_oracle.sql new file mode 100644 index 000000000..3970ed5f9 --- /dev/null +++ b/tests/test_sql_refsols/user_range_collection_6_oracle.sql @@ -0,0 +1,33 @@ +WITH _S5 AS ( + SELECT + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + COUNT(DISTINCT ORDERS.o_custkey) AS NDISTINCT_O_CUSTKEY + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'AUTOMOBILE' + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'JAPAN' + WHERE + ORDERS.o_clerk = 'Clerk#000000925' + GROUP BY + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) +) +SELECT + COLUMN1 AS year, + NVL(_S5.NDISTINCT_O_CUSTKEY, 0) AS n_orders +FROM (VALUES + (1990), + (1991), + (1992), + (1993), + (1994), + (1995), + (1996), + (1997), + (1998), + (1999), + (2000)) AS YEARS(YEAR) +LEFT JOIN _S5 _S5 + ON COLUMN1 = _S5.YEAR_O_ORDERDATE +ORDER BY + 1 NULLS FIRST diff --git a/tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql b/tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql new file mode 100644 index 000000000..f7961c8cb --- /dev/null +++ b/tests/test_sql_refsols/wdi_albania_footnotes_1978_oracle.sql @@ -0,0 +1,7 @@ +SELECT + FOOTNOTES.description AS footnote_description +FROM MAIN.COUNTRY COUNTRY +JOIN MAIN.FOOTNOTES FOOTNOTES + ON COUNTRY.countrycode = FOOTNOTES.countrycode AND FOOTNOTES.year = 'YR2012' +WHERE + COUNTRY.shortname = 'Albania' diff --git a/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql new file mode 100644 index 000000000..b14a8b8b9 --- /dev/null +++ b/tests/test_sql_refsols/wdi_low_income_country_with_series_oracle.sql @@ -0,0 +1,8 @@ +SELECT + COUNTRY.countrycode AS country_code +FROM MAIN.COUNTRY COUNTRY +JOIN MAIN.COUNTRYNOTES COUNTRYNOTES + ON COUNTRY.countrycode = COUNTRYNOTES.countrycode + AND COUNTRYNOTES.seriescode = 'DT.DOD.DECT.CD' +WHERE + COUNTRY.incomegroup = 'Low income' diff --git a/tests/test_sql_refsols/wealthiest_supplier_oracle.sql b/tests/test_sql_refsols/wealthiest_supplier_oracle.sql new file mode 100644 index 000000000..90f4b244b --- /dev/null +++ b/tests/test_sql_refsols/wealthiest_supplier_oracle.sql @@ -0,0 +1,13 @@ +WITH _T AS ( + SELECT + s_acctbal AS S_ACCTBAL, + s_name AS S_NAME, + ROW_NUMBER() OVER (ORDER BY s_acctbal DESC, s_name) AS _W + FROM TPCH.SUPPLIER +) +SELECT + S_NAME AS name, + S_ACCTBAL AS account_balance +FROM _T +WHERE + _W = 1 diff --git a/tests/test_sql_refsols/week_offset_oracle.sql b/tests/test_sql_refsols/week_offset_oracle.sql new file mode 100644 index 000000000..62d73f30b --- /dev/null +++ b/tests/test_sql_refsols/week_offset_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxdatetime AS date_time, + DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'WEEK') AS week_adj1, + DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, WEEK) AS week_adj2, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'HOUR'), 2, 'WEEK') AS week_adj3, + DATE_ADD(DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, SECOND), 2, 'WEEK') AS week_adj4, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'DAY'), 2, 'WEEK') AS week_adj5, + DATE_ADD(DATE_SUB(CAST(sbtxdatetime AS TIMESTAMP), 1, MINUTE), 2, 'WEEK') AS week_adj6, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'MONTH'), 2, 'WEEK') AS week_adj7, + DATE_ADD(DATE_ADD(CAST(sbtxdatetime AS TIMESTAMP), 1, 'YEAR'), 2, 'WEEK') AS week_adj8 +FROM MAIN.SBTRANSACTION +WHERE + EXTRACT(DAY FROM CAST(sbtxdatetime AS DATETIME)) > 1 + AND EXTRACT(YEAR FROM CAST(sbtxdatetime AS DATETIME)) < 2025 diff --git a/tests/test_sql_refsols/window_filter_order_10_oracle.sql b/tests/test_sql_refsols/window_filter_order_10_oracle.sql new file mode 100644 index 000000000..8396bf098 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_10_oracle.sql @@ -0,0 +1,17 @@ +WITH _T AS ( + SELECT + ORDERS.o_totalprice AS O_TOTALPRICE, + AVG(CAST(NULL AS INT)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' + WHERE + ORDERS.o_clerk = 'Clerk#000000001' +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + O_TOTALPRICE < ( + 0.05 * _W + ) diff --git a/tests/test_sql_refsols/window_filter_order_1_oracle.sql b/tests/test_sql_refsols/window_filter_order_1_oracle.sql new file mode 100644 index 000000000..ea21ffd40 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_1_oracle.sql @@ -0,0 +1,27 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +), _T2 AS ( + SELECT + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + COUNT_O_CUSTKEY, + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_2_oracle.sql b/tests/test_sql_refsols/window_filter_order_2_oracle.sql new file mode 100644 index 000000000..ea21ffd40 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_2_oracle.sql @@ -0,0 +1,27 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +), _T2 AS ( + SELECT + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + COUNT_O_CUSTKEY, + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_3_oracle.sql b/tests/test_sql_refsols/window_filter_order_3_oracle.sql new file mode 100644 index 000000000..ea21ffd40 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_3_oracle.sql @@ -0,0 +1,27 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1992 +), _T2 AS ( + SELECT + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + COUNT_O_CUSTKEY, + AVG(CAST(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) <> 0 AND _W > NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0) diff --git a/tests/test_sql_refsols/window_filter_order_4_oracle.sql b/tests/test_sql_refsols/window_filter_order_4_oracle.sql new file mode 100644 index 000000000..ad1bb5f16 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_4_oracle.sql @@ -0,0 +1,22 @@ +WITH _T2 AS ( + SELECT + COUNT(*) AS N_ROWS + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'GERMANY' + JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + AND EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1992 + GROUP BY + ORDERS.o_custkey +), _T AS ( + SELECT + N_ROWS, + AVG(CAST(N_ROWS AS DOUBLE PRECISION)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + N_ROWS < _W diff --git a/tests/test_sql_refsols/window_filter_order_5_oracle.sql b/tests/test_sql_refsols/window_filter_order_5_oracle.sql new file mode 100644 index 000000000..ce69c4193 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_5_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + 1 AS EXPR_0, + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY + FROM TPCH.CUSTOMER + WHERE + c_mktsegment = 'BUILDING' +), _T AS ( + SELECT + _S1.C_ACCTBAL, + _S1.EXPR_0, + AVG(CAST(NVL(_S1.C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S1 _S1 + ON ORDERS.o_custkey = _S1.C_CUSTKEY + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NOT EXPR_0 IS NULL AND C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_6_oracle.sql b/tests/test_sql_refsols/window_filter_order_6_oracle.sql new file mode 100644 index 000000000..ce69c4193 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_6_oracle.sql @@ -0,0 +1,24 @@ +WITH _S1 AS ( + SELECT + 1 AS EXPR_0, + c_acctbal AS C_ACCTBAL, + c_custkey AS C_CUSTKEY + FROM TPCH.CUSTOMER + WHERE + c_mktsegment = 'BUILDING' +), _T AS ( + SELECT + _S1.C_ACCTBAL, + _S1.EXPR_0, + AVG(CAST(NVL(_S1.C_ACCTBAL, 0) AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S1 _S1 + ON ORDERS.o_custkey = _S1.C_CUSTKEY + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NOT EXPR_0 IS NULL AND C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_7_oracle.sql b/tests/test_sql_refsols/window_filter_order_7_oracle.sql new file mode 100644 index 000000000..2029ce75a --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_7_oracle.sql @@ -0,0 +1,15 @@ +WITH _T AS ( + SELECT + CUSTOMER.c_acctbal AS C_ACCTBAL, + AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND CUSTOMER.c_mktsegment = 'BUILDING' + WHERE + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) = 1995 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_8_oracle.sql b/tests/test_sql_refsols/window_filter_order_8_oracle.sql new file mode 100644 index 000000000..ef696f888 --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_8_oracle.sql @@ -0,0 +1,30 @@ +WITH _S3 AS ( + SELECT + o_custkey AS O_CUSTKEY + FROM TPCH.ORDERS + WHERE + EXTRACT(MONTH FROM CAST(o_orderdate AS DATETIME)) = 1 + AND EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) = 1998 +), _T2 AS ( + SELECT + ANY_VALUE(CUSTOMER.c_acctbal) AS ANYTHING_C_ACCTBAL, + COUNT(_S3.O_CUSTKEY) AS COUNT_O_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + JOIN TPCH.NATION NATION + ON CUSTOMER.c_nationkey = NATION.n_nationkey AND NATION.n_name = 'FRANCE' + LEFT JOIN _S3 _S3 + ON CUSTOMER.c_custkey = _S3.O_CUSTKEY + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + ANYTHING_C_ACCTBAL, + COUNT_O_CUSTKEY, + SUM(NVL(NULLIF(COUNT_O_CUSTKEY, 0), 0)) OVER () AS _W + FROM _T2 +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + NULLIF(COUNT_O_CUSTKEY, 0) IS NULL AND ANYTHING_C_ACCTBAL < _W diff --git a/tests/test_sql_refsols/window_filter_order_9_oracle.sql b/tests/test_sql_refsols/window_filter_order_9_oracle.sql new file mode 100644 index 000000000..2113cdbbd --- /dev/null +++ b/tests/test_sql_refsols/window_filter_order_9_oracle.sql @@ -0,0 +1,30 @@ +WITH _S3 AS ( + SELECT + 1 AS EXPR_0, + NVL(SUM(ORDERS.o_totalprice), 0) AS TOTAL_SPENT, + CUSTOMER.c_custkey AS C_CUSTKEY + FROM TPCH.CUSTOMER CUSTOMER + LEFT JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey + WHERE + CUSTOMER.c_mktsegment = 'BUILDING' + GROUP BY + CUSTOMER.c_custkey +), _T AS ( + SELECT + _S3.EXPR_0, + ORDERS.o_totalprice AS O_TOTALPRICE, + AVG(CAST(_S3.TOTAL_SPENT AS DOUBLE PRECISION)) OVER () AS _W + FROM TPCH.ORDERS ORDERS + LEFT JOIN _S3 _S3 + ON ORDERS.o_custkey = _S3.C_CUSTKEY + WHERE + ORDERS.o_clerk = 'Clerk#000000001' +) +SELECT + COUNT(*) AS n +FROM _T +WHERE + EXPR_0 IS NULL AND O_TOTALPRICE < ( + 0.05 * _W + ) diff --git a/tests/test_sql_refsols/window_functions_oracle.sql b/tests/test_sql_refsols/window_functions_oracle.sql new file mode 100644 index 000000000..d38b2e6e1 --- /dev/null +++ b/tests/test_sql_refsols/window_functions_oracle.sql @@ -0,0 +1,13 @@ +SELECT + DENSE_RANK() OVER (ORDER BY CUSTOMER.c_acctbal DESC) AS rank_value, + NTILE(10) OVER (ORDER BY CUSTOMER.c_acctbal) AS precentile_value, + LAG(CUSTOMER.c_acctbal, 2, 0.0) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal) AS two_prev_value, + LEAD(CUSTOMER.c_acctbal, 2) OVER (PARTITION BY CUSTOMER.c_nationkey ORDER BY CUSTOMER.c_acctbal) AS two_next_value, + SUM(CUSTOMER.c_acctbal) OVER (PARTITION BY NATION.n_regionkey ORDER BY CUSTOMER.c_acctbal ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS relsum_value, + SUM(CUSTOMER.c_acctbal) OVER (ORDER BY CUSTOMER.c_acctbal ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS relsum_value2, + CUSTOMER.c_acctbal / AVG(CAST(CUSTOMER.c_acctbal AS DOUBLE PRECISION)) OVER (ORDER BY CUSTOMER.c_acctbal ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS relavg_value, + CUSTOMER.c_acctbal / COUNT(CASE WHEN CUSTOMER.c_acctbal > 0.0 THEN CUSTOMER.c_acctbal ELSE NULL END) OVER () AS relcount_value, + CUSTOMER.c_acctbal / COUNT(*) OVER () AS relsize_value +FROM TPCH.NATION NATION +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey diff --git a/tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql b/tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql new file mode 100644 index 000000000..9498ddfa2 --- /dev/null +++ b/tests/test_sql_refsols/window_sliding_frame_relsize_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxid AS transaction_id, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS w1, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 4 PRECEDING AND CURRENT ROW) AS w2, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w3, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w4, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS w5, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS w6, + COUNT(*) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 3 PRECEDING AND 5 FOLLOWING) AS w7, + COUNT(*) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 3 PRECEDING AND 5 FOLLOWING) AS w8 +FROM MAIN.SBTRANSACTION +ORDER BY + sbtxdatetime NULLS FIRST +FETCH FIRST 8 ROWS ONLY diff --git a/tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql b/tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql new file mode 100644 index 000000000..5b76a6850 --- /dev/null +++ b/tests/test_sql_refsols/window_sliding_frame_relsum_oracle.sql @@ -0,0 +1,14 @@ +SELECT + sbtxid AS transaction_id, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND 4 FOLLOWING) AS w1, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND 4 FOLLOWING) AS w2, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w3, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS w4, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) AS w5, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) AS w6, + SUM(sbtxshares) OVER (ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 5 PRECEDING AND 1 PRECEDING) AS w7, + SUM(sbtxshares) OVER (PARTITION BY sbtxcustid ORDER BY sbtxdatetime, sbtxid ROWS BETWEEN 5 PRECEDING AND 1 PRECEDING) AS w8 +FROM MAIN.SBTRANSACTION +ORDER BY + sbtxdatetime NULLS FIRST +FETCH FIRST 8 ROWS ONLY diff --git a/tests/test_sql_refsols/year_month_nation_orders_oracle.sql b/tests/test_sql_refsols/year_month_nation_orders_oracle.sql new file mode 100644 index 000000000..da9a6a46a --- /dev/null +++ b/tests/test_sql_refsols/year_month_nation_orders_oracle.sql @@ -0,0 +1,21 @@ +SELECT + NATION.n_name AS nation_name, + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS order_year, + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)) AS order_month, + COUNT(*) AS n_orders +FROM TPCH.REGION REGION +JOIN TPCH.NATION NATION + ON NATION.n_regionkey = REGION.r_regionkey +JOIN TPCH.CUSTOMER CUSTOMER + ON CUSTOMER.c_nationkey = NATION.n_nationkey +JOIN TPCH.ORDERS ORDERS + ON CUSTOMER.c_custkey = ORDERS.o_custkey AND ORDERS.o_orderpriority = '1-URGENT' +WHERE + REGION.r_name IN ('ASIA', 'AFRICA') +GROUP BY + EXTRACT(MONTH FROM CAST(ORDERS.o_orderdate AS DATETIME)), + EXTRACT(YEAR FROM CAST(ORDERS.o_orderdate AS DATETIME)), + NATION.n_name +ORDER BY + 4 DESC NULLS LAST +FETCH FIRST 5 ROWS ONLY diff --git a/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql new file mode 100644 index 000000000..4e0924cbc --- /dev/null +++ b/tests/test_sql_refsols/yoy_change_in_num_orders_oracle.sql @@ -0,0 +1,17 @@ +WITH _T0 AS ( + SELECT + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) AS YEAR_O_ORDERDATE, + COUNT(*) AS N_ROWS + FROM TPCH.ORDERS + GROUP BY + EXTRACT(YEAR FROM CAST(o_orderdate AS DATETIME)) +) +SELECT + YEAR_O_ORDERDATE AS year, + N_ROWS AS current_year_orders, + ( + 100.0 * CAST(N_ROWS - LAG(N_ROWS, 1) OVER (ORDER BY YEAR_O_ORDERDATE) AS DOUBLE PRECISION) + ) / LAG(N_ROWS, 1) OVER (ORDER BY YEAR_O_ORDERDATE) AS pct_change +FROM _T0 +ORDER BY + 1 NULLS FIRST