VisActor VBI
  • English

      • Having

      basic

      Basic Having Example - filter aggregated results

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-basic",
  "description": "Basic Having Example - filter aggregated results",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": ">",
          "value": 5000
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      between

      Having Example with BETWEEN operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-between",
  "description": "Having Example with BETWEEN operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": "between",
          "value": [
            5000,
            12000
          ]
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      in-array

      Having Example with array IN operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-in-array",
  "description": "Having Example with array IN operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "department",
          "aggr": {
            "func": "min"
          },
          "op": "in",
          "value": [
            "HR",
            "Engineering"
          ]
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      in-single

      Having Example with single value IN operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-in-single",
  "description": "Having Example with single value IN operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "department",
          "aggr": {
            "func": "min"
          },
          "op": "in",
          "value": "HR"
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      is-not-null

      Having Example with IS NOT NULL operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-is-not-null",
  "description": "Having Example with IS NOT NULL operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": "is not null"
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": null
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": null
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      is-null

      Having Example with IS NULL operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-is-null",
  "description": "Having Example with IS NULL operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": "is null"
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": null
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": null
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      max

      Having Example with MAX aggregate function

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-max",
  "description": "Having Example with MAX aggregate function",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Max Salary",
        "aggr": {
          "func": "max"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "max"
          },
          "op": "=",
          "value": 9000
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      min

      Having Example with MIN aggregate function

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-min",
  "description": "Having Example with MIN aggregate function",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Min Salary",
        "aggr": {
          "func": "min"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "min"
          },
          "op": "=",
          "value": 5000
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      multi-conditions

      Having Example with multiple conditions (AND/OR)

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-multi",
  "description": "Having Example with multiple conditions (AND/OR)",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      },
      {
        "field": "salary",
        "alias": "Count",
        "aggr": {
          "func": "count"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": ">",
          "value": 5000
        },
        {
          "field": "salary",
          "aggr": {
            "func": "count"
          },
          "op": ">",
          "value": 1
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      not-between

      Having Example with NOT BETWEEN operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-between",
  "description": "Having Example with NOT BETWEEN operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": "not between",
          "value": [
            5000,
            12000
          ]
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      not-in-single

      Having Example with single value NOT IN operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-in-single",
  "description": "Having Example with single value NOT IN operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "department",
          "aggr": {
            "func": "min"
          },
          "op": "not in",
          "value": "HR"
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      not-in

      Having Example with NOT IN operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-in",
  "description": "Having Example with NOT IN operator",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "and",
      "conditions": [
        {
          "field": "department",
          "aggr": {
            "func": "min"
          },
          "op": "not in",
          "value": [
            "Marketing"
          ]
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}

      or-conditions

      Having Example with OR conditions

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-or",
  "description": "Having Example with OR conditions",
  "vquery": {
    "select": [
      "department",
      {
        "field": "salary",
        "alias": "Total Salary",
        "aggr": {
          "func": "sum"
        }
      }
    ],
    "groupBy": [
      "department"
    ],
    "having": {
      "op": "or",
      "conditions": [
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": ">",
          "value": 15000
        },
        {
          "field": "salary",
          "aggr": {
            "func": "sum"
          },
          "op": "<",
          "value": 5000
        }
      ]
    }
  },
  "dataset": [
    {
      "id": 1,
      "name": "Alice",
      "age": 25,
      "department": "HR",
      "salary": 5000
    },
    {
      "id": 2,
      "name": "Bob",
      "age": 30,
      "department": "Engineering",
      "salary": 8000
    },
    {
      "id": 3,
      "name": "Charlie",
      "age": 35,
      "department": "Engineering",
      "salary": 9000
    },
    {
      "id": 4,
      "name": "David",
      "age": 40,
      "department": "HR",
      "salary": 6000
    },
    {
      "id": 5,
      "name": "Eve",
      "age": 22,
      "department": "Marketing",
      "salary": 4000
    }
  ],
  "schema": [
    {
      "name": "id",
      "type": "number"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "age",
      "type": "number"
    },
    {
      "name": "department",
      "type": "string"
    },
    {
      "name": "salary",
      "type": "number"
    }
  ]
}

  return <VQueryResultRender vqueryConfig={vqueryConfig} />
}