# calcViewAnalyzer

> Command: `calcViewAnalyzer`  
> Category: **Analysis Tools**  
> Status: Early Access

## Description

Analyze calculation view performance, providing detailed metrics about calculation views in your SAP HANA database. It helps identify performance bottlenecks and understand calculation view configurations.

### What is a Calculation View?

A **calculation view** is a virtual object in SAP HANA that defines how to combine and transform data from multiple sources. It's a powerful tool for creating reusable data models without creating physical tables.

Calculation views contain:

- **Data Source Nodes**: Read data from tables or other views
- **Join Nodes**: Combine data from multiple sources
- **Aggregation Nodes**: Group and summarize data
- **Union Nodes**: Combine data from disparate structures
- **SQL Script Nodes**: Execute complex logic
- **Output**: Final structure exposed to applications

Think of them as "smart queries" that you define once and reuse everywhere.

### How Are Calculation Views Used?

**Business Intelligence & Analytics:**

- **Data Warehousing**: Create data marts and dimensional models
- **Star Schema Implementation**: Combine facts with dimensions for reporting
- **KPI Calculation**: Define complex business metrics that users need
- **Aggregated Data**: Pre-aggregate high-volume data for faster reporting
- **Data Marts**: Create subject-specific views for different teams

**Application Integration:**

- **Application Views**: Provide applications only the data they need
- **Master Data Management**: Create single source of truth for customer, product, vendor data
- **Unified Views**: Present consistent data regardless of physical storage
- **API Layer**: Expose data through well-defined interfaces
- **Semantic Layer**: Add business logic and metadata on top of raw tables

**Cross-Functional Usage:**

- Finance teams use calc views to define GL balances, profit & loss, cash flow
- Sales teams use calc views for pipeline, forecast, quota calculations
- HR teams use calc views for headcount, compensation, turnover metrics
- Supply Chain teams use calc views for inventory, demand, fulfillment data

### Real-World Example

Without Calculation Views:

```text
Every analyst writes individual queries to:
  - Join CUSTOMERS, ORDERS, ORDER_ITEMS, PRODUCTS
  - Apply business rules (filter inactive customers, exclude test orders)
  - Aggregate to get sales per customer

Result: Inconsistent definitions, maintenance nightmare, performance issues
```

With Calculation Views:

```text
Define once: ORDER_SUMMARY view that:
  - Joins all necessary tables
  - Applies consistent business rules
  - Pre-aggregates data

Benefit: Analysts use the view, guaranteed consistency, better performance
```

### What Will calcViewAnalyzer Tell You?

The `calcViewAnalyzer` command provides insights into calculation view structure, performance, and issues:

#### View Metadata

- **Schema & Name**: Location of the view
- **View Type**: GRAPHICAL (visual designer) or SQL SCRIPT (code-based)
- **Description**: Purpose and usage documentation
- **Creation Date**: When the view was created
- **Last Modified**: When it was last changed

#### Validity & Status

- **IS_VALID**: Whether the view is valid (dependencies still exist)
- **Invalid References**: Which objects (tables, views) it depends on
- **Circular Dependencies**: If this view references something that references it
- **Build Status**: Whether the view needs to be recompiled

#### Structure & Components

- **Data Sources**: Which tables/views does it read from
- **Join Count**: How many tables are being joined
- **Union Count**: If it combines data from different structures
- **Aggregation Level**: What data is being grouped
- **SQL Script Complexity**: For script-based views

#### Performance Metrics

- **Execution Time**: How long queries using this view take
- **Cache Status**: Whether results are cached
- **Memory Usage**: How much RAM the view consumes
- **Row Count**: How many rows does it return
- **Join Effectiveness**: How many rows are filtered/aggregated

#### Potential Issues

- **Unused Views**: Views that nothing is using
- **Cyclic References**: Views that reference themselves indirectly
- **Missing Dependencies**: Tables deleted but view still references
- **Excessive Joins**: Too many tables joined together
- **Performance Bottlenecks**: Expensive operations in the view
- **Documentation Issues**: Missing descriptions or comments

### Why You'd Want This Analysis

**Performance Optimization:**

```bash
# Find slow-performing calculation views
hana-cli calcViewAnalyzer --schema ANALYTICS --metrics
```

Identify views taking too long to execute so you can:

- Add aggregation levels
- Push filters down to data sources
- Pre-aggregate frequently-used calculations
- Add indexes to underlying tables
- Denormalize if needed

**Maintenance & Cleanup:**

```bash
# Understand view dependencies before deletion
hana-cli calcViewAnalyzer --view OLD_REVENUE_VIEW
```

Before deleting a view, know:

- Which applications use it
- Which other views depend on it
- What data it provides

**Documentation & Governance:**

```bash
# Document all views and their structure
hana-cli calcViewAnalyzer --schema PRODUCTION
```

Create:

- Data dictionary
- Data lineage documentation
- Impact analysis before schema changes
- Compliance mapping for data governance

**Problem Investigation:**

```bash
# Understand why a report is slow
hana-cli calcViewAnalyzer --view SALES_SUMMARY --metrics
```

Find:

- Missing filters causing full scans
- Excessive joins slowing queries
- Aggregations causing memory issues
- Inefficient SQL logic

**Migration Planning:**

```bash
# Assess complexity before system migration
hana-cli calcViewAnalyzer --schema SOURCE_SYSTEM
```

Understand:

- How many views need to be migrated
- Dependencies between views
- Complexity of each view
- Which views are critical vs. optional

### Key Metrics Explained

#### Valid vs. Invalid

- Valid = All dependencies exist, view will work
- Invalid = Missing tables/views, view won't work

#### Complexity Score

- Simple (1-3 nodes) = Easy to understand and maintain
- Medium (4-6 nodes) = Moderate complexity
- Complex (7+ nodes) = May need refactoring

#### Execution Time

- < 1 second = Fast
- 1-5 seconds = Acceptable
- > 5 seconds = Slow, needs optimization

#### Join Count

- 2-3 joins = Good
- 4-6 joins = Moderate
- 7+ joins = Complex, potential performance issue

### Benefits by Role

**BI Developers**: Understand view structure and identify optimization opportunities

**Database Administrators**: Monitor view validity, dependencies, and performance

**Data Architects**: Plan data models and migration strategies

**Performance Engineers**: Identify bottlenecks and optimization targets

**Compliance Officers**: Document data lineage and access paths

**Business Analysts**: Understand what data is available through which views

## Syntax

```bash
hana-cli calcViewAnalyzer [schema] [view]
```

## Aliases

- `cva`
- `analyzeCalcView`
- `calcview`

## Command Diagram

```mermaid
graph TD
    Start([hana-cli calcViewAnalyzer]) --> Input{Input Parameters}
    Input -->|schema/view| Connect[Create DB connection]

    Connect --> Query[Query SYS.VIEWS<br/>where VIEW_TYPE = 'CALC']
    Query --> Limit{Apply --limit?}
    Limit -->|yes| Limited[Append LIMIT clause]
    Limit -->|no| Main[Run base query]

    Limited --> Metrics{--metrics enabled?}
    Main --> Metrics
    Metrics -->|yes| Extra[Run additional query<br/>sorted by CREATE_TIME DESC]
    Metrics -->|no| Output[Render main output table]

    Extra --> Output
    Output --> Complete([Command Complete])

    style Start fill:#0092d1
    style Complete fill:#2ecc71
    style Input fill:#f39c12
    style Limit fill:#f39c12
    style Metrics fill:#f39c12
```

## Parameters

### Positional Arguments

| Parameter | Type   | Description                                  |
|-----------|--------|----------------------------------------------|
| `schema`  | string | Schema filter. Default: `**CURRENT_SCHEMA**` |
| `view`    | string | View filter. Default: `*`                    |

### Options

| Option      | Alias | Type    | Default              | Description                          |
|-------------|-------|---------|----------------------|--------------------------------------|
| `--view`    | `-v`  | string  | `*`                  | Database view                        |
| `--schema`  | `-s`  | string  | `**CURRENT_SCHEMA**` | Schema                               |
| `--metrics` | `-m`  | boolean | `false`              | Include detailed performance metrics |
| `--limit`   | `-l`  | number  | `100`                | Limit results                        |
| `--profile` | `-p`  | string  | -                    | CDS Profile                          |

### Connection Parameters

| Option    | Alias | Type    | Default | Description                                      |
|-----------|-------|---------|---------|--------------------------------------------------|
| `--admin` | `-a`  | boolean | `false` | Connect via admin (default-env-admin.json)       |
| `--conn`  | -     | string  | -       | Connection filename to override default-env.json |

### Troubleshooting

| Option             | Alias     | Type    | Default | Description            |
|--------------------|-----------|---------|---------|------------------------|
| `--disableVerbose` | `--quiet` | boolean | `false` | Disable verbose output |
| `--debug`          | `-d`      | boolean | `false` | Enable debug output    |

For the runtime-generated option list, run:

```bash
hana-cli calcViewAnalyzer --help
```

## Examples

### Basic Usage

```bash
hana-cli calcViewAnalyzer
```

List calculation views in the current schema.

### Filter by Schema and View Pattern

```bash
hana-cli calcViewAnalyzer --schema MYSCHEMA --view SALES_%
```

Return calculation views in `MYSCHEMA` that match `SALES_%`.

### Use Alias with Limit

```bash
hana-cli cva -s SYS -v "*" -l 50
```

Use the short alias and cap result rows.

### Include Metrics Output

```bash
hana-cli analyzeCalcView --schema ANALYTICS --metrics
```

Run the additional metrics result set along with the base output.

## Related Commands

- `views` - List database views
- `erdDiagram` - Generate schema relationship diagrams

See the [Commands Reference](../all-commands.md) for other commands in this category.

## See Also

- [Category: Analysis Tools](..)
- [All Commands A-Z](../all-commands.md)