sql_page.h

/*
 * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <vector>
#include <boost/any.hpp>
#include <boost/optional.hpp>
#include <boost/enable_shared_from_this.hpp>
 
#include "hazelcast/util/export.h"
#include "hazelcast/client/sql/sql_column_type.h"
#include "hazelcast/client/sql/sql_row_metadata.h"
#include "hazelcast/client/serialization/serialization.h"
 
namespace hazelcast {
namespace client {
namespace protocol {
namespace codec {
namespace builtin {
class sql_page_codec;
}
} // namespace codec
} // namespace protocol
namespace sql {
 
class HAZELCAST_API sql_page
{
    using column = std::vector<boost::any>;
    struct HAZELCAST_API page_data;
 
public:
    class HAZELCAST_API sql_row
    {
    public:
        sql_row(size_t row_index, std::shared_ptr<page_data> page);
 
        template<typename T>
        boost::optional<T> get_object(std::size_t column_index) const
        {
            check_index(column_index);
 
            return page_data_->get_column_value<T>(column_index, row_index_);
        }
 
        template<typename T>
        boost::optional<T> get_object(const std::string& column_name) const
        {
            auto column_index = resolve_index(column_name);
            return page_data_->get_column_value<T>(column_index, row_index_);
        }
 
        const sql_row_metadata& row_metadata() const;
 
    private:
        std::size_t row_index_;
        std::shared_ptr<page_data> page_data_;
 
        std::size_t resolve_index(const std::string& column_name) const;
 
        void check_index(size_t index) const;
    };
 
    sql_page(std::vector<sql_column_type> column_types,
             std::vector<column> columns,
             bool last,
             std::shared_ptr<sql_row_metadata> row_metadata = nullptr);
 
    const std::vector<sql_column_type>& column_types() const;
 
    bool last() const;
 
    std::size_t column_count() const;
 
    std::size_t row_count() const;
 
    const std::vector<sql_row>& rows() const;
 
private:
    friend class sql_result;
    friend class protocol::codec::builtin::sql_page_codec;
 
    std::shared_ptr<page_data> page_data_;
    std::vector<sql_row> rows_;
    bool last_;
 
    void row_metadata(std::shared_ptr<sql_row_metadata> row_metadata);
 
    void serialization_service(serialization::pimpl::SerializationService* ss);
 
    void construct_rows();
 
    struct HAZELCAST_API page_data
    {
        std::vector<sql_column_type> column_types_;
        std::vector<column> columns_;
        std::shared_ptr<sql_row_metadata> row_metadata_;
        serialization::pimpl::SerializationService* serialization_service_;
 
        template<typename T>
        boost::optional<T> get_column_value(std::size_t column_index,
                                            std::size_t row_index) const
        {
            assert(column_index < column_count());
            assert(row_index < row_count());
 
            auto& any_value = columns_[column_index][row_index];
            if (any_value.empty()) {
                return boost::none;
            }
 
            if (column_types_[column_index] != sql_column_type::object) {
                return boost::any_cast<T>(any_value);
            }
 
            // this is the object type, hence the value is `data`
            // and we need to de-serialize it
            return serialization_service_->to_object<T>(
              boost::any_cast<serialization::pimpl::data>(any_value));
        }
 
        std::size_t column_count() const;
        std::size_t row_count() const;
    };
};
 
} // namespace sql
} // namespace client
} // namespace hazelcast