query_sql.h

Go to the documentation of this file.

/*
 * Copyright 2019 GridGain Systems, Inc. and Contributors.
 *
 * Licensed under the GridGain Community Edition License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.gridgain.com/products/software/community-edition/gridgain-community-edition-license
 *
 * 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.
 */
 
#ifndef _IGNITE_CACHE_QUERY_QUERY_SQL
#define _IGNITE_CACHE_QUERY_QUERY_SQL
 
#include <stdint.h>
#include <string>
#include <vector>
 
#include <ignite/impl/writable_object.h>
#include <ignite/binary/binary_raw_writer.h>
 
namespace ignite
{
    namespace cache
    {
        namespace query
        {
            class SqlQuery
            {
            public:
                SqlQuery(const std::string& type, const std::string& sql) :
                    type(type),
                    sql(sql),
                    pageSize(1024),
                    loc(false),
                    distributedJoins(false),
                    args()
                {
                    // No-op.
                }
 
                SqlQuery(const SqlQuery& other) :
                    type(other.type),
                    sql(other.sql),
                    pageSize(other.pageSize),
                    loc(other.loc),
                    distributedJoins(other.distributedJoins),
                    args()
                {
                    args.reserve(other.args.size());
 
                    typedef std::vector<impl::WritableObjectBase*>::const_iterator Iter;
 
                    for (Iter i = other.args.begin(); i != other.args.end(); ++i)
                        args.push_back((*i)->Copy());
                }
 
                SqlQuery& operator=(const SqlQuery& other) 
                {
                    if (this != &other)
                    {
                        SqlQuery tmp(other);
 
                        Swap(tmp);
                    }
 
                    return *this;
                }
 
                ~SqlQuery()
                {
                    typedef std::vector<impl::WritableObjectBase*>::const_iterator Iter;
 
                    for (Iter it = args.begin(); it != args.end(); ++it)
                        delete *it;
                }
 
                void Swap(SqlQuery& other)
                {
                    if (this != &other)
                    {
                        std::swap(type, other.type);
                        std::swap(sql, other.sql);
                        std::swap(pageSize, other.pageSize);
                        std::swap(loc, other.loc);
                        std::swap(distributedJoins, other.distributedJoins);
                        std::swap(args, other.args);
                    }
                }
 
                const std::string& GetType() const
                {
                    return type;
                }
 
                void SetType(const std::string& type)
                {
                    this->type = type;
                }
 
                const std::string& GetSql() const
                {
                    return sql;
                }
 
                void SetSql(const std::string& sql)
                {
                    this->sql = sql;
                }
 
                int32_t GetPageSize() const
                {
                    return pageSize;
                }
 
                void SetPageSize(int32_t pageSize)
                {
                    this->pageSize = pageSize;
                }
 
                bool IsLocal() const
                {
                    return loc;
                }
 
                void SetLocal(bool loc)
                {
                    this->loc = loc;
                }
 
                bool IsDistributedJoins() const
                {
                    return distributedJoins;
                }
 
                void SetDistributedJoins(bool enabled)
                {
                    distributedJoins = enabled;
                }
 
                template<typename T>
                void AddArgument(const T& arg)
                {
                    args.push_back(new impl::WritableObject<T>(arg));
                }
 
                void ClearArguments()
                {
                    std::vector<impl::WritableObjectBase*>::iterator iter;
                    for (iter = args.begin(); iter != args.end(); ++iter)
                        delete *iter;
 
                    args.clear();
                }
 
                void Write(binary::BinaryRawWriter& writer) const
                {
                    writer.WriteBool(loc);
                    writer.WriteString(sql);
                    writer.WriteString(type);
                    writer.WriteInt32(pageSize);
 
                    writer.WriteInt32(static_cast<int32_t>(args.size()));
 
                    std::vector<impl::WritableObjectBase*>::const_iterator it;
 
                    for (it = args.begin(); it != args.end(); ++it)
                        (*it)->Write(writer);
 
                    writer.WriteBool(distributedJoins);
                    writer.WriteInt32(0);  // Timeout, ms
                    writer.WriteBool(false);  // ReplicatedOnly
                }
 
            private:
                std::string type;
 
                std::string sql;
 
                int32_t pageSize;
 
                bool loc;
 
                bool distributedJoins;
 
                std::vector<impl::WritableObjectBase*> args;
            };
        }
    }    
}
 
#endif //_IGNITE_CACHE_QUERY_QUERY_SQL