data

Builds command to export data and push it to run in background cluster

Code
Parameters
----------
prep_dfs : str
nonprep_dfs : str
start_date : str
end_date : str
as_of_date : str

Returns
-------
success : bool
   True if completely successful, false if not
messages : list of str
   List of human-readable error messages

Uses a saved JSON Report to return a custom JSON object, given required parameters.

Code
Parameters
----------
report_name : str
params : dict

Returns
-------
json : str

Get Available Dashboards returns available dashboards for BriteCore and BriteQuote. For the agent portal it will return only dashboards the user has been granted access to based on user permissions. For the employee portal (BriteCore) it will include stock dashboards and embedded ones.

Code
Parameters
----------
module : str, optional
    The module to use, can be britequote or britecore (defaults to britequote).

Returns
-------
success : bool
   True if completely successful, false if not
messages : list of str
   List of human-readable error messages
data : dict
   List of dicts with available dashboards based on user permission
    [
        {
            "id": 'agency_exp',
            "title": 'Agency Experience',
            "path": 'ae_dashboard',
            "permission": {
                "value": "agency/stats/ae_dashboard",
                "access": "r"
            }
        },
        {
            "id": 'csr_dash',
            "title": 'CSR Dashboard',
            "path": 'csr_dashboard',
            "permission": {
                "value": "agency/stats/csr_dashboard",
                "access": "r"
            }
        },
    ]

Fetch the most recent successful BriteData execution for a migration.

Code
Looks up the latest SUCCEEDED ``report_processes`` row for the given
``britedata_migration_reports`` id, downloads the output file from the
carrier S3 bucket (resolved from the carrier's BriteCore config), parses
it, and returns up to ``sample_size`` rows along with the report
parameters.

Parameters
----------
migration_id : str
    UUID of the ``britedata_migration_reports`` row.
sample_size : int, optional
    Maximum sample rows to return (default 500). Capped server-side
    regardless to keep response payloads bounded.

Returns
-------
data : dict
    Envelope with ``parameters``, ``sample_rows``, ``total_rows``,
    ``sample_size``, and -- on any failure path -- a ``reason``
    field (``no_s3_bucket`` | ``no_successful_execution`` |
    ``file_expired`` | ``invalid_files_url`` | ``s3_error`` |
    ``file_too_large`` | ``unsupported_format`` | ``parse_error``).

Return the unified coverage schema across every policy type.

Code
Aggregates duplicate coverage names so each entry lists every category
field, scheduled-item header, and (optionally) question label observed
anywhere in the carrier.

Parameters
----------
include_questions : bool, optional
    Include question labels (default True).

Get Logical Catalog returns the metadata for logical SQL catalog.

Code
Returns
-------
success : bool
   True if completely successful, false if not
messages : list of str
   List of human-readable error messages
data : dict
   Logical catalog metadata

Return SHOW CREATE PROCEDURE output for one or more procedures.

Code
Always list-based; ``[name]`` is the single-name case. Missing
procedures get ``success=False`` per item rather than failing the
whole batch.

Parameters
----------
procedure_names : list of str
    Non-empty list of procedure names.

Returns
-------
data : list of dict
    Per-procedure result objects in the requested order.

Return report examples grouped by category with parameters and referenced views extracted from each sheet's SQL.

Code
Parameters
----------
category : str, optional
    Restrict the response to a single Report Category name.
include_sql : bool, optional
    Include each sheet's raw ``sql_query`` (default True).
max_reports_per_category : int, optional
    Cap reports per category (default unlimited).

Returns
-------
data : dict
    ``{"categories": {<category>: [<report>, ...], ...}}``

Return SHOW CREATE VIEW output for one or more views.

Code
Always list-based; ``[name]`` is the single-name case. The
``m_*`` -> ``t_*`` mapping is applied server-side so callers always
work with public names. Missing views get ``success=False`` per item.

Parameters
----------
view_names : list of str
    Non-empty list of view names.

Returns
-------
data : list of dict
    Per-view result objects in the requested order.

List all stored procedures in the carrier database.

Code
Returns
-------
data : list of dict
    ``[{"procedure_name": "build_measure"}, ...]`` ordered by name.

List all report categories.

Code
Returns
-------
data : list of dict
    ``[{"name": "Financial"}, ...]`` ordered by name.

Preview SQL Check validates.

Code
Parameters
----------
query : str
   The SQL query to preview
params : dict, optional
   Dictionary of parameters to use in the query, when using measure tables
   will require AsOfDate or StartDate and EndDate

Returns
-------
success : bool
   True if completely successful, false if not
messages : list of str
   List of human-readable error messages

Return the MySQL execution plan and index metadata for a saved report's sheet WITHOUT executing its query.

Code
Report-centric by design: only a report already saved in the system can
be analyzed (there is no arbitrary-SQL mode). Requires READ access to
the report.

Parameters
----------
report_id : str
   The saved report to analyze. Required.
sheet_id : str, optional
   Which sheet of the report to analyze; defaults to the first sheet.
params : dict, optional
   ``<<$Name>>`` parameter values (e.g. AsOfDate, or StartDate and
   EndDate), same shape as run_report. Required when the report's SQL
   references parameters that have no default.

Returns
-------
success : bool
executed_sql : str
   The final SQL that was explained (measures rewritten, params
   substituted, LIMIT and MAX_EXECUTION_TIME hint injected).
plan_tree : str or null
   EXPLAIN FORMAT=TREE output (null on MySQL < 8.0.16).
plan_json : dict or null
   EXPLAIN FORMAT=JSON output, verbatim from MySQL.
tables : list of dict
   Per real table the plan touches: name, rows_estimate, data_length,
   index_length, indexes (index rows from information_schema).
built_measures : list of str
   Any ``m_*`` measures this request materialized (see Notes).
warnings : list of str

Notes
-----
The report's SELECT is never executed. But this is not free of writes:
referencing an ``m_*`` measure not yet built for the requested window
triggers a real materialization (``CREATE TABLE ... AS SELECT``, the same
build ``run_report`` does and gated by the same READ access) before the
plan can be produced -- potentially minutes for a wide range measure. Such
builds are reported in ``built_measures``. The optimizer may also evaluate
constant scalar subqueries while planning.

Preview SQL Result validates and runs a SQL query, capped at 10,000 rows.

Code
Parameters
----------
query : str
   The SQL query to preview
params : dict, optional
   Dictionary of parameters to use in the query, when using measure tables
   will require AsOfDate or StartDate and EndDate
include_totals_row : bool, optional
   When true, append a computed grand-total row to the result and tag it
   via row_meta[].is_total. Default false.

Returns
-------
success : bool
   True if completely successful, false if not
messages : list of str
   List of human-readable error messages
error_code : str, optional
   Present only on failure. A stable identifier for *why* the query was
   refused, so non-human callers do not have to pattern-match the prose in
   ``messages``. Messages may be reworded freely; codes are contract.

   Faults in the submitted query -- deterministic, so retrying the same
   query is pointless: ``SQL_PARSE_ERROR``, ``SQL_DML_DDL_NOT_ALLOWED``,
   ``SQL_DISALLOWED_FUNCTION``, ``SQL_UNKNOWN_TABLE``,
   ``SQL_DATED_MEASURE_TABLE`` (the query names a dated measure table,
   which measure cleanup drops; query the measure instead),
   ``SQL_MISSING_PARAMS``, ``SQL_MULTIPLE_STATEMENTS``,
   ``SQL_NOT_CATALOG_QUERY``, ``SQL_EXECUTION_TIMEOUT`` (the query is too
   expensive to preview, though it can still be built and downloaded), and
   ``SQL_EXECUTION_ERROR``.

   Faults on the server -- transient, and the same query may succeed on a
   later attempt: ``SQL_EXECUTION_UNAVAILABLE`` (lost connection, deadlock,
   lock wait, resource exhaustion) and ``SQL_CATALOG_UNAVAILABLE`` (the
   logical catalog could not be read, so table names could not be
   validated). Callers must not report these as caller mistakes.
num_rows : int
   Number of rows in the result
columns : list of dict
     List of columns in the result, each dict with name and type
data : list of list
     List of rows in the result, each row is a list of values

Notes
-----
Queries are capped at 10,000 rows and a 180-second server-side execution
time, injected as a MySQL ``MAX_EXECUTION_TIME`` optimizer hint.

Only read-only catalog queries are accepted. Validation rejects DML/DDL and
the functions listed in ``DISALLOWED_FUNCTIONS`` (``SLEEP``, ``BENCHMARK``,
advisory-lock and replication-wait functions, ``LOAD_FILE``). Multiple
statements are refused separately, when the query is run rather than during
validation.

Comments -- including MySQL executable comments (``/*!...*/``) -- and
user-supplied optimizer hints (``/*+ ... */``) are stripped from the parsed
statement rather than rejected, so neither can carry SQL through to the
database. A caller's own ``MAX_EXECUTION_TIME`` value is read before the
hint is dropped, so it still tightens the bound.

Validate a SQL expression for use as a parameter default.

Code
This endpoint validates that a SQL expression is syntactically valid MySQL SQL
and does not contain dangerous operations that could lead to SQL injection.
If valid, it also evaluates the expression and validates the result matches
the expected parameter type.

Parameters
----------
expression : str
    SQL expression string to validate
param_type : str
    Parameter type (Date, DateTime, String, Number, Enum, UUID) for type validation

Returns
-------
success : bool
    True if expression is valid, False otherwise
data : dict
    Contains 'evaluated_value' if expression is valid and could be evaluated,
    and 'type_valid' indicating if the value matches the expected type
messages : list of str
    List of error messages if validation fails