clausesBuilder.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal
 
  This file is part of ANCH Framework.
 
  ANCH Framework is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  ANCH Framework is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public License
  along with ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
 
#include <string>
#include <list>
#include <sstream>
#include <functional>
#include <vector>
#include <optional>
 
 
#include "sql/builder/sqlQuery.hpp"
 
 
namespace anch {
  namespace sql {
 
    class SelectBuilder;
    class FromBuilder;
    class ClausesBuilder;
    extern ClausesBuilder clauses();

    using ClauseMaker = std::function<std::string(const std::string&)>;

    template<typename T>
    using ValueChecker = std::function<std::optional<std::string>(const T&)>;

    using ClausesProvider = std::function<const anch::sql::ClausesBuilder&()>;

    template<typename T>
    std::optional<std::string> isValidValue(T& value);

    class ClausesBuilder {
      friend ClausesBuilder anch::sql::clauses();
      friend anch::sql::SelectBuilder;
      friend anch::sql::FromBuilder;
 
      // Attributes +
    private:
      std::ostringstream _buffer;

      std::list<std::string> _values;

      bool _firstClause;
      // Attributes -
 
 
      // Constructors +
    private:
      ClausesBuilder();
 
    public:
      ClausesBuilder(const ClausesBuilder& other);
 
    private:
      template<typename T>
      ClausesBuilder(ClauseMaker clause, const T& value);
 
      // /*!
      //  * \ref ClausesBuilder constructor.\n
      //  * This constructor will try to add a first clause if value is valid. Value will
      //  * be validated with \c SQL::isValidValue function.\n
      //  * This constructor can be used to add 'EXISTS' clause.
      //  *
      //  * \tparam T the value type
      //  *
      //  * \param clause the clause maker
      //  * \param value the value
      //  * \param check the value checker to use
      //  */
      // template<typename T>
      // ClausesBuilder(ClauseMaker clause, const T& value, ValueChecker<T> checker);
 
      // /*!
      //  * \ref ClausesBuilder constructor.\n
      //  * This constructor will try to add a first clause if value is valid. Value will
      //  * be validated with \c SQL::isValidValue function.\n
      //  * This constructor can be used to add 'EXISTS' clause.
      //  *
      //  * \tparam T the value type
      //  *
      //  * \param clause the clause maker
      //  * \param value the value
      //  */
      // template<typename T>
      // ClausesBuilder(const std::string& column, ClauseMaker clause, const T& value);
 
      // /*!
      //  * \ref ClausesBuilder constructor.\n
      //  * This constructor will try to add a first clause if value is valid. Value will
      //  * be validated with \c SQL::isValidValue function.\n
      //  * This constructor can be used to add 'EXISTS' clause.
      //  *
      //  * \tparam T the value type
      //  *
      //  * \param clause the clause maker
      //  * \param value the value
      //  * \param check the value checker to use
      //  */
      // template<typename T>
      // ClausesBuilder(const std::string& column, ClauseMaker clause, const T& value, ValueChecker<T> checker);
      // Constructors -
 
      // Destructor +
    public:
      virtual ~ClausesBuilder();
      // Destructor -
 
 
      // SQL commands +
    public:
      // No check no prepared statement values +
      ClausesBuilder& field(const std::string& column);

      ClausesBuilder& NOT(const std::string& clauses);

      ClausesBuilder& isNull();

      ClausesBuilder& isNotNull();

      ClausesBuilder& notEquals();

      ClausesBuilder& equals();

      ClausesBuilder& notExists(const anch::sql::SelectBuilder& query);

      ClausesBuilder& exists(const anch::sql::SelectBuilder& query);

      template<typename T>
      ClausesBuilder& in(const std::vector<T>& values); // \todo list vector ?

      template<typename T>
      ClausesBuilder& notIn(const std::vector<T>& values); // \todo list vector ?

      ClausesBuilder& in(const anch::sql::SQLQuery& query);

      ClausesBuilder& notIn(const anch::sql::SQLQuery& query);

      ClausesBuilder& in(const anch::sql::SelectBuilder& query);

      ClausesBuilder& notIn(const anch::sql::SelectBuilder& query);

      ClausesBuilder& greater();

      ClausesBuilder& greaterEquals();

      ClausesBuilder& lesser();

      ClausesBuilder& lesserEquals();

      ClausesBuilder& like();

      ClausesBuilder& notLike();

      ClausesBuilder& between();

      ClausesBuilder& notBetween();

      ClausesBuilder& AND(); // \todo operator ...

      ClausesBuilder& OR(); // \todo operator ...
      // No check no prepared statement values -
 
      // Check and add value to prepared statement +
      ClausesBuilder& AND(anch::sql::ClausesProvider clauses);

      template<typename T>
      ClausesBuilder& AND(anch::sql::ClauseMaker clause, T& value, anch::sql::ValueChecker<T> checker = anch::sql::isValidValue<T>);

      template<typename T>
      ClausesBuilder& AND(const std::string& column, anch::sql::ClauseMaker clause, T& value, ValueChecker<T> checker = anch::sql::isValidValue<T>);

      template<typename T>
      ClausesBuilder& AND(const std::string& column, ClauseMaker clause, T& value1, T& value2, ValueChecker<T> checker = anch::sql::isValidValue<T>);

      template<typename T>
      ClausesBuilder& OR(ClauseMaker clause, T& value, ValueChecker<T> checker = anch::sql::isValidValue<T>);

      template<typename T>
      ClausesBuilder& OR(const std::string& column, ClauseMaker clause, T& value, ValueChecker<T> checker = anch::sql::isValidValue<T>);

      template<typename T>
      ClausesBuilder& OR(const std::string& column, ClauseMaker clause, T& value1, T& value2, ValueChecker<T> checker = anch::sql::isValidValue<T>);

      ClausesBuilder& OR(anch::sql::ClausesProvider clauses);
      // Check and add value to prepared statement -
 
      // Parentheses +
    public:
      ClausesBuilder& AND(const ClausesBuilder& other);

      ClausesBuilder& OR(const ClausesBuilder& other);

      ClausesBuilder& operator ||(const ClausesBuilder& other);
      // Parentheses -
      // SQL commands -
 
 
      // Methods +
    private:
      ClausesBuilder& checkAndAddClauses(const std::string& boolAgg, const ClausesBuilder& other);

      void addBooleanAggregator(const std::string& boolAgg);

      ClausesBuilder& checkAndAddClauses(const std::string& boolAgg, anch::sql::ClausesProvider clauses);

      template<typename T>
      ClausesBuilder& checkAndAddClause(const std::string& boolAgg, const std::string& column, ClauseMaker clause, T& value, ValueChecker<T> checker);

      template<typename T>
      ClausesBuilder& checkAndAddClause(const std::string& boolAgg, const std::string& column, ClauseMaker clause, T& value1, T& value2, ValueChecker<T> checker);
      // Methods -
 
    };
 
    // Implementations +
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::AND(anch::sql::ClauseMaker clause, T& value, const anch::sql::ValueChecker<T> checker) {
      return checkAndAddClause("AND", NULL, clause, value, checker);
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::AND(const std::string& column, anch::sql::ClauseMaker clause, T& value, ValueChecker<T> checker) {
      return checkAndAddClause("AND", column, clause, value, checker);
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::AND(const std::string& column, ClauseMaker clause, T& value1, T& value2, ValueChecker<T> checker) {
      return checkAndAddClause("AND", column, clause, value1, value2, checker);
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::OR(ClauseMaker clause, T& value, ValueChecker<T> checker) {
      return checkAndAddClause("OR", NULL, clause, value, checker);
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::OR(const std::string& column, ClauseMaker clause, T& value, ValueChecker<T> checker) {
      return checkAndAddClause("OR", column, clause, value, checker);
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::OR(const std::string& column, ClauseMaker clause, T& value1, T& value2, ValueChecker<T> checker) {
      return checkAndAddClause("OR", column, clause, value1, value2, checker);
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::checkAndAddClause(const std::string& boolAgg, const std::string& column, ClauseMaker clause, T& value, ValueChecker<T> checker) {
      auto optVal = checker(value);
      if(optVal) {
        addBooleanAggregator(boolAgg);
        _buffer << clause(column);
        _values.push_back(optVal.value());
        // if(value instanceof Optional<?>) {
        //   // Optional value has already been check at his point
        //   values.add(((Optional<?>)value).get());
        // } else if(value instanceof Collection) { // For (NOT) IN operators
        //   buffer.append(SQL.toSQLList((Collection<?>)value));
        // } else if(value instanceof SelectBuilder) { // For (NOT) EXISTS operators
        //   buffer.append('(').append(value).append(')');
        //   values.addAll(((SelectBuilder)value).values);
        // } else if(value instanceof SQLQuery) { // For (NOT) EXISTS operators
        //   final SQLQuery query = (SQLQuery)value;
        //   buffer.append('(').append(query.getQuery()).append(')');
        //   values.addAll(query.getValues());
        // } else {
        //   values.add(value);
        // }
        _firstClause = false;
      }
      return *this;
    }
 
    template<typename T>
    ClausesBuilder&
    ClausesBuilder::checkAndAddClause(const std::string& boolAgg, const std::string& column, ClauseMaker clause, T& value1, T& value2, ValueChecker<T> checker) {
      auto optVal1 = checker(value1);
      auto optVal2 = checker(value2);
      if(optVal1 && optVal2) {
        addBooleanAggregator(boolAgg);
        _buffer << clause(column);
        _values.push_back(optVal1.value());
        _values.push_back(optVal2.value());
        // if(value1 instanceof Optional<?>) {
        //   // Optional value has already been check at his point
        //   values.add(((Optional<?>)value1).get());
        // } else {
        //   values.add(value1);
        // }
        // if(value2 instanceof Optional<?>) {
        //   // Optional value has already been check at his point
        //   values.add(((Optional<?>)value2).get());
        // } else {
        //   values.add(value2);
        // }
        _firstClause = false;
      }
      return *this;
    }
    // Implementations -
 
  }  // sql
}  // anch