This topic describes how to edit a HeatWave cluster.

1. Open the navigation menu. Under MySQL, click DB Systems.
   A list of DB Systems is displayed.
2. In the HeatWave filter, select Attached to filter the DB Systems by those with HeatWave clusters attached.
3. Edit your HeatWave cluster in one of the following ways:
   • Select the DB System and choose Edit HeatWave Cluster from the Actions icon (three dots) on the same line as your DB System.
   • Open the DB System and select HeatWave from the Resources list.
4. Click Edit.
   The Edit HeatWave Cluster dialog is displayed.
5. On the Edit HeatWave Cluster dialog, you can change the shape of the HeatWave nodes, or change the number of nodes in the HeatWave cluster, and run node count estimations.
   To determine the number of nodes you should create, click Estimate Node Count. For instructions, see Generating a Node Count Estimate.
6. When the edits are complete, click Save Changes to apply the changes.

This section describes the HeatWave Cluster Information and HeatWave Node sections of the MySQL DB System Details page, which enables you to manage, view, and edit your HeatWave cluster .

This topic describes how to check the status of a HeatWave cluster.

1. Open the navigation menu. Under MySQL, click DB Systems.
   A list of DB Systems is displayed.
2. In the HeatWave filter, select Attached to filter the DB Systems by those with HeatWave clusters attached.
3. Choose your Compartment.
4. In the list of DB Systems, find yours and check the icon in the State column. The color of the icon and the associated text indicate the status of the HeatWave cluster.

   • CREATING: Yellow icon. Resources are being reserved for the HeatWave cluster, and the HeatWave cluster is being created. Provisioning can take several minutes. The HeatWave cluster is not ready to use yet.

   • ACTIVE: Green icon. The HeatWave cluster was successfully created.

   • UPDATING: Yellow icon. The HeatWave cluster is in the process of starting, stopping, restarting, or updating.

   • INACTIVE: Grey icon. The HeatWave cluster is powered off by the stop or restart action in the Console or API.

   • DELETING: Orange icon. The HeatWave cluster is being deleted by the terminate action in the Console or API.

   • DELETED: Grey icon. The HeatWave cluster has been deleted and is no longer available.

   • FAILED: Red icon. An error condition prevented the creation or continued operation of the HeatWave cluster.

5. To check the status of HeatWave nodes, click the name of the DB System to open the DB System Details page, then select HeatWave from the Resources list.

When a HeatWave node failure is detected, HeatWave automatically attempts to bring the node back online and reform the cluster.

When the HeatWave cluster is reformed, HeatWave attempts to reload the tables that were previously loaded in the HeatWave cluster. The tables are reloaded from the MySQL Server. The time to reload tables depends on data size. You can expect the operation to take approximately the same amount of time it took to load the tables into the HeatWave cluster initially, assuming table size has not changed significantly.

To monitor the recovery process, you can connect to the MySQL DB System using a client, such as MySQL Shell, to query the rapid_service_status variable, which reports the status of the HeatWave cluster. For information about connecting to the MySQL Server, see Connecting to a DB System.

mysql> SHOW STATUS LIKE 'rapid_service_status';
+----------------------+--------------+
| Variable_name        | Value        |
+----------------------+--------------+
| rapid_service_status | CLUSTERREADY |
+----------------------+--------------+

This topic describes how to start or stop a HeatWave cluster.

1. Open the navigation menu. Under MySQL, click DB Systems.
   A list of DB Systems is displayed.
2. In the HeatWave filter, select Attached to filter the DB Systems by those with HeatWave clusters attached.
3. Choose your DB System.
4. In the Resources list, select HeatWave.
   The HeatWave Cluster Information section is displayed.
5. Select one of the following actions:
   • Start: Starts a stopped HeatWave cluster. After the HeatWave cluster is started, the Stop action is enabled and the Start option is disabled.
   • Stop: Stops a running HeatWave cluster. After the HeatWave cluster is stopped, the Start action is enabled.
   • Restart: Shuts down a HeatWave cluster, and restarts it. You must reload data to the cluster.
   Stopping the HeatWave cluster stops billing for the cluster. Billing resumes if you restart the HeatWave cluster.
   Note
   
   These actions have no affect on the DB System to which the HeatWave cluster is attached. However, start, stop, or restart actions on the DB System also affect the attached HeatWave cluster.

This topic describes how to delete a HeatWave cluster. Deleting a HeatWave cluster removes the HeatWave cluster permanently.

1. Open the navigation menu. Under MySQL, click DB Systems.
   A list of DB Systems is displayed.
2. In the HeatWave filter, select Attached to filter the DB Systems by those with a HeatWave cluster attached.
3. Open your DB System and select HeatWave from the Resources list.
4. To delete the HeatWave cluster, click Delete and follow the instructions.
   Deleting the HeatWave cluster does not delete the DB System or any of the data.
   Note
   
   Deleting the HeatWave cluster has no affect on the DB System to which the HeatWave cluster is attached. However, deleting the DB System also deletes the attached HeatWave cluster.

This topic describes how to generate HeatWave node count estimates to determine the number of nodes required for your data.

1. Click Estimate Node Count on either the Add HeatWave Cluster or Edit HeatWave Cluster dialogs.
   The Estimate Node Count dialog is displayed.
2. On the Estimate Node Count dialog, click Generate Estimate.
   If you recently generated a node count estimate, the previous estimate details are displayed. Click Regenerate Estimate to create a new estimate.
   The operation may take several minutes depending on the size and properties of your data. When the operation completes, you are presented with a table that displays information about the schemas that were evaluated. The information shown includes:

   • Name: The name of the schema.
   • Memory Size Estimate: The estimated amount of memory required for the schema.
   • Information: The number of tables in the schema.
3. Select the schemas that you want to include in the node count estimate.
   The estimate details in the Summary dialog box are adjusted automatically after modifying the schema selection.
4. Optionally, expand the schema rows to view information about individual tables. Deselect tables that you do not want to include in the estimate.
   Note
   
   The Information column reports errors if there are problems with a table. For example, an error is reported if a table contains a column with an unsupported data type, or if a table has too many columns. Tables with errors are not included in the node count estimate. In this case, regenerate the node count estimate after resolving the errors. For information about potential table errors, see Node Count Estimate Table Errors.
   The estimate details in the Summary dialog box are adjusted automatically after modifying the table selection.
5. Review the estimate details in the Summary dialog box, which provides the following information:
   • Shape: The selected HeatWave node shape.
   • CPU Core Count: The CPU core count of the selected HeatWave node shape.
   • Memory Size: The memory size of the selected HeatWave node shape.
   • Node Count: The estimated number of HeatWave nodes required based on the data size and the selected HeatWave node shape.
   • Total Cluster Memory Required: The estimated amount of memory required for the HeatWave cluster based on the data size.
   • Total Cluster Memory Size: The total HeatWave cluster memory size, which is the memory size of the selected HeatWave node shape multiplied by the Node Count estimate.
6. To apply the node count estimate, click Apply Node Count Estimate.

This topic describes table errors that may appear in node count estimate results.

This topic lists the prerequisites for the HeatWave Quickstart.

This topic describes how to upload your sample data files for the tpch sample database to an Object Storage bucket.

1. In the Oracle Cloud Infrastructure Console navigation menu, go to Object Storage, and then select Object Storage.
2. From the list of Buckets, click Create Bucket or select your object storage bucket.
3. On the Bucket Details page, under Objects, click Upload.
4. In the Upload Objects panel, drag and drop the sample database files to the dropzone, or click select files to locate them on your machine.
5. Click Upload, and then click Close.

This topic describes how to create the tpch sample database on the MySQL DB System and import the sample data. The sample data must be available on the MySQL DB System before it can be loaded into the HeatWave Cluster.

1. SSH into the Compute instance using the public IP address of the Compute instance.

   ssh opc@computeInstancePublicIP

2. Start MySQL Shell and connect to the MySQL DB System's endpoint:

   shell> mysqlsh --mysql Username@IPAddressOfMySQLDBSystemEndpoint 
   Please provide the password for 'Username@IPAddressOfMySQLDBSystemEndpoint':
   Save password for 'Username@IPAddressOfMySQLDBSystemEndpoint'? 
   [Y]es/[N]o/Ne[v]er (default No):

   The --mysql option opens a ClassicSession, which is required when using the MySQL Shell Parallel Table Import Utility.

   MySQL Shell opens in JavaScript execution mode by default.

   MySQL>JS>

3. Change the MySQL Shell execution mode from JavaScript to SQL:

   MySQL>JS> \sql

4. Create the sample database and tables:

   CREATE DATABASE tpch character set utf8mb4;
   USE tpch;
   
   CREATE TABLE nation  ( N_NATIONKEY INTEGER primary key,
       N_NAME       CHAR(25) NOT NULL,
       N_REGIONKEY  INTEGER NOT NULL,
       N_COMMENT    VARCHAR(152));
   							
   CREATE TABLE region  ( R_REGIONKEY INTEGER primary key,
       R_NAME       CHAR(25) NOT NULL,
       R_COMMENT    VARCHAR(152));
   							
   CREATE TABLE part  ( P_PARTKEY INTEGER primary key,
       P_NAME        VARCHAR(55) NOT NULL,
       P_MFGR        CHAR(25) NOT NULL,
       P_BRAND       CHAR(10) NOT NULL,
       P_TYPE        VARCHAR(25) NOT NULL,
       P_SIZE        INTEGER NOT NULL,
       P_CONTAINER   CHAR(10) NOT NULL,
       P_RETAILPRICE DECIMAL(15,2) NOT NULL,
       P_COMMENT     VARCHAR(23) NOT NULL );
   						  
   CREATE TABLE supplier  ( S_SUPPKEY INTEGER primary key,
       S_NAME        CHAR(25) NOT NULL,
       S_ADDRESS     VARCHAR(40) NOT NULL,
       S_NATIONKEY   INTEGER NOT NULL,
       S_PHONE       CHAR(15) NOT NULL,
       S_ACCTBAL     DECIMAL(15,2) NOT NULL,
       S_COMMENT     VARCHAR(101) NOT NULL);
   							 
   CREATE TABLE partsupp  ( PS_PARTKEY INTEGER NOT NULL,
       PS_SUPPKEY     INTEGER NOT NULL,
       PS_AVAILQTY    INTEGER NOT NULL,
       PS_SUPPLYCOST  DECIMAL(15,2)  NOT NULL,
       PS_COMMENT     VARCHAR(199) NOT NULL, primary key (ps_partkey, ps_suppkey) );
   						
   CREATE TABLE customer  ( C_CUSTKEY INTEGER primary key,
       C_NAME        VARCHAR(25) NOT NULL,
       C_ADDRESS     VARCHAR(40) NOT NULL,
       C_NATIONKEY   INTEGER NOT NULL,
       C_PHONE       CHAR(15) NOT NULL,
       C_ACCTBAL     DECIMAL(15,2)   NOT NULL,
       C_MKTSEGMENT  CHAR(10) NOT NULL,
       C_COMMENT     VARCHAR(117) NOT NULL);
   							 
   CREATE TABLE orders  ( O_ORDERKEY INTEGER primary key,
       O_CUSTKEY        INTEGER NOT NULL,
       O_ORDERSTATUS    CHAR(1) NOT NULL,
       O_TOTALPRICE     DECIMAL(15,2) NOT NULL,
       O_ORDERDATE      DATE NOT NULL,
       O_ORDERPRIORITY  CHAR(15) NOT NULL,
       O_CLERK          CHAR(15) NOT NULL,
       O_SHIPPRIORITY   INTEGER NOT NULL,
       O_COMMENT        VARCHAR(79) NOT NULL);
   						   
   CREATE TABLE lineitem ( L_ORDERKEY INTEGER NOT NULL,
       L_PARTKEY     INTEGER NOT NULL,
       L_SUPPKEY     INTEGER NOT NULL,
       L_LINENUMBER  INTEGER NOT NULL,
       L_QUANTITY    DECIMAL(15,2) NOT NULL,
       L_EXTENDEDPRICE  DECIMAL(15,2) NOT NULL,
       L_DISCOUNT    DECIMAL(15,2) NOT NULL,
       L_TAX         DECIMAL(15,2) NOT NULL,
       L_RETURNFLAG  CHAR(1) NOT NULL,
       L_LINESTATUS  CHAR(1) NOT NULL,
       L_SHIPDATE    DATE NOT NULL,
       L_COMMITDATE  DATE NOT NULL,
       L_RECEIPTDATE DATE NOT NULL,
       L_SHIPINSTRUCT CHAR(25) NOT NULL,
       L_SHIPMODE     CHAR(10) NOT NULL,
       L_COMMENT      VARCHAR(44) NOT NULL,
       primary key(L_ORDERKEY,L_LINENUMBER));

5. Verify that the schema and tables were created:

   MySQL>SQL> SHOW TABLES;
   +----------------+
   | Tables_in_tpch |
   +----------------+
   | customer       |
   | lineitem       |
   | nation         |
   | orders         |
   | part           |
   | partsupp       |
   | region         |
   | supplier       |
   +----------------+

6. Change back to JavaScript execution mode to use the parallel table import utility:

   MySQL>SQL> \js

7. Execute the following operations to import the data into the tpch database on the MySQL DB System. When you specify your region, namespace, and bucket values, the importTable parameter string will appear similar to "oci+os://us-ashburn-1/your_tenancy/your_bucket/nation.tbl".
   Note
   
   For information about the util.importTable() options used in the following commands, see MySQL Shell Parallel Table Import Utility. The number of parallel threads specified using the threads option depends on the number of CPU cores of the shape. It is assumed that sample data fields are terminated by the pipe "|" character, and that the data files have an initial header line containing column names, which is omitted from the import operation using the skipRows option.

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/nation.tbl", {schema:"tpch", table:"nation", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/region.tbl", {schema:"tpch", table:"region", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/part.tbl", {schema:"tpch", table:"part", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/supplier.tbl", {schema:"tpch", table:"supplier", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/partsupp.tbl", {schema:"tpch", table:"partsupp", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/customer.tbl", {schema:"tpch", table:"customer", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/orders.tbl", {schema:"tpch", table:"orders", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

   MySQL>JS> util.importTable("oci+os://region/namespace/bucket/lineitem.tbl", {schema:"tpch", table:"lineitem", fieldsTerminatedBy:"|", bytesPerChunk:"100M", threads:16, skipRows:1})

This topic describes how to add a HeatWave cluster to your MySQL DB System.

1. In the navigation menu, go to MySQL, and select DB System.
2. On the MySQL DB Systems page, select your DB System.
3. On the MySQL DB Systems Details page, select Add HeatWave Cluster from the More Actions drop-down menu.
4. On the Add HeatWave Cluster dialog, click Select Shape to select a shape for your HeatWave nodes. You must use the same shape used by the MySQL DB System. The shape defines the number of CPU cores, the amount of RAM, and so on.
5. Define the number of HeatWave nodes to create. The default number of nodes is 2, which is a sufficient number of nodes for the HeatWave Quickstart, assuming roughly 1GB of data. Optionally, you can perform a node count estimate to determine an appropriate number of nodes to create. For details, see Generating a Node Count Estimate.
6. Click Add HeatWave Cluster to create the HeatWave cluster.

This topic describes how to load data into the HeatWave cluster.

1. SSH into the Compute instance using the public IP address of the Compute instance.

   ssh opc@computeInstancePublicIP

2. Start MySQL Shell and connect to the MySQL DB System's endpoint:

   shell> mysqlsh Username@IPAddressOfMySQLDBSystemEndpoint

   MySQL Shell opens in JavaScript execution mode by default.

   MySQL>JS>

3. Change the MySQL Shell execution mode to SQL:

   MySQL>JS> \sql

4. Execute the following operations to prepare the tpch sample database tables and load them into the HeatWave cluster. The operations performed include defining string column encodings, defining the secondary engine, and executing a SECONDARY_LOAD operations.

   USE tpch;
   
   ALTER TABLE nation modify `N_NAME` CHAR(25) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE nation modify `N_COMMENT` VARCHAR(152) COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE nation SECONDARY_ENGINE=RAPID;
   ALTER TABLE nation SECONDARY_LOAD;
   
   ALTER TABLE region modify `R_NAME` CHAR(25) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE region modify `R_COMMENT` VARCHAR(152) COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE region SECONDARY_ENGINE=RAPID;
   ALTER TABLE region SECONDARY_LOAD;
   
   ALTER TABLE part modify `P_MFGR` CHAR(25) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE part modify `P_BRAND` CHAR(10) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE part modify `P_CONTAINER` CHAR(10) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE part modify `P_COMMENT` VARCHAR(23) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE part SECONDARY_ENGINE=RAPID;
   ALTER TABLE part SECONDARY_LOAD;
   
   ALTER TABLE supplier modify `S_NAME` CHAR(25) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE supplier modify `S_ADDRESS` VARCHAR(40) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE supplier modify `S_PHONE` CHAR(15) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE supplier SECONDARY_ENGINE=RAPID;
   ALTER TABLE supplier SECONDARY_LOAD;
   
   ALTER TABLE partsupp modify `PS_COMMENT` VARCHAR(199) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE partsupp SECONDARY_ENGINE=RAPID;
   ALTER TABLE partsupp SECONDARY_LOAD;
   
   ALTER TABLE customer modify `C_NAME` VARCHAR(25) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE customer modify `C_ADDRESS` VARCHAR(40) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE customer modify `C_MKTSEGMENT` CHAR(10) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE customer modify `C_COMMENT` VARCHAR(117) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE customer SECONDARY_ENGINE=RAPID;
   ALTER TABLE customer SECONDARY_LOAD;
   
   ALTER TABLE orders modify `O_ORDERSTATUS` CHAR(1) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE orders modify `O_ORDERPRIORITY` CHAR(15) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE orders modify `O_CLERK` CHAR(15) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE orders SECONDARY_ENGINE=RAPID;
   ALTER TABLE orders SECONDARY_LOAD;
   
   ALTER TABLE lineitem modify `L_RETURNFLAG` CHAR(1) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE lineitem modify `L_LINESTATUS` CHAR(1) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE lineitem modify `L_SHIPINSTRUCT` CHAR(25) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE lineitem modify `L_SHIPMODE` CHAR(10) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE lineitem modify `L_COMMENT` VARCHAR(44) NOT NULL COMMENT 'RAPID_COLUMN=ENCODING=SORTED';
   ALTER TABLE lineitem SECONDARY_ENGINE=RAPID;
   ALTER TABLE lineitem SECONDARY_LOAD;

5. Verify that the tables are loaded in the HeatWave cluster by querying LOAD_STATUS data from the HeatWave Performance Schema tables. Loaded tables have an AVAIL_RPDGSTABSTATE load status.

   MySQL>SQL> USE performance_schema;
   MySQL>SQL> SELECT NAME, LOAD_STATUS FROM rpd_tables,rpd_table_id
              WHERE rpd_tables.ID = rpd_table_id.ID;
   +------------------------------+---------------------+
   | NAME                         | LOAD_STATUS         |
   +------------------------------+---------------------+
   | tpch.supplier                | AVAIL_RPDGSTABSTATE |
   | tpch.partsupp                | AVAIL_RPDGSTABSTATE |
   | tpch.orders                  | AVAIL_RPDGSTABSTATE |
   | tpch.lineitem                | AVAIL_RPDGSTABSTATE |
   | tpch.customer                | AVAIL_RPDGSTABSTATE |
   | tpch.nation                  | AVAIL_RPDGSTABSTATE |
   | tpch.region                  | AVAIL_RPDGSTABSTATE |
   | tpch.part                    | AVAIL_RPDGSTABSTATE |
   +------------------------------+---------------------+

This topic describes how to query data in the HeatWave cluster.

1. SSH into the Compute instance using the public IP address of the Compute instance.

   ssh opc@computeInstancePublicIP

2. Start MySQL Shell and connect to the MySQL DB System's endpoint:

   shell> mysqlsh Username@IPAddressOfMySQLDBSystemEndpoint

   MySQL Shell opens in JavaScript execution mode by default.

   MySQL>JS>

3. Change the MySQL Shell execution mode to SQL:

   MySQL>JS> \sql

4. Change to the tpch database.

   MySQL>SQL> USE tpch;
   Default schema set to `tpch`.Fetching table and column names from `tpch` for 
   auto-completion... Press ^C to stop.

5. Before running a query, use EXPLAIN to verify that the query can be offloaded to the HeatWave cluster. For example:

   MySQL>SQL> EXPLAIN SELECT SUM(l_extendedprice * l_discount) AS revenue 
              FROM lineitem WHERE l_shipdate >= date '1994-01-01'\G
   *************************** 1. row ***************************
              id: 1
     select_type: SIMPLE
           table: lineitem
      partitions: NULL
            type: ALL
   possible_keys: NULL
             key: NULL
         key_len: NULL
             ref: NULL
            rows: 56834662
        filtered: 33.33
           Extra: Using where; Using secondary engine RAPID

   If the query can be offloaded, the Extra column in the EXPLAIN output reports "Using secondary engine RAPID".
6. After verifying that the query can be offloaded, run the query and note the execution time.

   MySQL>SQL> SELECT SUM(l_extendedprice * l_discount) AS revenue 
   FROM lineitem WHERE l_shipdate >= date '1994-01-01';
   +------------------+
   | revenue          |
   +------------------+
   | 82752894454.9036 |
   +------------------+
   1 row in set (0.04 sec)

7. To compare the HeatWave execution time with MySQL DB System execution time, disable the use_secondary_engine variable to see how long it takes to run the same query on the MySQL DB System. For example:

   MySQL>SQL> SET SESSION use_secondary_engine=OFF;
   MySQL>SQL> SELECT SUM(l_extendedprice * l_discount) AS revenue FROM lineitem WHERE l_shipdate >= date '1994-01-01';
   +------------------+
   | revenue          |
   +------------------+
   | 82752894454.9036 |
   +------------------+
   1 row in set (24.20 sec)