VisActor VBI
  • 한국어

      • Having

      basic

      기본 Having 예제 - 집계 결과 필터링

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-basic",
  "description": "기본 Having 예제 - 집계 결과 필터링",
  "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

      BETWEEN 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-between",
  "description": "BETWEEN 연산자를 사용하는 Having 예제",
  "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

      배열 IN 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-in-array",
  "description": "배열 IN 연산자를 사용하는 Having 예제",
  "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

      단일 값 IN 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-in-single",
  "description": "단일 값 IN 연산자를 사용하는 Having 예제",
  "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

      IS NOT NULL 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-is-not-null",
  "description": "IS NOT NULL 연산자를 사용하는 Having 예제",
  "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

      IS NULL 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-is-null",
  "description": "IS NULL 연산자를 사용하는 Having 예제",
  "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

      MAX 집계 함수를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-max",
  "description": "MAX 집계 함수를 사용하는 Having 예제",
  "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

      MIN 집계 함수를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-min",
  "description": "MIN 집계 함수를 사용하는 Having 예제",
  "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

      여러 조건(AND/OR)을 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-multi",
  "description": "여러 조건(AND/OR)을 사용하는 Having 예제",
  "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

      NOT BETWEEN 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-between",
  "description": "NOT BETWEEN 연산자를 사용하는 Having 예제",
  "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

      단일 값 NOT IN 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-in-single",
  "description": "단일 값 NOT IN 연산자를 사용하는 Having 예제",
  "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

      NOT IN 연산자를 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-not-in",
  "description": "NOT IN 연산자를 사용하는 Having 예제",
  "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

      OR 조건을 사용하는 Having 예제

      import { VQueryResultRender } from '@components'

export default () => {
  const vqueryConfig = {
  "datasetId": "having-or",
  "description": "OR 조건을 사용하는 Having 예제",
  "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} />
}