DBInterface.H

Go to the documentation of this file.

/*************************************
 *File: DBInterface.H
 *Author: relminya
 *Date:   3.15.2005
 *
 *Description: This file is the gateway
 * to all the data held in the database,
 * be it ranking info or map info.
 * As of 3.15.2005 it only describes
 * the methods that other components will
 * be dependent on. 
 **************************************/

#ifndef DBInterface_h
#define DBInterface_h

#include <iostream>
#include <string>
#include <vector>
#include <pqxx/pqxx> //PostgreSQL C++ interface, compiles.

#include "BQStructs.H"
#include "strlib.H"

using namespace std;
using namespace pqxx;

const std::string Connection="host=dbwebu.cs.brown.edu dbname=bikequestri2 user=relminya password=coemouri";


class DBInterface {
  
   //default constructor, destructor

private:
  pqxx::result executeTransaction(pqxx::connection* c, std::string sql);
  pqxx::result executeNonTransaction(pqxx::connection* c, std::string sql);
  pqxx::connection* getConnection();
  pqxx::connection* makeConnection();
  void tryDisconnect(pqxx::connection* c);
  vector<seg_t*>* processRDQUANTTuple (pqxx::result& R);
  void addQUALResults(std::vector<seg_t*>* segvector, pqxx::connection* c);

public:

  //EMPTY CONSTRUCTOR AND DESTRUCTOR SINCE THERE ARE NO MEMBER FUNCTIONS.
  DBInterface ();
  ~DBInterface ();

  /**************************************
   *Method: getSegment
   *Parameters: string routeid
   *Returns: STL vector of streetSeg(s)
   *Author: relminya
   *Date:   3.15.2005
   *
   *
   *Description: Converts routeid into an int
   * and then queries database for tuples 
   * with said routeid. Returns vector although
   * we will always have only one segment. This
   * is for continuity with the other methods and 
   * the helper methods.
   *
   *Error Codes: Returns Empty Vector if things go wrong.
   */
  vector<seg_t*>* getSegment(std::string routeid);
 
  /**************************************
   *Method: getStreetsAt
   *Parameters: intersection i
   *Returns: STL vector of streetSeg(s)
   *Author: relminya
   *Date:   3.15.2005
   *
   *
   *Description: Queries the database for
   * all streets that either start or end
   * with intersection i. Returns an STL
   * vector of all queried matches, each match
   * will be a filled streetSeg struct. Using
   * STL vector because of ease of interface,
   * the fact that this doesnt have to be sorted,
   * and because insertion and removal at the end
   * (the only type used in this case) is constant
   * time, it becomes the most efficient thing to use.
   *
   *Error Codes:  Returns Empty Vector if things go wrong.
   * 
   **************************************/
  vector<seg_t*>* getStreetsAt( isect_t* i );
  
  /**************************************
   *Method: getPath
   *Parameters: intersection from, intersection to
   *Returns: STL vector of streetSeg(s) 
   *Author: relminya
   *Date:   3.15.2005
   *
   *
   *Description: Returns an STL vector of street
   * segments that make up a single street.
   * For example, Thayer St. between Meeting and Waterman
   * is made up of Thayer betw. Meeting->Euclid, Euclid->Angell
   * Angell->Waterman (pardon me if wrong :-p). In the DB
   * it is very useful to keep road sections this small, but for 
   * the use of AI, UI, this should be one road section, 
   * and this  method helps in the detection of this. 
   * Could ostensibly return a queue, because order is important 
   * here, but consistency is also an issue with 
   * the interface, and vector is as good a choice. 
   *
   *Error Codes: returns NULL if record doesnt exist
   *
   **************************************/
  //* Returns an STL vector of street segments that make up a single street. For example, Thayer St. between Meeting and Waterman is made up of Thayer between Meeting and Euclid, Euclid and Angell, Angell and Waterman. In the DB, it is very useful to keep road sections this small, but for the use of the AI and the UI, this should be one road section, and this method helps in the detection of this. Could ostensibly return a queue, because order is important here, but consistency is also an issue with the interface, and vector is as good a choice. 

  vector<seg_t*>* getPath( isect_t* from, 
                           isect_t* to);

  //* Arc version of the STL-based getPath(...)
  vector<segComps_t*>* getPathArcs( isect_t* from,
                                    isect_t* to );
  /**************************************
   *Method: getMatches
   *Parameters: string streetName: name of street
   *            string town: town name
   *            string state: two letter state code
   *            string zip: five digit zip
   *            double address: number on street
   *Returns: STL vector of streetSegs
   *Author: relminya
   *Date:   3.15.2005
   *
   *
   *Description: Given user entered streetName, etc
   * return all streetSegs that match the general description
   * of the road given by the parameters. What elements
   * are required of the parameters is dictated by the UI's
   * form checking. If the number of matches exceeds what
   * is easily displayable by UI this interface will return
   * an error, and the user will be forced to reenter search 
   * terms. 
   * 
   *
   *Error Codes: returns NULL if record doesnt exist
   *
   **************************************/

  vector<seg_t*>* getMatches ( std::vector<string> streetName,
                              string town,
                              string state,
                              string zip,
                              double address );
  
  /**************************************
   *Method: addQuantRanking
   *Parameters: seg_t where: which segment has been clicked
   *            double x_val: votes average
   *            int numX_val: quantity of votes
   *
   *Returns: int
   *Author: relminya
   *Date:   3.24.2005
   *
   *
   *Description: given a streetSeg, and updated
   * rankings information we will do a SQL insert
   * or update to make the database reflect the
   * new information on the road. Returns an int for 
   * error codes. Not per user of course as there
   * are no users in BQ v1. Since there are many
   * rankings per segment, the mechanism to addRanking
   * is as follows: a call to getRanking is done
   * to recieve existing data on the road (the number
   * of votes for shoulder, and the average of it, etc)
   * With the current information, the rankings code
   * will average the new information, add a vote to the
   * total, and call addRanking() with the newly
   * calculated information.
   *
   *Error Codes: 1 if operation successful
   *             -1 if seg_t doesnt exist
   *             -2 if record is locked
   *             -3 if range for input numbers is not w/in BQ admissible range
   *             -4 other reason
   *
   **************************************/

  int addQuantRanking ( seg_t* where,
                        double shoulder_val,
                        int numShoulder_val,
                        double traffic_val,
                        int numTraffic_val,
                        double condition_val,
                        int numCondition_val,
                        double steepness_val,
                        int numSteepness_val );
  
  /**************************************
   *Method: addQualRanking
   *Parameters: seg_t where: which segment has been clicked
   *            string comment:
   *            int commenttype: based on enum in BQStructs, what type? 
   *
   *Returns: int
   *Author: relminya
   *Date:   3.24.2005
   *
   *Description: Interface to add qualitative comments to
   * bikequest database. Based on the enumeration
   * in BQStructs, the caller will give what type of 
   * comment it is. This method, in addition to adding
   * this to the database, will concatenate the current date
   * to the comment. 
   *
   *Error Codes: 1 if operation successful
   *             -1 if seg_t doesnt exist
   *             -2 if record is locked
   *             -3 if incorrect commenttype
   *             -4 other
   **************************************/

  int addQualRanking ( seg_t* where,
                       string comment,
                       int commenttype,
                       string author);
  
  /**************************************
   *Method: getRanking
   *Parameters: intersection from, intersection to
   *Returns: streetSeg
   *Author: relminya
   *Date:   3.15.2005
   *
   *
   *Description: Given a street segment that starts
   * with from, and ends with to, query the database
   * for a row which meets the from, to criteria. 
   * Also fills out a streetSeg struct with the information
   * returned. The data that is needed out of the street
   * segment is its ranking information. The qualitative
   * information from tables is parsed here, and put into
   * a multimap for ease of information retrieval. 
   *
   *Error Codes: returns NULL if record doesnt exist.
   **************************************/
  seg_t* getRanking ( isect_t* from,
                      isect_t* to );
  
  /**************************************
   *Method: getArcs 
   *Parameters: pathDesc fullpath
   *Returns: String
   *Author: relminya
   *Date:   3.21.2005
   *
   *
   *Description: Given a full path description
   * we will traverse the linked list of street segments
   * and return a string of comma separated values 
   * that are the exact point to point geometry of the streets
   * in the path. Used by mapvis. Mapvis will parse the numbers
   * sent back and convert the stateplane coordinates to 
   * their own xy coordinate plane. 
   *
   *Error Codes: returns NULL if all segs arent found.
   *             returns String with names of unfound segs if some are found.
   **************************************/
  vector<segComps_t*>* getArcs (  );
  
  
  
}; 
  
#endif

---