ParquetFilter.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Justin Sing $
// $Authors: Justin Sing $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/OpenMSConfig.h>
#include <OpenMS/DATASTRUCTURES/String.h>
 
#include <vector>
 
namespace OpenMS
{
  enum class ColumnType
  {
    INT,
    STRING
  };
 
  struct OPENMS_DLLAPI Condition
  {
    String column;
    String op;
    std::vector<String> values;
    ColumnType type{ColumnType::INT};
  };
 
  struct OPENMS_DLLAPI FilterExpression
  {
    std::vector<Condition> conditions;
    std::vector<String> connectors; // "AND" / "OR"
 
    bool empty() const;
  };
 
  class OPENMS_DLLAPI ParquetFilter
  {
  public:
    ParquetFilter() = default;
    ParquetFilter(const ParquetFilter&) = default;
 
    ParquetFilter& andNext();
 
    ParquetFilter& orNext();
 
    ParquetFilter& eq(const String& column, Int64 value);
 
    ParquetFilter& ne(const String& column, Int64 value);
 
    ParquetFilter& lt(const String& column, Int64 value);
 
    ParquetFilter& le(const String& column, Int64 value);
 
    ParquetFilter& gt(const String& column, Int64 value);
 
    ParquetFilter& ge(const String& column, Int64 value);
 
    ParquetFilter& in(const String& column, const std::vector<Int64>& values);
 
    ParquetFilter& eq(const String& column, const String& value);
 
    ParquetFilter& ne(const String& column, const String& value);
 
    ParquetFilter& lt(const String& column, const String& value);
 
    ParquetFilter& le(const String& column, const String& value);
 
    ParquetFilter& gt(const String& column, const String& value);
 
    ParquetFilter& ge(const String& column, const String& value);
 
    ParquetFilter& in(const String& column, const std::vector<String>& values);
 
    const FilterExpression& expression() const;
 
    bool empty() const;
 
    static FilterExpression merge(const FilterExpression& lhs,
                                  const FilterExpression& rhs,
                                  const String& connector = "AND");
 
  private:
    ParquetFilter& addCondition_(const String& column,
                                 const String& op,
                                 ColumnType type,
                                 const std::vector<String>& values);
 
    FilterExpression expr_;
    String next_connector_{"AND"};
  };
 
  class OPENMS_DLLAPI ParquetFilterBuilder
  {
  public:
    ParquetFilterBuilder() = default;
    ParquetFilterBuilder(const ParquetFilterBuilder&) = default;
 
    ParquetFilterBuilder& andNext();
 
    ParquetFilterBuilder& orNext();
 
    ParquetFilterBuilder& eq(const String& column, Int64 value);
 
    ParquetFilterBuilder& ne(const String& column, Int64 value);
 
    ParquetFilterBuilder& lt(const String& column, Int64 value);
 
    ParquetFilterBuilder& le(const String& column, Int64 value);
 
    ParquetFilterBuilder& gt(const String& column, Int64 value);
 
    ParquetFilterBuilder& ge(const String& column, Int64 value);
 
    ParquetFilterBuilder& in(const String& column, const std::vector<Int64>& values);
 
    ParquetFilterBuilder& eq(const String& column, const String& value);
 
    ParquetFilterBuilder& ne(const String& column, const String& value);
 
    ParquetFilterBuilder& lt(const String& column, const String& value);
 
    ParquetFilterBuilder& le(const String& column, const String& value);
 
    ParquetFilterBuilder& gt(const String& column, const String& value);
 
    ParquetFilterBuilder& ge(const String& column, const String& value);
 
    ParquetFilterBuilder& in(const String& column, const std::vector<String>& values);
 
    const ParquetFilter& filter() const;
 
    bool empty() const;
 
  private:
    ParquetFilter filter_;
  };
} // namespace OpenMS