VisActor VBI
  • Deutsch

      • Having

      basic

      Einfaches Having-Beispiel - aggregierte Ergebnisse filtern

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-basic",
  "description": "Einfaches Having-Beispiel - aggregierte Ergebnisse filtern",
  "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-Beispiel mit BETWEEN-Operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-between",
  "description": "Having-Beispiel mit 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-Beispiel mit Array-IN-Operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-in-array",
  "description": "Having-Beispiel mit 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-Beispiel mit einzelnem IN-Wert

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-in-single",
  "description": "Having-Beispiel mit einzelnem IN-Wert",
  "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-Beispiel mit IS NOT NULL-Operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-is-not-null",
  "description": "Having-Beispiel mit 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-Beispiel mit IS NULL-Operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-is-null",
  "description": "Having-Beispiel mit 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-Beispiel mit MAX-Aggregatfunktion

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-max",
  "description": "Having-Beispiel mit MAX-Aggregatfunktion",
  "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-Beispiel mit MIN-Aggregatfunktion

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-min",
  "description": "Having-Beispiel mit MIN-Aggregatfunktion",
  "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-Beispiel mit mehreren Bedingungen (AND/OR)

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-multi",
  "description": "Having-Beispiel mit mehreren Bedingungen (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-Beispiel mit NOT BETWEEN-Operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-between",
  "description": "Having-Beispiel mit 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-Beispiel mit einzelnem NOT IN-Wert

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-in-single",
  "description": "Having-Beispiel mit einzelnem NOT IN-Wert",
  "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-Beispiel mit NOT IN-Operator

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-in",
  "description": "Having-Beispiel mit 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-Beispiel mit OR-Bedingungen

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-or",
  "description": "Having-Beispiel mit OR-Bedingungen",
  "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} />
}