source: observatorio/simulacion/ModuloDinamico/queries.H @ 4b459a7

/*
  Copyright (C) 2014
  Alejandro Mujica (amujica@cenditel.gob.ve)
  José Ruiz (jruiz@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: 12/06/2014
  Este archivo contiene la definición de cabeceras para las diversas consultas
  a base de datos efectuadas.
*/

# ifndef QUERIES_H
# define QUERIES_H

# include <product.H>
# include <input.H>

struct DB
{
  // Nombres de tablas
  static const std::string PRODUCT_TABLE_NAME;
  static const std::string INPUT_TABLE_NAME;
  static const std::string PLANT_TABLE_NAME;
  static const std::string COMPANY_TABLE_NAME;
  static const std::string COMPANY_ACTIVITY_CIIU_TABLE_NAME;
  static const std::string PRODUCT_INPUT_TABLE_NAME;
  static const std::string MEASUREMENT_UNIT_TABLE_NAME;
  static const std::string INPUT_SUPPLIER_TABLE_NAME;
  static const std::string SUPPLIER_TABLE_NAME;
  static const std::string PRODUCTION_QUANTITIES_TABLE_NAME;
  static const std::string ACQ_PRICE_TABLE_NAME;
  static const std::string COUNTRY_TABLE_NAME;
  static const std::string PARISH_TABLE_NAME;
  static const std::string TOWN_TABLE_NAME;
  static const std::string STATE_TABLE_NAME;
  static const std::string COMPANY_OCCUPANCY_TABLE_NAME;

  // Nombres de campos
  static const std::string ID;
  static const std::string NAME;
  static const std::string COMPANY_NAME;
  static const std::string TECHNICAL_SPECIFICATION;
  static const std::string TARIFF_CODE;
  static const std::string MEASUREMENT_UNIT_ID;
  static const std::string TRADEMARK;
  static const std::string PLANT_ID;
  static const std::string CODE;
  static const std::string PARISH_CODE;
  static const std::string TOWN_CODE;
  static const std::string STATE_CODE;
  static const std::string COMPANY_RIF;
  static const std::string UE_RIF;
  static const std::string RIF;
  static const std::string NATIONALITY;
  static const std::string WORKDAY;
  static const std::string ACQ_PRICE;
  static const std::string NAC_ACQ_PRICE;
  static const std::string CIIU_ID;
  static const std::string ACTIVE;
  static const std::string MAIN;
  static const std::string INPUT_ID;
  static const std::string PRODUCT_ID;
  static const std::string SUPPLIER_ID;
  static const std::string PRODUCED_QUANTITY;
  static const std::string PRICE;
  static const std::string BOUGHT_QUANTITY;
  static const std::string QUANTITY;
  static const std::string ORIG_COUNTRY_ID;
  static const std::string PROC_COUNTRY_ID;
  static const std::string YEAR_R;
  static const std::string YEAR;
  static const std::string USED_CAPACITY;
  static const std::string INSERTION_DATE;
  static const std::string OPERATING;
  static const std::string ADMINISTRATIVE;
};

/** 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 single_quote(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 double_quote(const std::string & str);

/** Concatena dos cadenas mediante un conector.
 *
 * Útil 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 & table, const std::string & field);

/** 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 id_to_str(const db_id_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 in_year(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 Product con toda la información del producto consultado.
 */
Product load_product_by_id(const db_id_t & id);

/** Carga la lista de id de los insumos para un producto dado.
 *
 * @param[in] product_id id del producto.
 * @param[in] year año de declaración de la matriz.
 * @param[out] input_ids Lista en la cual se almacenarán los ids.
 */
void list_input_ids(const db_id_t & product_id, const std::string & year,
                    List<db_id_t> & input_ids);

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

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

/** 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 get_unitarian_request(const db_id_t & input_id,
                           const db_id_t & product_id);

/** Consulta el precio declarado de compra para un insumo el cual no está 
 *  registrado en el sigesic como un producto.
 *
 * @param nationality Nacionalidad de la unidad económica productora del insumo.
 * @param input_id id del insumo.
 * @param year año de declaración de la compra.
 * @return precio de compra del insumo.
 */
real get_acquisition_price(const std::string & nationality,
                           const db_id_t & input_id,
                           const std::string & year);

/** Consulta la cantidad que un comprador declara que obtiene de un proveedor.
 *
 * @param rif R.I.F. del proveedor.
 * @param company_name Nombre del proveedor para el caso de extranjeros.
 * @param input_id id del insumo.
 * @param year año de la compra.
 * @return cantidad de insumo declarado.
 */
real get_declared_bought_quantity(const std::string & rif,
                                  const std::string & company_name,
                                  const db_id_t & input_id,
                                  const std::string & year);

/** Consulta la cantidad producida y el precio de venta declarado de un producto.
 *
 * @param product_id id del producto.
 * @param year año de declaración de la producción.
 */
Aleph::pair<real, real>
get_produced_quantity_and_price(const db_id_t & product_id,
                                const std::string & year);

/** 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[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 list_requesters(Good * good, List <Aleph::pair<Product, long>> & list);

/** Consulta la capacidad usada de producción de la planta distribuida a un
 *  producto dado.
 *
 * @param product_id id del producto el cual se quiere consultar.
 * @param year año de declaración de la producción.
 * @return capacidad máxima de producción para el producto.
 */
real get_product_used_capacity(const db_id_t & product_id,
                               const std::string & year);

/** Consulta información laboral de la empresa, como lo son: jornada laboral y
 *  cantidad de personal operativo y administrativo distribuidos por producto.
 *
 * @param rif R.I.F. de la empresa.
 * @param year Año del estudio.
 * @param product_id id del producto.
 * @return Par ordenado con ambos resultados.
 */
std::tuple<real, real, real>
get_product_staff_numbers(const std::string & rif,
                          const std::string & year,
                          const db_id_t & product_id);

/** Obtiene el monto obtenido por las empresas fuera de la red en la venta de
 *  un producto.
 *
 * @param tariff_code Código Arancelario del producto en estudio.
 * @param seller_rif R.I.F. de la empresa productora del producto.
 * @param year Año de declaración de la compra-venta.
 * @param buyers_to_exclude Cadena que contiene los R.I.F.s de los compradores a
 *                          excluir en el cálculo, es decir, los que están
 *                          dentro de la red.
 * @return El monto total en Bs obtenido por la empresa por los compradores que
 *         no están en la red.
 */
real get_external_sales(const std::string & tariff_code,
                        const std::string & seller_rif,
                        const std::string & year,
                        const std::string & buyers_to_exclude);

# endif // QUERIES_H