Using MySQL Library

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Using MySQL Library

    Hallo,

    derzeit arbeite ich an einem IRC Bot, der bestimmte Inhalte aus einem Channel in einer Datenbank schreiben soll. Da der Bot Platformunabhängig sein soll, habe ich mich für die Sprache C++ entschieden.

    Um aber überhaupt mit C/C++ MySQL nutzen zu können, kann man die MySQL++ API nutzen. Hier habe ich eine kleine Klasse geschrieben, die ein MYSQL Objekt initialisiert, zum Server eine Verbindung aufbaut und einen Query ausführt.
    Wohl angemerkt: Das Ganze ist noch recht unvollständig, Grundfunktionalitäten sind aber implementiert. Außerdem, der Query ist noch nicht geschützt, SQL Injections sind also möglich!

    Um die Klasse nutzen zu können, muss man unter Windows die mysql++ API installieren und die include- und lib Pfade angeben. Außerdem ist es nötig die windows.h, noch bevor man die mysql.h included, einzufügen!

    Unter Linux installiert man sich einfach das Paket mysql und teilt dem Compiler (ich habe g++ genutzt) mit die Verzeichnisse /usr/include/mysql/ und /usr/lib/mysql/ nach den Includes und Librarys zu durchsuchen.


    g++ -c -I/usr/include/mysql main.cpp
    g++ -o main main.o -L/usr/lib/mysql -lmysqlclient -lz



    Desweiteren würde ich um etwas Feedback bitten. Was ist daran schön, was ist weniger schön programmiert? Was ließe sich besser implementieren und vorallem wie?


    Quellcode

    1. /* SQL Klasse zum Zugriff auf mysql Datenbanken mit C++.
    2. *
    3. */
    5. #ifndef SQL_H
    6. #define SQL_H
    8. #define MAX_IRC_TEXT_LENGHT 512
    9. #define STEP 8
    11. #include <iostream>
    12. #include <mysql.h>
    13. #include <string>
    15. using namespace std;
    17. class sql {
    18. private:
    19. char *pHost;
    20. int pHost_sz;
    22. char *pUser;
    23. int pUser_sz;
    25. char *pPw;
    26. int pPw_sz;
    28. char *pDb;
    29. int pDb_sz;
    31. bool connected;
    33. void sql_init();
    34. void sql_error();
    35. bool sql_connect();
    36. void sql_disconnect();
    38. public:
    39. // Das MYSQL Objekt aus der mysql.h
    40. MYSQL *my;
    42. // Konstruktor / Destruktor
    43. sql(char *_host, char *_user, char *_pw, char *_db);
    44. ~sql();
    46. // Methoden
    48. // debugging Methode
    49. void DEBUG();
    51. // Verbindung aufbauen
    53. // Query ausführen
    54. bool sql_query(string query);
    55. };
    57. // Konstruktor
    58. sql::sql(char *_host, char *_user, char *_pw, char *_db) {
    59. this->pHost = NULL;
    60. this->pHost_sz = 0;
    62. this->pUser = NULL;
    63. this->pUser_sz = 0;
    65. this->pPw = NULL;
    66. this->pPw_sz = 0;
    68. this->pDb = NULL;
    69. this->pDb_sz = 0;
    71. for(int i=0; i<=strlen(_host); i++) {
    72. if(i >= pHost_sz) {
    73. char *c = new char[this->pHost_sz+STEP];
    75. for(int j=0; j<pHost_sz; j++) {
    76. c[j] = this->pHost[j];
    77. }
    79. if(this->pHost == NULL)
    80. delete[] this->pHost;
    82. this->pHost = c;
    83. this->pHost_sz += STEP;
    85. }
    86. this->pHost[i] = _host[i];
    87. }
    90. for(int i=0; i<=strlen(_user); i++) {
    91. if(i >= pUser_sz) {
    92. char *c = new char[this->pUser_sz+STEP];
    94. for(int j=0; j<pUser_sz; j++) {
    95. c[j] = this->pUser[j];
    96. }
    98. if(this->pUser == NULL)
    99. delete[] this->pUser;
    101. this->pUser = c;
    102. this->pUser_sz += STEP;
    103. }
    104. this->pUser[i] = _user[i];
    105. }
    108. for(int i=0; i<=strlen(_pw); i++) {
    109. if(i >= pPw_sz) {
    110. char *c = new char[this->pPw_sz+STEP];
    112. for(int j=0; j<pPw_sz; j++) {
    113. c[j] = this->pPw[j];
    114. }
    116. if(this->pPw == NULL)
    117. delete[] this->pPw;
    119. this->pPw = c;
    120. this->pPw_sz += STEP;
    121. }
    122. this->pPw[i] = _pw[i];
    123. }
    126. for(int i=0; i<=strlen(_db); i++) {
    127. if(i >= pDb_sz) {
    128. char *c = new char[this->pDb_sz+STEP];
    130. for(int j=0; j<pDb_sz; j++) {
    131. c[j] = this->pDb[j];
    132. }
    134. if(this->pDb == NULL)
    135. delete[] this->pDb;
    137. this->pDb = c;
    138. this->pDb_sz += STEP;
    139. }
    140. this->pDb[i] = _db[i];
    141. }
    143. // Nachdem die Parameter gesetzt wurden, wird das Objekt initialisiert
    144. this->sql_init();
    145. }
    147. sql::~sql() {
    148. if(this->pHost != NULL) {
    149. delete[] pHost;
    150. }
    151. if(this->pUser != NULL) {
    152. delete[] pUser;
    153. }
    154. if(this->pPw != NULL) {
    155. delete[] pPw;
    156. }
    157. if(this->pDb != NULL) {
    158. delete[] pDb;
    159. }
    160. }
    162. void sql::sql_error() {
    163. // Selbsterklärend
    164. cerr << "Errorcode: " << mysql_errno(my) << "\n" << mysql_error(my);
    165. //exit(EXIT_FAILURE);
    166. }
    168. void sql::DEBUG() {
    169. cout << this->pHost << endl;
    170. cout << this->pUser << endl;
    171. cout << this->pPw << endl;
    172. cout << this->pDb << endl;
    173. }
    175. void sql::sql_init() {
    176. this->connected = false;
    178. if((this->my = mysql_init(NULL)) == NULL) {
    179. cerr << "Fehler beim initialisieren.";
    180. exit(EXIT_FAILURE);
    181. }
    182. }
    184. void sql::sql_disconnect() {
    185. if(this->connected) {
    186. mysql_close(my);
    187. this->connected = false;
    188. }
    189. }
    191. bool sql::sql_connect() {
    192. // Zur Datenbank verbinden:
    193. if(this->connected == false) {
    194. if(mysql_real_connect(
    195. my, /* *MYSQL Handler */
    196. this->pHost, /* Host */
    197. this->pUser, /* User */
    198. this->pPw, /* Passwort */
    199. this->pDb, /* Datenbank */
    200. 0, /* Port */
    201. NULL, /* Socket */
    202. 0) /* Flags */ == NULL) {
    203. // Bei einem Fehler die error Methode ausführen
    204. this->sql_error();
    205. return false;
    206. }
    207. else {
    208. this->connected = true;
    209. return true;
    210. }
    211. }
    213. }
    215. bool sql::sql_query(string query) {
    217. if(this->connected == false) {
    218. if(this->sql_connect() == false) {
    219. return false;
    220. }
    221. }
    223. // in dynamic char casten
    224. char *sql_char = NULL;
    225. int sql_char_sz = 0;
    226. for(int i=0; i<=query.size(); i++) {
    227. // Ist das Query länger als der sql_char?
    228. if(i >= sql_char_sz) {
    229. // Joa, ist er, also ein neues - größeres - Char erzeugen
    230. char *c = new char[sql_char_sz+STEP];
    231. // Daten kopieren
    232. for(int j=0; j<sql_char_sz; j++)
    233. c[j] = sql_char[j];
    234. // Altes Char löschen
    235. if(sql_char != NULL)
    236. delete[] sql_char;
    237. // c zuweisen
    238. sql_char = c;
    239. sql_char_sz += STEP;
    240. }
    241. // Dateneintragen
    242. sql_char[i] = query[i];
    243. }
    245. // Query ausführen
    246. if(mysql_real_query(this->my, sql_char, (unsigned) (long) strlen(sql_char)))
    247. this->sql_error();
    249. if(this->connected == true) {
    250. this->sql_disconnect();
    251. }
    253. return true;
    254. }
    256. #endif
    Alles anzeigen