source: observatorio/simulacion/SimEscenariosEconomicos/queries.H @ eac25c3

/*
  Copyright (C) 2012
  Alejandro Mujica (amujica@cenditel.gob.ve)
  Erwin Paredes (eparedes@cenditel.gob.ve)
  José Ruiz (jruiz@cenditel.gob.ve)
  Rodolfo Rangel (rrangel@cenditel.gob.ve)
  Julie Vera (jvera@cenditel.gob.ve)
 
  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres
 
  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.
 
  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

/*
  Autor:             Alejandro J. Mujica
  Fecha de creación: 01/08/2013
  Este archivo contiene la definición de un conjunto de consultas a base de
  datos utilizadas a lo largo del proyecto.
*/

# ifndef QUERIES_H
# define QUERIES_H

# include <common.H>

/** Encierra una cadena entre comillas simples.
 *
 * Utilizada para los campos de tipo cadena que se almacenan en base de datos.
 *
 * @param str cadena que se va a encerrar entre comillas simples.
 * @return cadena encerrada entre comillas simples.
 */
std::string singleQuote(const std::string & str);

/** Encierra una cadena entre comillas dobles.
 *
 * @param str cadena que se va a encerrar entre comillas simples.
 * @return cadena encerrada entre comillas simples.
 */
std::string doubleQuote(const std::string & str);

/** Concatena dos cadenas mediante un conector.
 *
 * Últil para concatenar nombres de tablas con nombres de campos.
 * Ej: estudiante.id.
 *  
 * @param table nombre de la tabla.
 * @param field nombre del campo.
 * @param connector caracter que conectará a las dos cadenas.
 * @return cadena concatenada.
 */
std::string concat(const std::string & table, const std::string & field,
                   const char & connector = '.');

/** Concatena "campo AS alias"
 *
 * @param field nombre del campo de la tabla.
 * @param alias alias que se le asignará al campo.
 * @return cadena concatenada.
 */
std::string as(const std::string & field, const std::string & alias);

/** Concatena "tabla.campo AS alias"
 *
 * @param table nombre de la tabla.
 * @param field nombre del campo de la tabla.
 * @param alias alias que se le asignará al campo.
 * @return cadena concatenada.
 */
std::string concatas(const std::string & table, const std::string & field,
                     const std::string & alias);

/** Concatena tabla y campo de la forma tabla.campo AS tabla_campo
 *
 * @param table nombre de la tabla.
 * @param field nombre del campo de la tabla. 
 * @return cadena concatenada.
 */
std::string concatas(const std::string &, const std::string &);

/** Concatena una operación de comparación para base de datos.
 *
 * @param field nombre del campo.
 * @param value valor con el cual se va a comparar el campo.
 * @param oper operador de comparación (=, <, <=, >, >= <>)
 */
std::string op(const std::string & field, const std::string & value,
               const std::string & oper = "=");

/** Convierte un campo id (de tipo long) en cadena.
 *
 * @param id valor numérico del id.
 * @return valor del id convertido en cadena.
 */
std::string idToStr(const size_t & id);


/** Concatena la operación field BETWEEN beg AND end (para fechas).
 *
 * @param field nombre del campo a evaluar.
 * @param beg valor mínimo de comparación.
 * @param end valor máximo de comparación.
 * @return cadena concatenada.
 */
std::string between(const std::string & field, const std::string & beg,
                    const std::string & end);

/** Dados un campo y un año (en cadena), efectúa la operación between entre
 *  el primer y el último día del año.
 *
 * @param field nombre del campo que se va a comparar.
 * @param year valor del año.
 * @return cadena concatenada.
 */
std::string inYear(const std::string & field, const std::string & year);

/** Extrae de la base de datos toda la información de un producto con id dado.
 *
 * @param id id del producto que se quiere consultar.
 * @return Objeto ProductInfo con toda la información del producto consultado.
 */
ProductInfo loadInfoByProductId(const size_t & id);

/** Carga la lista de id de los insumos para un producto dado.
 *
 * @param[in] productId id del producto.
 * @param[in] year año de declaración de la matriz.
 * @param[out] inputIds Lista de enteros en la cual se van a escribir los ids
 *             de los insumos.
 */
void listInputIds(const size_t & productId, const std::string & year,
                  List <size_t> & inputIds);

/** Carga a todos los proveedores de un insumo dado.
 *
 * @param[in] inputId id del insumo.
 * @param[in] year año de la venta del insumo.
 * @param[out] Lista de proveedores del insumo.
 */
void listInputs(const size_t & inputId, const std::string & year,
                List <InputInfo> & inputs);


/** Dado un proveedor, obtiene todos los posibles productos asociados a ese
 *  proveedor que coincidan con el mismo código arancelario.
 *
 * @param[in] inputInfo información del insumo.
 * @param[out] Lista de productos asociados al insumo.
 */
void productInfoFromInput(const InputInfo & inputInfo,
                          List <ProductInfo> & list);

/** Carga la lista de todos los productos que utilizan como insumo un producto
 *  dado.
 *
 * @param[in] good bien del cual se requieren los que lo usan.
 * @param[in] Año de declaración de la relación.
 * @param[out] list Lista sobre la cual se escribirán los productos que lo usan
 *              junto al id que se le asocia como insumo a good por cada uno.
 */
void listRequesters(Good * good, const std::string & year,
                    List <Aleph::pair<ProductInfo, long>> & list);

/** Consulta la candidad de insumo requerida para producir una unidad de
 *  producto.
 *
 * @param inputId id del insumo.
 * @param productId id del producto.
 * @return cantidad de insumo para producir una unidad de producto.
 */
real getUnitarianRequest(const size_t & inputId, const size_t & productId);

/** Carga la cantidad producida y el precio de un producto en un año dado.
 *
 * @param[in-out] good bien al cual se le efectúa la consulta y se le asignan
 *                 los valores.
 * @param year año de la producción.
 */
void getProducedQuantityAndPrice(Good * good, const std::string & year);


/** Carga la cantidad producida y el precio de un producto en un año dado.
 *
 * @param[in-out] info producto al cual se le efectúa la consulta y se le
 *                 asignan los valores.
 * @param year año de la producción.
 */
void getProducedQuantityAndPrice(ProductInfo & info, const std::string & year);

/** Calcula la cantidad que se le debe asignar a un arco que va hacia aguas
 *  arriba.
 *
 * @param[in] src bien en el nodo fuente.
 * @param[in] tgt bien en el nodo destino.
 * @param[in] year año de la relación.
 * @param[out] info Referencia a la información del arco
 */
void computeArcQuantityUpstream(Good * src, Good * tgt,
                                const std::string & year, ArcInfo & info);

/** Consulta la cantidad que un comprador declara que obtiene de un proveedor.
 *
 * @param rif R.I.F. del proveedor.
 * @param inputId id del insumo.
 * @param year año de la compra.
 * @return cantidad de insumo declarado.
 */
real getDeclaredBoughtQuantity(const std::string & rif, const long & inputId,
                                 const std::string & year);

/** Calcula la cantidad que se le debe asignar a un arco que va hacia aguas
 *  abajo.
 *
 * @param[in] src bien en el nodo fuente.
 * @param[in] tgt bien en el nodo destino.
 * @param[in-out] arcInfo información del arco sobre la cual se van a escribir
                  los resultados.
 * @param[in] year año de la relación.
 */
void computeArcQuantityDownstream(Good * src, Good * tgt,
                                  const std::string & year, ArcInfo & arcInfo);

/** Consulta el precio declarado de compra para un insumo el cual no está 
 *  registrado en el sigesic como un producto.
 *
 * @param good Bien proveído.
 * @param id id del insumo.
 * @param year año de la compra.
 * @return precio de compra del insumo.
 */
real getAcquisitionPrice(Good * good, const long & id,
                           const std::string & year);

/** Consulta el país de origen de una empresa.
 *
 * @param rif R.I.F. de la empresa.
 * @return nombre del país de origen.
 */
std::string getOrigCountry(const long & supplierId);

/** Consulta el país de procedencia de una empresa.
 *
 * @param rif R.I.F. de la empresa.
 * @return nombre del país de procedencia.
 */
std::string getProcCountry(const long & supplierId);

/** Carga una lista de posibles proveedores para un insumo.
 *
 * @param[in] tariffCode código arancelario del insumo.
 * @param[in] year año de la venta.
 * @param[out] list Lista de posibles proveedores.
 */
void listSuggestedSuppliers(const std::string & tariffCode,
                            const std::string & year,
                            List<ProductInfo> & list);

/** Carga la lista de id de productos de un insumo dado.
 *
 * @param[in] id id del insumo.
 * @param[in] año de la de las ventas.
 * @param[out] ids lista de id de los productos.
 */
void listRealProductId(const long & id, const std::string & year,
                       List<long> & ids);

/** Consulta el nombre de un insumo.
 *
 * @param id id del insumo.
 * @return nombre del insumo.
 */
std::string getInputName(const long & id);

/** Consulta la ubicación de una planta.
 *
 * @param id id de la planta.
 * @return ubicación de la planta.
 */
PlantLocation getPlantLocation(const long & id);

/** Consulta el CIIU de una unidad económica.
 *
 * @param rif R.I.F. de la empresa.
 * @return valor del CIIU de la actividad económica.
 */
std::string getCiiu(const std::string & rif);

/** Consulta la cantidad de emplados operativos de una unidad económica.
 *
 *  @param rif R.I.F. de la empresa.
 *  @param year Año máximo de la declaración.
 *  @return cantidad de empleados en la unidad económica.
 */
real getOperatingStaffNumber(const std::string & rif, const std::string & year);

/** Consulta el monto total producido por una empresa en un año dado.
 *
 *  @param rif R.I.F. de la empresa.
 *  @param year Año de la producción.
 *  @return monto total producido por la empresa.
 */
real getTotalAmount(const std::string & rif, const std::string & year);

/** Extrae los años para los cuales existe una producción.
 *
 * @param[in]  productId Id del producto del cual se quiere consultar.
 * @param[out] years Lista de años para los cuales hay producción declarada.
 */
void getProductionYears(const long productId, List<std::string> & years);

struct CompanyRifName {
    std::string rif;

    std::string name;
};

/** Lista las empresas que tengan nombre parecido al dado.
 *
 * @param[in] company Nombre de la empresa.
 * @param[out] list Lista de pares (rif, nombre) de cada empresa coincidente.
 */
void listCompaniesLike(const std::string & company,
                       List <CompanyRifName> & list);

struct ProductIdName {
    long id;

    std::string name;

    std::string technicalSpecifications;
};

/** Lista todos los productos producidos por una empresa.
 *
 * @param[in] rif R.I.F. de la empresa.
 * @param[out] list Lista de pares (id, nombre) de cada cada producto.
 */
void listProductsByCompany(const std::string & rif,
                           List <ProductIdName> & list);

void setArcMeasurementUnit(ArcInfo & info);

# endif // QUERIES_H