ASqlBuilder.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <AUI/Autumn/Autumn.h>
#include <AUI/Common/AString.h>
#include <AUI/Common/AVariant.h>
#include <AUI/Common/AVector.h>
#include <AUI/Common/AMap.h>
#include <AUI/Common/AStringVector.h>
#include <AUI/Reflect/AField.h>
#include <AUI/Data/ASqlDatabase.h>
#include <AUI/Traits/parameter_pack.h>
 
template<typename ModelType>
struct ASqlModel;
 
template<class T>
struct AModelMeta;
 
class API_AUI_DATA ASqlBuilder {
private:
   AString mTableName;
 
public:
   class API_AUI_DATA Statement {
   protected:
       ASqlBuilder& mBuilder;
       AString mSql;
 
       Statement(ASqlBuilder& builder, const AString& sql);
       Statement(const Statement&) = delete;
   public:
       virtual ~Statement() = default;

       ASqlBuilder& also() {
           return mBuilder;
       }
   };
 
   class API_AUI_DATA Insert: public Statement {
       friend class ASqlBuilder;
   private:
       AVector<AVariant> mData;
       bool mInsertDone = false;
 
       Insert(ASqlBuilder& builder, const AString& sql);
       int doInsert();
 
   public:
       Insert(const Insert&) = delete;
       Insert& row(const AVector<AVariant>& data);
       Insert& rows(const AVector<AVector<AVariant>>& data);
       id_t rowId();
       ~Insert() override;
   };
 
   class API_AUI_DATA WhereStatement: public Statement {
   public:
       ~WhereStatement() override = default;
 
       class API_AUI_DATA WhereExpr {
           friend class WhereStatement;
       private:
           AString mExprString;
           AVector<AVariant> mWhereParams;
 
       public:
           WhereExpr() = default;
           explicit WhereExpr(const AString& exprString);
 
           static std::tuple<AString, AVector<AVariant>> unpack(const WhereExpr& e) {
               return std::make_tuple(e.mExprString, e.mWhereParams);
           }
 
           inline WhereExpr& operator>(const AVariant& other) {
               mExprString += " > ?";
               mWhereParams << other;
               return *this;
           }
           inline WhereExpr& operator>=(const AVariant& other) {
               mExprString += " >= ?";
               mWhereParams << other;
               return *this;
           }
           inline WhereExpr& operator<(const AVariant& other) {
               mExprString += " < ?";
               mWhereParams << other;
               return *this;
           }
           inline WhereExpr& operator<=(const AVariant& other) {
               mExprString += " <= ?";
               mWhereParams << other;
               return *this;
           }
           inline WhereExpr& operator==(const AVariant& other) {
               mExprString += " = ?";
               mWhereParams << other;
               return *this;
           }
           inline WhereExpr& operator!=(const AVariant& other) {
               mExprString += " != ?";
               mWhereParams << other;
               return *this;
           }
 
           inline WhereExpr& operator&&(const WhereExpr& other) {
               mExprString += " and " + other.mExprString;
               mWhereParams.insertAll(other.mWhereParams);
               return *this;
           }
           inline WhereExpr& operator||(const WhereExpr& other) {
               mExprString += " or " + other.mExprString;
               mWhereParams.insertAll(other.mWhereParams);
               return *this;
           }
       };
 
   protected:
       AString mWhereExpr;
       AVector<AVariant> mWhereParams;
 
       WhereStatement(ASqlBuilder& builder, const AString& sql);
       void whereImpl(const WhereExpr& w);
   };
 
   class API_AUI_DATA Select: public WhereStatement {
       friend class ASqlBuilder;
   private:
       AVector<AVariant> mData;
 
       Select(ASqlBuilder& builder, const AString& sql);
 
   public:
       Select(const Select&) = delete;
       ~Select() override = default;
 
       Select& where(const WhereExpr& w) {
           whereImpl(w);
           return *this;
       }

       AVector<AVector<AVariant>> get();

       template<class Model>
       AVector<Model> as() {
           auto idField = AField<ASqlModel<Model>>::make(&ASqlModel<Model>::id);
           AVector<Model> result;
           result.reserve(0x100);
 
           mSql += " ";
           mSql += mWhereExpr;
           auto dbResult = Autumn::get<ASqlDatabase>()->query(mSql, mWhereParams);
 
           AVector<size_t> sqlColumnToModelFieldIndexMapping;
           AVector<_<AField<Model>>> fields;
           fields << AModelMeta<Model>::getFields().valueVector();
           /*
           {
               sqlColumnToModelFieldIndexMapping.resize(dbResult->getColumns().size());
               AMap<AString, size_t> columnNameToFieldIndexMapping;
               size_t counter = 0;
               for (auto& column : dbResult->getColumns()) {
                   columnNameToFieldIndexMapping[column.name] = counter++;
               }
 
               for (std::pair<AString, _<AField<Model>>>& field : AModelMeta<Model>::fields) {
                   sqlColumnToModelFieldIndexMapping.push_back(columnNameToFieldIndexMapping[field.first]);
                   fields << field.second;
               }
           }*/
 
           for (auto& row : dbResult) {
               Model m;
               idField->set(m, row->getValue(0));
               for (size_t columnIndex = 1; columnIndex < dbResult->getColumns().size(); ++columnIndex) {
                   fields[columnIndex - 1]->set(m, row->getValue(columnIndex));
               }
               result << std::move(m);
           }
 
           return result;
       }
   };
 
   class API_AUI_DATA Update: public WhereStatement {
       friend class ASqlBuilder;
   private:
       AMap<AString, AVariant> mValues;
 
       Update(const AMap<AString, AVariant>& values, ASqlBuilder& builder, const AString& sql);
 
   public:
       Update(const Update&) = delete;
       ~Update() override;
 
       Update& where(const WhereExpr& w) {
           whereImpl(w);
           return *this;
       }
 
       void set(const AString& key, const AVariant& value) {
           mValues[key] = value;
       }
   };
 
   class API_AUI_DATA Delete: public WhereStatement {
       friend class ASqlBuilder;
   private:
       AVector<AVariant> mData;
 
       Delete(ASqlBuilder& builder, const AString& sql);
 
   public:
       Delete(const Delete&) = delete;
       ~Delete() override;
 
       Delete& where(const WhereExpr& w) {
           whereImpl(w);
           return *this;
       }
   };
 
   ASqlBuilder(const AString& tableName);

   Insert insert(const AStringVector& columnNames);
 

   template<typename... Args>
   Insert ins(Args&&... args) {
       AStringVector v;
       aui::parameter_pack::for_each([&](const AString& s) {
           v << s;
       }, std::forward<Args>(args)...);
       return insert(v);
   }
 

   Select select(const AStringVector& columnNames = {});

   template<typename... Args>
   Select sel(Args&&... args) {
       AStringVector v;
       aui::parameter_pack::for_each([&](const AString& s) {
           v << s;
       }, std::forward<Args>(args)...);
       return select(v);
   }

   Update update(const AMap<AString, AVariant>& data = {});

   Delete remove();
 

   template<typename Model>
   id_t insertORM(const Model& model) {
       Insert insertStatement = insert(AModelMeta<Model>::getFields().keyVector());
 
       AVector<AVariant> row;
       for (std::pair<AString, _<AField<Model>>> field : AModelMeta<Model>::getFields()) {
           row << field.second->get(model);
       }
       insertStatement.row(row);
       return insertStatement.rowId();
   }

   template<typename Model>
   void updateORM(const Model& model) {
       Update updateStatement = update();
 
       AVector<AVariant> row;
       for (const std::pair<AString, _<AField<Model>>>& field : AModelMeta<Model>::getFields()) {
           if (field.first != "id")
               updateStatement.set(field.first, field.second->get(model));
       }
       updateStatement.where(WhereStatement::WhereExpr("id") == model.id);
   }

   template<typename Model>
   void removeORM(const Model& model) {
       remove().where(WhereStatement::WhereExpr("id") == model.id);
   }
};
 
 
typedef ASqlBuilder table;
typedef ASqlBuilder::WhereStatement::WhereExpr col;

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.