metadata_query.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:     J.M. De la Rosa Trevin (jmdelarosa@cnb.csic.es)
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef CORE_METADATAQUERY_H
#define CORE_METADATAQUERY_H

#include <sstream>

#include "metadata_label.h"
#include "xmipp_error.h"
#include "metadata_static.h"


class MDQuery
{
public:
    int limit; 
    int offset; 
    MDLabel orderLabel; 
    bool asc;

    MDQuery(int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID,bool asc=true)
    {
        this->limit = limit;
        this->offset = offset;
        this->orderLabel = orderLabel;
        this->asc=asc;
    }

    virtual ~MDQuery() {}

    String orderByString() const
    {
        return (String)" ORDER BY " + MDL::label2Str(orderLabel) + (asc ? " ASC" : " DESC");
    }

    String limitString() const;

    String whereString() const
    {
        String queryString = this->queryStringFunc();
        return (queryString == " ") ? " " : " WHERE " + queryString + " ";
    }

    virtual String queryStringFunc() const
    {
        return " ";
    }
}
;//End of class MDQuery

enum RelationalOp
{
    EQ, 
    NE, 
    GT, 
    LT, 
    GE, 
    LE 
};

class MDValueRelational: public MDQuery
{
public:
    MDObject *value;
    RelationalOp op;

    template <class T>
    MDValueRelational(MDLabel label, const T &value, RelationalOp op, int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID):MDQuery(limit, offset, orderLabel)
    {
        this->op = op;
        this->value = new MDObject(label, value);
    }

    MDValueRelational(const MDObject &value, RelationalOp op, int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID):MDQuery(limit, offset, orderLabel)
    {
        this->op = op;
        this->value = new MDObject(value);
    }

    ~MDValueRelational()
    {
        delete this->value;
    }

    String opString() const
    {
        switch (op)
        {
        case EQ:
            return "=";
        case NE:
            return "!=";
        case GT:
            return ">";
        case LT:
            return "<";
        case GE:
            return ">=";
        case LE:
            return "<=";
        default:
            REPORT_ERROR(ERR_ARG_INCORRECT,"Unknown binary operator");
        }
    }

    virtual String queryStringFunc() const
    {
        return (value == NULL) ? " " : MDL::label2Str(value->label) + opString() + value->toString(false, true);
    }

    template <class T>
    void setValue(T &value)
    {
        this->value->setValue(value);
    }
}
;//end of class MDValueRelational

class MDValueEQ: public MDValueRelational
{
public:
    template <class T>
    MDValueEQ(MDLabel label, const T &value, int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID)
            :MDValueRelational(label, value, EQ, limit, offset, orderLabel)
    {}
}
;//end of class MDValueEQ

class MDValueNE: public MDValueRelational
{
public:
    template <class T>
    MDValueNE(MDLabel label, const T &value, int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID)
            :MDValueRelational(label, value, NE, limit, offset, orderLabel)
    {}
}
;//end of class MDValueNE

class MDValueGE: public MDValueRelational
{
public:
    template <class T>
    MDValueGE(MDLabel label, const T &valueMin, int limit = -1,int offset = 0, MDLabel orderLabel = MDL_OBJID)
            :MDValueRelational(label, valueMin, GE, limit, offset, orderLabel)
    {}
}
;//end of class MDValueGE

class MDValueGT: public MDValueRelational
{
public:
    template <class T>
    MDValueGT(MDLabel label, const T &valueMin, int limit = -1,int offset = 0, MDLabel orderLabel = MDL_OBJID)
            :MDValueRelational(label, valueMin, GT, limit, offset, orderLabel)
    {}
}
;//end of class MDValueGT

class MDValueLE: public MDValueRelational
{
public:
    template <class T>
    MDValueLE(MDLabel label, const T &valueMax, int limit = -1,int offset = 0, MDLabel orderLabel = MDL_OBJID)
            :MDValueRelational(label, valueMax, LE, limit, offset, orderLabel)
    {}
}
;//end of class MDValueLE

class MDValueLT: public MDValueRelational
{
public:
    template <class T>
    MDValueLT(MDLabel label, const T &valueMax, int limit = -1,int offset = 0, MDLabel orderLabel = MDL_OBJID)
            :MDValueRelational(label, valueMax, LT, limit, offset, orderLabel)
    {}
}
;//end of class MDValueLT

class MDValueRange: public MDQuery
{
    MDValueRelational *query1, *query2;
public:
    MDValueRange()
    {
        query1=query2=NULL;
    }
    template <class T>
    MDValueRange(MDLabel label, const T &valueMin, const T &valueMax,
                 int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID):MDQuery(limit, offset, orderLabel)
    {
        query1 = new MDValueRelational(label, valueMin, GE);
        query2 = new MDValueRelational(label, valueMax, LE);
    }

    MDValueRange(const MDObject &o1, const MDObject &o2,
                 int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID):MDQuery(limit, offset, orderLabel)
    {
        if (o1.label != o2.label)
            REPORT_ERROR(ERR_VALUE_INCORRECT, "Labels should be the same");
        query1 = new MDValueRelational(o1, GE);
        query2 = new MDValueRelational(o2, LE);

    }
    virtual String queryStringFunc() const;

    ~MDValueRange()
    {
        delete query1;
        delete query2;
    }
}
;//end of class MDValueRange

class MDExpression: public MDQuery
{
    String sExpression;
public:
    MDExpression()
    {
        sExpression = " 1=1 ";
    }
    MDExpression(String _sExpression,
                 int limit = -1,
                 int offset = 0,
                 MDLabel orderLabel = MDL_OBJID):MDQuery(limit, offset, orderLabel)
    {
        sExpression=_sExpression;
    }

    virtual String queryStringFunc() const
    {
        return sExpression;
    }

}
;//end of class MDExpression

class MDMultiQuery: public MDQuery
{
public:
    std::vector<const MDQuery*> queries;
    std::vector<String> operations;

    MDMultiQuery(int limit = -1, int offset = 0, MDLabel orderLabel = MDL_OBJID):MDQuery(limit, offset, orderLabel)
    {
        clear();
    }
    void addAndQuery(MDQuery &query)
    {
        queries.emplace_back(&query);
        operations.emplace_back("AND");
    }
    void addOrQuery(MDQuery &query)
    {
        queries.emplace_back(&query);
        operations.emplace_back("OR");
    }

    void clear()
    {
        queries.clear();
        operations.clear();
    }

    virtual String queryStringFunc() const;

}
;//end of class MDMultiQuery

#endif