irods_query.hpp

#ifndef IRODS_QUERY_HPP
#define IRODS_QUERY_HPP

#ifdef RODS_SERVER
#include "rsGenQuery.hpp"
#include "specificQuery.h"
#include "rsSpecificQuery.hpp"
#else
#include "genQuery.h"
#include "specificQuery.h"
#endif

#include "rcMisc.h"

#include <algorithm>

char *getCondFromString( char * t );

namespace irods {
    namespace query_helper {
#ifdef RODS_SERVER
        typedef rsComm_t comm_type;
        static const std::function<
            int(rsComm_t*,
                genQueryInp_t*,
                genQueryOut_t**)>
                    gen_query_fcn{rsGenQuery};
        static const std::function<
            int(rsComm_t*,
                specificQueryInp_t *specificQueryInp,
                genQueryOut_t **)>
                    spec_query_fcn{rsSpecificQuery};
#else
        typedef rcComm_t comm_type;
        static const std::function<
            int(rcComm_t*,
                genQueryInp_t*,
                genQueryOut_t**)>
            gen_query_fcn{rcGenQuery};
        static const std::function<
            int(rcComm_t*,
                specificQueryInp_t *specificQueryInp,
                genQueryOut_t **)>
                    spec_query_fcn{rcSpecificQuery};
#endif
    };

    class query {
    public:
        typedef std::vector<std::string> value_type;

        enum query_type {
            GENERAL = 0,
            SPECIFIC = 1
        };

        static query_type convert_string_to_query_type(
                const std::string& _str) {
            // default option
            if(_str.empty()) {
                return GENERAL;
            }

            const std::string GEN_STR{"general"};
            const std::string SPEC_STR{"specific"};

            std::string lowered{_str};
            std::transform(
                lowered.begin(),
                lowered.end(),
                lowered.begin(),
                ::tolower);

            if(GEN_STR == lowered) {
                return GENERAL;
            }
            else if(SPEC_STR == lowered) {
                return SPECIFIC;
            }
            else {
                THROW(
                    SYS_INVALID_INPUT_PARAM,
                    _str + " - is not a query type");
            }
        } // convert_string_to_query_type

        class query_impl_base {
            public:

            size_t size() {
                if(!gen_output_) {
                    return 0;
                }
                return gen_output_->rowCnt;
            }

            int cont_idx() {
                return gen_output_->continueInx;
            }

            int row_cnt() {
                return gen_output_->rowCnt;
            }

            std::string query_string() {
                return query_string_;
            }

            bool page_in_flight(const int row_idx_) {
                if(row_idx_ < row_cnt()) {
                    return true;
                }
                return false;
            }

            bool query_complete() {
                // finished page, and out of pages
                if(cont_idx() <= 0) {
                    return true;
                }
                return false;
            }

            value_type capture_results(int _row_idx) {
                value_type res;
                for(int attr_idx = 0; attr_idx < gen_output_->attriCnt; ++attr_idx) {
                    uint32_t offset = gen_output_->sqlResult[attr_idx].len * _row_idx;
                    std::string str{&gen_output_->sqlResult[attr_idx].value[offset]};
                    res.push_back(str);
                }
                return res;
            }

            bool results_valid() {
                if(gen_output_) {
                    return (gen_output_->rowCnt > 0);
                }
                else {
                    return false;
                }
            }

            virtual int fetch_page() = 0;
            virtual ~query_impl_base() {
                freeGenQueryOut(&gen_output_);
            }

            query_impl_base(
                query_helper::comm_type* _comm,
                const std::string&       _q) :
                comm_{_comm},
                query_string_{_q},
                gen_output_{} {
            };
            protected:
            query_helper::comm_type* comm_;
            const std::string& query_string_;
            genQueryOut_t* gen_output_;
        }; // class query_impl_base

        class gen_query_impl : public query_impl_base {
            public:
            virtual ~gen_query_impl() {
            }

            int fetch_page() {
                if(gen_output_) {
                    gen_input_.continueInx = gen_output_->continueInx;
                    freeGenQueryOut(&gen_output_);
                }

                int ret = query_helper::gen_query_fcn(
                           comm_,
                           &gen_input_,
                           &gen_output_);
                return ret;
            } // fetch_page

            gen_query_impl(
                query_helper::comm_type* _comm,
                int                      _max_rows,
                const std::string&       _query_string) :
                query_impl_base(_comm, _query_string) {

                memset(&gen_input_, 0, sizeof(gen_input_));
                gen_input_.maxRows = _max_rows;
                const int fill_err = fillGenQueryInpFromStrCond(
                                         const_cast<char*>(_query_string.c_str()),
                                         &gen_input_);
                if(fill_err < 0) {
                    THROW(
                        fill_err,
                        boost::format("query fill failed for [%s]") %
                        _query_string);
                }
            } // ctor

            private:
            genQueryInp_t gen_input_; 
        }; // class gen_query_impl

        class spec_query_impl : public query_impl_base {
            public:
            virtual ~spec_query_impl() {
            }

            int fetch_page() {
                if(gen_output_) {
                    spec_input_.continueInx = gen_output_->continueInx;
                    freeGenQueryOut(&gen_output_);
                }

                int ret = query_helper::spec_query_fcn(
                           comm_,
                           &spec_input_,
                           &gen_output_);
                return ret;
            } // fetch_page

            spec_query_impl(
                query_helper::comm_type* _comm,
                int                      _max_rows,
                const std::string&       _query_string) :
                query_impl_base(_comm, _query_string) {

                memset(&spec_input_, 0, sizeof(spec_input_));
                spec_input_.maxRows = _max_rows;
                spec_input_.sql = const_cast<char*>(_query_string.c_str());

                int spec_err = query_helper::spec_query_fcn(
                                   _comm,
                                   &spec_input_,
                                   &gen_output_);
                if(spec_err < 0) {
                    THROW(
                        spec_err,
                        boost::format("query fill failed for [%s]") %
                        _query_string);
                }
            } // ctor

            private:
            specificQueryInp_t spec_input_; 
        }; // class spec_query_impl

        class iterator: public std::iterator<
            std::forward_iterator_tag,// iterator_category
            value_type,               // value_type
            value_type,               // difference_type
            const value_type*,        // pointer
            value_type> {             // reference
                query_helper::comm_type* comm_;
                const std::string query_string_;
                uintmax_t max_rows_;//const uintmax_t max_rows_;
                uint32_t row_idx_;
                genQueryInp_t* gen_input_; 
                genQueryOut_t* gen_output_; 
                bool end_iteration_state_;

                std::shared_ptr<query_impl_base> query_impl_;

                public:
                explicit iterator () :
                    comm_{},
                    query_string_{},
                    max_rows_{},
                    row_idx_{},
                    gen_input_{},
                    gen_output_{},
                    end_iteration_state_{true} {
                }

                explicit iterator(
                    std::shared_ptr<query_impl_base> _qimp) :
                    comm_{},
                    query_string_{},
                    max_rows_{},
                    row_idx_{},
                    gen_input_{},
                    gen_output_{},
                    end_iteration_state_{false},
                    query_impl_(_qimp) {
                }

                explicit iterator(
                    query_helper::comm_type* _comm,
                    const std::string&       _query_string,
                    const uintmax_t&         _max_rows,
                    genQueryInp_t*           _gen_input,
                    genQueryOut_t*           _gen_output) :
                    comm_{_comm},
                    query_string_{_query_string},
                    max_rows_{_max_rows},
                    row_idx_{},
                    gen_input_{_gen_input},
                    gen_output_{_gen_output},
                    end_iteration_state_{false} {
                } // ctor

                iterator operator++() {
                    advance_query();
                    return *this;
                }
                
                iterator operator++(int) {
                    iterator ret = *this;
                    ++(*this);
                    return ret;
                }

                bool operator==(const iterator& _rhs) const {
                    if(end_iteration_state_ && _rhs.end_iteration_state_) {
                        return true;
                    }
                    //return (query_string_ == _rhs.query_string_);
                    return (query_impl_->query_string() == _rhs.query_string_);
                }
               
                bool operator!=(const iterator& _rhs) const {
                    bool val = !(*this == _rhs);
                    return val;
                }

                value_type operator*() {
                    return capture_results();
                }

                void advance_query() {
                    row_idx_++;

                    if(query_impl_->page_in_flight(row_idx_)) {
                        return;
                    }

                    if(query_impl_->query_complete()) {
                        end_iteration_state_ = true;
                        return;
                    }

                    const int query_err = query_impl_->fetch_page();
                    if(query_err < 0) {
                        if(CAT_NO_ROWS_FOUND != query_err) {
                            THROW(
                                query_err,
                                boost::format("gen query failed for [%s] on idx %d") %
                                query_string_ %
                                gen_input_->continueInx);
                        }

                       end_iteration_state_ = true;
                
                    } // if

                } // advance_query 

                value_type capture_results() {
                    return query_impl_->capture_results(row_idx_);
                }

         }; // class iterator
        
        explicit query(
            query_helper::comm_type* _comm,
            const std::string&       _query_string,
            uintmax_t                _max_rows   = MAX_SQL_ROWS,
            query_type               _query_type = GENERAL) {
                if(_query_type == GENERAL) {
                    query_impl_ = std::make_shared<gen_query_impl>(
                                      _comm,
                                      _max_rows,
                                      _query_string);
                }
                else if(_query_type == SPECIFIC) {
                    query_impl_ = std::make_shared<spec_query_impl>(
                                      _comm,
                                      _max_rows,
                                      _query_string);
                }

                const int fetch_err = query_impl_->fetch_page(); 
                if(fetch_err < 0) {
                    if(CAT_NO_ROWS_FOUND == fetch_err) {
                        iter_ = std::make_unique<iterator>();
                    }
                    else {
                        THROW(
                            fetch_err,
                            boost::format("query failed for [%s] type [%d]") %
                            _query_string %
                            _query_type);
                    }
                }

                if(query_impl_->results_valid()) {
                    iter_ = std::make_unique<iterator>(query_impl_);
                }
                else {
                    iter_ = std::make_unique<iterator>();
                }
        } // ctor

        ~query() {
        }

        iterator   begin() {
            return *iter_;
        }
        iterator   end()   {
            return iterator();
        }
        value_type front() {
            return (*(*iter_));
        }

        size_t size()  {
            return query_impl_->size();
        }
    private:
        std::unique_ptr<iterator>        iter_;
        std::shared_ptr<query_impl_base> query_impl_;
    }; // class query
} // namespace irods

#endif // IRODS_QUERY_HPP