dbqueries_source

SUBMITTED BY: davalillocm

DATE: July 29, 2021, 5:53 a.m.

FORMAT: Text only

SIZE: 99.6 kB

Raw Download

HITS: 551

Report
  1. #include "dbqop.h"
  3. namespace databases{
  5. namespace odbc_database_operations{
  7. //STRUCTS DEFINITIONS
  8. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  9. //DBConnection DEFINITIONS
  10. DBConnection::DBConnection():
  11. environment_handle(nullptr),database_connection_handle(nullptr),
  12. environment_handle_allocated(false),connection_handle_allocated(false),
  13. sql_command_prepared(false),asynch_support(false),is_connected(false),
  14. is_open(false),flag(0),connection_string(""),output_connection_string(""),
  15. server_string(""),user_string(""),password_string(""),last_message("")
  16. {
  18. }
  20. DBConnection::~DBConnection()
  21. {
  22. // Connection
  23. if(database_connection_handle!=SQL_NULL_HDBC)
  24. {
  25. SQLDisconnect(database_connection_handle);
  26. SQLFreeHandle(SQL_HANDLE_DBC,database_connection_handle);
  27. database_connection_handle=SQL_NULL_HDBC;
  28. }
  30. // Environment
  31. if(environment_handle!=SQL_NULL_HENV)
  32. {
  33. SQLFreeHandle(SQL_HANDLE_ENV,environment_handle);
  34. environment_handle=SQL_NULL_HENV;
  35. }
  36. }
  38. DBConnection& DBConnection::operator=(const DBConnection& rhs)
  39. {
  40. if(this != &rhs)// handle self assignment
  41. {
  42. this->environment_handle_allocated=rhs.environment_handle_allocated;
  43. this->connection_handle_allocated=rhs.connection_handle_allocated;
  44. this->sql_command_prepared=rhs.sql_command_prepared;
  45. this->asynch_support=rhs.asynch_support;
  46. this->is_connected=rhs.is_connected;
  47. this->is_open=rhs.is_open;
  48. this->connection_string=rhs.connection_string;
  49. this->output_connection_string=rhs.output_connection_string;
  50. this->server_string=rhs.server_string;
  51. this->user_string=rhs.user_string;
  52. this->password_string=rhs.password_string;
  53. this->last_message=rhs.last_message;
  54. this->flag=rhs.flag;
  55. this->environment_handle=rhs.environment_handle;//Environment handle
  56. this->database_connection_handle=rhs.database_connection_handle;//Database connection handle
  57. }
  58. return *this;
  59. }
  61. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  62. //DBColumn DEFINITIONS
  63. DBColumn::DBColumn():
  64. table_owner(0),column_type(0),catalog_name_length(0),schema_name_length(0),
  65. table_name_length(0),column_name_length(0),column_type_name_length(0),
  66. data_length_indicator(0),column_buffer_length(0),column_buffer(nullptr)
  67. {
  69. }
  71. DBColumn::~DBColumn()
  72. {
  73. delete[] column_buffer;
  74. }
  76. DBColumn::DBColumn(const short& new_column_type,const long& buffer_length):
  77. table_owner(0),column_type(new_column_type),catalog_name_length(0),
  78. schema_name_length(0),table_name_length(0),column_name_length(0),
  79. column_type_name_length(0),data_length_indicator(0),
  80. column_buffer_length(buffer_length),column_buffer(nullptr)
  81. {
  82. column_buffer=new SQLCHAR[buffer_length];
  83. }
  85. DBColumn::DBColumn(const DBColumn& other):
  86. table_owner(0),column_type(0),catalog_name_length(0),schema_name_length(0),
  87. table_name_length(0),column_name_length(0),column_type_name_length(0),
  88. data_length_indicator(0),column_buffer_length(0),column_buffer(nullptr)
  89. {
  90. table_owner=other.table_owner;
  91. column_type=other.column_type;
  92. catalog_name_length=other.catalog_name_length;
  93. schema_name_length=other.schema_name_length;
  94. table_name_length=other.table_name_length;
  95. column_name_length=other.column_name_length;
  96. column_type_name_length=other.column_type_name_length;
  97. data_length_indicator=other.data_length_indicator;
  98. column_buffer_length=other.column_buffer_length;//Max byte length of the column
  99. memcpy(catalog_name,other.catalog_name,SQL_MAX_CATALOG_NAME_LEN);
  100. memcpy(schema_name,other.schema_name,SQL_MAX_SCHEMA_NAME_LEN);
  101. memcpy(table_name,other.table_name,SQL_MAX_TABLE_NAME_LEN);
  102. memcpy(column_name,other.column_name,SQL_MAX_COLUMN_NAME_LEN);
  103. memcpy(column_type_name,other.column_type_name,MAX_COL_TYPE_NAME_LENGTH);
  104. column_buffer=new SQLCHAR[other.column_buffer_length];
  105. memcpy(column_buffer,other.column_buffer,other.column_buffer_length);
  106. }
  108. DBColumn& DBColumn::operator=(const DBColumn& rhs)
  109. {
  110. if(this != &rhs)
  111. {
  112. this->table_owner=rhs.table_owner;
  113. this->column_type=rhs.column_type;
  114. this->catalog_name_length=rhs.catalog_name_length;
  115. this->schema_name_length=rhs.schema_name_length;
  116. this->table_name_length=rhs.table_name_length;
  117. this->column_name_length=rhs.column_name_length;
  118. this->column_type_name_length=rhs.column_type_name_length;
  119. this->data_length_indicator=rhs.data_length_indicator;
  120. this->column_buffer_length=rhs.column_buffer_length;//Max byte length of the column
  121. memcpy(this->catalog_name,rhs.catalog_name,SQL_MAX_CATALOG_NAME_LEN);
  122. memcpy(this->schema_name,rhs.schema_name,SQL_MAX_SCHEMA_NAME_LEN);
  123. memcpy(this->table_name,rhs.table_name,SQL_MAX_TABLE_NAME_LEN);
  124. memcpy(this->column_name,rhs.column_name,SQL_MAX_COLUMN_NAME_LEN);
  125. memcpy(this->column_type_name,rhs.column_type_name,MAX_COL_TYPE_NAME_LENGTH);
  126. this->column_buffer=new SQLCHAR[rhs.column_buffer_length];
  127. memcpy(this->column_buffer,rhs.column_buffer,rhs.column_buffer_length);
  128. }
  129. return *this;
  130. }
  132. brw::Archive& DBColumn::operator&(brw::Archive& ar)
  133. {
  134. return ar;
  135. }
  136. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  137. //DBRow DEFINITIONS
  138. DBRow::DBRow():
  139. table_owner(0),row_index(0),row_data()
  140. {
  141. }
  143. DBRow::DBRow(const DBRow& other):
  144. table_owner(other.table_owner),row_index(other.row_index),row_data(other.row_data)
  145. {
  146. }
  148. DBRow::DBRow(const uintptr_t& row_table_owner,const UINT& new_row_index):
  149. table_owner(0),row_index(new_row_index),row_data()
  150. {
  151. DBTable table=*reinterpret_cast<DBTable*>(row_table_owner);
  152. table_owner=row_table_owner;
  153. //row_index=new_row_index;
  154. row_data=RowData(table.total_columns);
  155. for(short i=0;i<table.total_columns;i++)
  156. {
  157. CellData value;
  158. value.buffer_size=table.table_columns[i].column_buffer_length;
  159. value.buffer=new SQLCHAR[table.table_columns[i].column_buffer_length];
  160. row_data[i]=value;
  161. }
  162. }
  164. DBRow& DBRow::operator=(const DBRow& rhs)
  165. {
  166. if(this != &rhs)
  167. {
  168. this->table_owner=rhs.table_owner;
  169. this->row_index=rhs.row_index;
  170. this->row_data=rhs.row_data;
  171. }
  172. return *this;
  173. }
  175. DBRow::~DBRow()
  176. {
  178. }
  180. void* DBRow::getValue(const short& column_index) const
  181. {
  182. DBTable table=*reinterpret_cast<DBTable*>(table_owner);
  183. if(table.total_columns==0)
  184. {
  185. return nullptr;
  186. }
  187. CellData value=row_data[column_index];
  188. if(!value.buffer)
  189. {
  190. return nullptr;
  191. }
  192. long len=value.buffer_size;
  193. switch(table.table_columns[column_index].column_type)
  194. {
  195. case SQL_BIT:
  196. {
  198. break;
  199. }
  200. case SQL_CHAR:
  201. {
  202. char data1[len+1];
  203. for(long i=0;i<len;i++)
  204. {
  205. data1[i]=(char)value.buffer[i];
  206. }
  207. data1[len]='\0';
  208. static std::string value1;
  209. value1=std::string(data1);
  210. return &value1;
  211. }
  212. case SQL_VARCHAR:
  213. {
  214. char* data2=new char[len+1];
  215. for(long i=0;i<len;i++)
  216. {
  217. data2[i]=(char)value.buffer[i];
  218. }
  219. data2[len]='\0';
  220. static std::string value2;
  221. value2=std::string(data2);
  222. return &value2;
  223. }
  224. case SQL_LONGVARCHAR:
  225. {
  227. break;
  228. }
  229. case SQL_WCHAR:
  230. {
  232. break;
  233. }
  234. case SQL_WVARCHAR:
  235. {
  237. break;
  238. }
  239. case SQL_WLONGVARCHAR:
  240. {
  242. break;
  243. }
  244. case SQL_TINYINT:
  245. {
  246. PSQLCHAR data7=reinterpret_cast<PSQLCHAR>(value.buffer);
  247. static unsigned char value7;
  248. value7=(unsigned char)(*data7);
  249. return &value7;
  250. }
  251. case SQL_SMALLINT:
  252. {
  253. short* data8=reinterpret_cast<short*>(value.buffer);
  254. static short value8;
  255. value8=(short)(*data8);
  256. return &value8;
  257. }
  258. case SQL_INTEGER:
  259. {
  260. int* data9=reinterpret_cast<int*>(value.buffer);
  261. static int value9;
  262. value9=(int)(*data9);
  263. return &value9;
  264. break;
  265. }
  266. case SQL_BIGINT:
  267. {
  268. long* data10=reinterpret_cast<long*>(value.buffer);
  269. static long value10;
  270. value10=long(*data10);
  271. return &value10;
  272. }
  273. case SQL_DECIMAL:
  274. {
  276. break;
  277. }
  278. case SQL_NUMERIC:
  279. {
  281. break;
  282. }
  283. case SQL_REAL:
  284. {
  286. break;
  287. }
  288. case SQL_FLOAT:
  289. {
  290. float* data14=reinterpret_cast<float*>(value.buffer);
  291. static float value14;
  292. value14=float(*data14);
  293. return &value14;
  294. }
  295. case SQL_DOUBLE:
  296. {
  297. double* data15=reinterpret_cast<double*>(value.buffer);
  298. static double value15;
  299. value15=double(*data15);
  300. return &value15;
  301. }
  302. case SQL_DATE:
  303. {
  305. break;
  306. }
  307. case SQL_TIME:
  308. {
  310. break;
  311. }
  312. case SQL_TYPE_TIMESTAMP:
  313. {
  314. PTIMESTAMP buffer18=reinterpret_cast<PTIMESTAMP>(value.buffer);
  315. tm data18;
  317. data18.tm_year=buffer18->year;
  318. data18.tm_mon=buffer18->month;
  319. data18.tm_mday=buffer18->day;
  320. data18.tm_hour=buffer18->hour;
  321. data18.tm_min=buffer18->minute;
  322. data18.tm_sec=buffer18->second;
  324. tm timeinfo = {};
  325. timeinfo.tm_year = data18.tm_year - 1900;
  326. timeinfo.tm_mon = data18.tm_mon - 1;
  327. timeinfo.tm_mday = data18.tm_mday;
  328. mktime(&timeinfo);
  329. data18.tm_yday = timeinfo.tm_yday;
  330. data18.tm_wday=timeinfo.tm_wday;
  332. static tm value18;
  333. value18=data18;
  334. return &value18;
  335. }
  336. case SQL_BINARY:
  337. {
  338. break;
  339. }
  340. case SQL_VARBINARY:
  341. {
  342. break;
  343. }
  344. case SQL_LONGVARBINARY:
  345. {
  346. break;
  347. }
  348. default:
  349. {
  350. break;
  351. }
  352. }
  353. return nullptr;
  354. }
  356. void DBRow::getValue(const short& column_index,CellData& value) const
  357. {
  358. DBTable table=*reinterpret_cast<DBTable*>(table_owner);
  359. if(table.total_columns==0)
  360. {
  361. value.buffer=nullptr;
  362. value.buffer_size=0;
  363. }
  364. else
  365. {
  366. CellData value_data;
  367. CellData cell=row_data[column_index];
  368. value_data.buffer_size=cell.buffer_size;
  369. value_data.buffer=new SQLCHAR[value_data.buffer_size];
  370. memcpy(
  371. value_data.buffer,
  372. cell.buffer,
  373. cell.buffer_size
  374. );
  375. value=value_data;
  376. }
  377. }
  379. void DBRow::setValue(const short& column_index,void* value) const
  380. {
  381. }
  383. void DBRow::setValue(const short& column_index,const CellData& value)
  384. {
  385. row_data[column_index]=value;
  386. }
  391. DBRow DBRow::cloneRow() const
  392. {
  393. DBRow clone;
  394. clone.table_owner=table_owner;
  395. clone.row_index=row_index;
  396. clone.row_data=row_data;
  397. return clone;
  398. }
  399. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  400. //DBTable DEFINITIONS
  401. DBTable::DBTable():
  402. sql_statement(""),database_name(""),catalog_name(""),schema_name(""),table_name(""),
  403. total_columns(0),total_primary_key_columns(0),total_foreign_key_columns(0),
  404. primary_key_columns(nullptr),foreign_key_columns(nullptr),total_rows(0),
  405. table_columns(nullptr),statement_handle(nullptr),table_data(),
  406. is_primary_keys_set(false),is_foreign_keys_set(false)
  407. {
  408. }
  410. DBTable::~DBTable()
  411. {
  412. if(statement_handle!=SQL_NULL_HSTMT)
  413. {
  414. SQLFreeHandle(SQL_HANDLE_STMT,statement_handle);
  415. statement_handle=SQL_NULL_HSTMT;
  416. }
  417. delete[] table_columns;
  418. delete[] primary_key_columns;
  419. }
  421. DBTable::DBTable(const short& new_total_columns,DBColumn* new_table_columns):
  422. sql_statement(""),database_name(""),catalog_name(""),schema_name(""),table_name(""),
  423. total_columns(0),total_primary_key_columns(0),total_foreign_key_columns(0),
  424. primary_key_columns(nullptr),foreign_key_columns(nullptr),total_rows(0),
  425. table_columns(nullptr),statement_handle(nullptr),table_data(),
  426. is_primary_keys_set(false),is_foreign_keys_set(false)
  427. {
  428. total_columns=new_total_columns;
  429. table_columns=new DBColumn[new_total_columns];
  430. primary_key_columns=new short[new_total_columns];
  431. foreign_key_columns=new short[new_total_columns];
  432. for(short i=0;i<new_total_columns;i++)
  433. {
  434. table_columns[i]=DBColumn(new_table_columns[i]);
  435. }
  436. table_data=TableData();
  437. }
  439. DBTable::DBTable(const DBTable& other):
  440. sql_statement(other.sql_statement),database_name(other.database_name),
  441. catalog_name(other.catalog_name),schema_name(other.schema_name),
  442. table_name(other.table_name),total_columns(0),total_primary_key_columns(0),
  443. total_foreign_key_columns(0),primary_key_columns(nullptr),
  444. foreign_key_columns(nullptr),total_rows(other.total_rows),table_columns(nullptr),
  445. statement_handle(nullptr),table_data(),is_primary_keys_set(false),
  446. is_foreign_keys_set(false)
  447. {
  448. total_columns=other.total_columns;
  449. total_primary_key_columns=other.total_primary_key_columns;
  450. total_foreign_key_columns=other.total_foreign_key_columns;
  451. table_columns=new DBColumn[other.total_columns];
  452. primary_key_columns=new short[other.total_primary_key_columns];
  453. foreign_key_columns=new short[other.total_foreign_key_columns];
  454. for(short i=0;i<other.total_columns;i++)
  455. {
  456. table_columns[i]=other.table_columns[i];
  457. }
  458. for(short i=0;i<other.total_primary_key_columns;i++)
  459. {
  460. primary_key_columns[i]=other.primary_key_columns[i];
  461. }
  462. for(short i=0;i<other.total_foreign_key_columns;i++)
  463. {
  464. foreign_key_columns[i]=other.foreign_key_columns[i];
  465. }
  466. statement_handle=other.statement_handle;
  467. table_data=other.table_data;
  468. }
  470. DBTable& DBTable::operator=(const DBTable& rhs)
  471. {
  472. if(this != &rhs)
  473. {
  474. this->sql_statement=rhs.sql_statement;
  475. this->database_name=rhs.database_name;
  476. this->catalog_name=rhs.catalog_name;
  477. this->schema_name=rhs.schema_name;
  478. this->table_name=rhs.table_name;
  479. this->total_columns=rhs.total_columns;
  480. this->total_primary_key_columns=rhs.total_primary_key_columns;
  481. this->total_foreign_key_columns=rhs.total_foreign_key_columns;
  482. this->total_rows=rhs.total_rows;
  483. this->table_columns=new DBColumn[rhs.total_columns];
  484. this->primary_key_columns=new short[rhs.total_primary_key_columns];
  485. this->foreign_key_columns=new short[rhs.total_foreign_key_columns];
  486. for(short i=0;i<rhs.total_columns;i++)
  487. {
  488. this->table_columns[i]=rhs.table_columns[i];
  489. }
  490. for(short i=0;i<rhs.total_primary_key_columns;i++)
  491. {
  492. this->primary_key_columns[i]=rhs.primary_key_columns[i];
  493. }
  494. for(short i=0;i<rhs.total_foreign_key_columns;i++)
  495. {
  496. this->foreign_key_columns[i]=rhs.foreign_key_columns[i];
  497. }
  498. this->statement_handle=rhs.statement_handle;
  499. this->table_data=rhs.table_data;
  500. this->is_primary_keys_set=rhs.is_primary_keys_set;
  501. this->is_foreign_keys_set=rhs.is_foreign_keys_set;
  502. }
  503. return *this;
  504. }
  506. brw::Archive& DBTable::operator&(brw::Archive& ar)
  507. {
  508. switch(ar.getFileVersion())
  509. {
  510. case FILE_VERSION:
  511. {
  512. break;
  514. }
  515. default:
  516. {
  517. break;
  518. }
  519. }
  520. return ar;
  521. }
  525. DBRow DBTable::newRow() const
  526. {
  527. DBRow new_row=DBRow(reinterpret_cast<uintptr_t>(this),0);
  528. return new_row;
  529. }
  531. DBRow DBTable::getRow(const UINT& row_index) const
  532. {
  533. DBRow row=DBRow(reinterpret_cast<uintptr_t>(this),row_index);
  534. for(short i=0;i<total_columns;i++)
  535. {
  536. CellData value;
  537. getValue(row_index,i,value);
  538. row.setValue(i,value);
  539. }
  540. return row;
  541. }
  543. void DBTable::addRow(UINT& new_row_index)
  544. {
  545. RowData row_data=RowData(total_columns);
  546. for(short i=0;i<total_columns;i++)
  547. {
  548. CellData value;
  549. value.buffer_size=table_columns[i].column_buffer_length;
  550. value.buffer=new SQLCHAR[table_columns[i].column_buffer_length];
  551. row_data[i]=value;
  552. }
  553. table_data.push_back(row_data);
  554. new_row_index=total_rows;
  555. total_rows++;
  556. }
  558. void DBTable::addRow(const DBRow& new_row)
  559. {
  560. RowData row_data=RowData(total_columns);
  561. for(short i=0;i<total_columns;i++)
  562. {
  563. CellData value;
  564. new_row.getValue(i,value);
  565. row_data[i]=value;
  566. }
  567. table_data.push_back(row_data);
  568. total_rows++;
  569. }
  571. void* DBTable::getValue(const UINT& row_index,const short& column_index) const
  572. {
  573. if((total_columns==0) || (total_rows==0))
  574. {
  575. return nullptr;
  576. }
  577. CellData value=table_data[row_index][column_index];
  578. if(!value.buffer)
  579. {
  580. return nullptr;
  581. }
  582. long len=value.buffer_size;
  583. switch(table_columns[column_index].column_type)
  584. {
  585. case SQL_BIT:
  586. {
  588. break;
  589. }
  590. case SQL_CHAR:
  591. {
  592. char data1[len+1];
  593. for(long i=0;i<len;i++)
  594. {
  595. data1[i]=(char)value.buffer[i];
  596. }
  597. data1[len]='\0';
  598. static std::string value1;
  599. value1=std::string(data1);
  600. return &value1;
  601. }
  602. case SQL_VARCHAR:
  603. {
  604. char* data2=new char[len+1];
  605. for(long i=0;i<len;i++)
  606. {
  607. data2[i]=(char)value.buffer[i];
  608. }
  609. data2[len]='\0';
  610. static std::string value2;
  611. value2=std::string(data2);
  612. return &value2;
  613. }
  614. case SQL_LONGVARCHAR:
  615. {
  617. break;
  618. }
  619. case SQL_WCHAR:
  620. {
  622. break;
  623. }
  624. case SQL_WVARCHAR:
  625. {
  627. break;
  628. }
  629. case SQL_WLONGVARCHAR:
  630. {
  632. break;
  633. }
  634. case SQL_TINYINT:
  635. {
  636. PSQLCHAR data7=reinterpret_cast<PSQLCHAR>(value.buffer);
  637. static unsigned char value7;
  638. value7=(unsigned char)(*data7);
  639. return &value7;
  640. }
  641. case SQL_SMALLINT:
  642. {
  643. short* data8=reinterpret_cast<short*>(value.buffer);
  644. static short value8;
  645. value8=(short)(*data8);
  646. return &value8;
  647. }
  648. case SQL_INTEGER:
  649. {
  650. int* data9=reinterpret_cast<int*>(value.buffer);
  651. static int value9;
  652. value9=(int)(*data9);
  653. return &value9;
  654. break;
  655. }
  656. case SQL_BIGINT:
  657. {
  658. long* data10=reinterpret_cast<long*>(value.buffer);
  659. static long value10;
  660. value10=long(*data10);
  661. return &value10;
  662. }
  663. case SQL_DECIMAL:
  664. {
  666. break;
  667. }
  668. case SQL_NUMERIC:
  669. {
  671. break;
  672. }
  673. case SQL_REAL:
  674. {
  676. break;
  677. }
  678. case SQL_FLOAT:
  679. {
  680. float* data14=reinterpret_cast<float*>(value.buffer);
  681. static float value14;
  682. value14=float(*data14);
  683. return &value14;
  684. }
  685. case SQL_DOUBLE:
  686. {
  687. double* data15=reinterpret_cast<double*>(value.buffer);
  688. static double value15;
  689. value15=double(*data15);
  690. return &value15;
  691. }
  692. case SQL_DATE:
  693. {
  695. break;
  696. }
  697. case SQL_TIME:
  698. {
  700. break;
  701. }
  702. case SQL_TYPE_TIMESTAMP:
  703. {
  704. PTIMESTAMP buffer18=reinterpret_cast<PTIMESTAMP>(value.buffer);
  705. tm data18;
  707. data18.tm_year=buffer18->year;
  708. data18.tm_mon=buffer18->month;
  709. data18.tm_mday=buffer18->day;
  710. data18.tm_hour=buffer18->hour;
  711. data18.tm_min=buffer18->minute;
  712. data18.tm_sec=buffer18->second;
  714. tm timeinfo = {};
  715. timeinfo.tm_year = data18.tm_year - 1900;
  716. timeinfo.tm_mon = data18.tm_mon - 1;
  717. timeinfo.tm_mday = data18.tm_mday;
  718. mktime(&timeinfo);
  719. data18.tm_yday = timeinfo.tm_yday;
  720. data18.tm_wday=timeinfo.tm_wday;
  722. static tm value18;
  723. value18=data18;
  724. return &value18;
  725. }
  726. case SQL_BINARY:
  727. {
  729. break;
  730. }
  731. case SQL_VARBINARY:
  732. {
  734. break;
  735. }
  736. case SQL_LONGVARBINARY:
  737. {
  739. break;
  740. }
  741. default:
  742. {
  744. }
  745. }
  746. return nullptr;
  747. }
  749. void DBTable::getValue
  750. (
  751. const UINT& row_index,
  752. const short& column_index,
  753. CellData& value
  754. ) const
  755. {
  756. CellData cell=table_data[row_index][column_index];
  757. if(!cell.buffer)
  758. {
  759. value.buffer=nullptr;
  760. value.buffer_size=0;
  761. }
  762. else
  763. {
  764. value.buffer_size=cell.buffer_size;
  765. value.buffer=new SQLCHAR[cell.buffer_size];
  766. memcpy(value.buffer,cell.buffer,cell.buffer_size);
  767. }
  768. }
  770. void DBTable::setValue
  771. (
  772. const UINT& row_index,
  773. const short& column_index,
  774. void* value,
  775. const long& value_length
  776. )
  777. {
  778. CellData cell_value;
  779. if(!value)
  780. {
  781. cell_value.buffer=nullptr;
  782. cell_value.buffer_size=0;
  783. }
  784. else
  785. {
  786. long len;
  787. switch(table_columns[column_index].column_type)
  788. {
  789. case SQL_BIT:
  790. {
  791. break;
  792. }
  793. case SQL_CHAR:
  794. {
  795. char* buffer1=reinterpret_cast<char*>(value);
  796. len=sizeof(char);
  797. cell_value.buffer=new SQLCHAR[len];
  798. cell_value.buffer_size=len;
  799. memcpy(cell_value.buffer,buffer1,len);
  800. break;
  801. }
  802. case SQL_VARCHAR:
  803. {
  804. char* buffer2=reinterpret_cast<char*>(value);
  805. len=value_length;
  806. cell_value.buffer=new SQLCHAR[len];
  807. cell_value.buffer_size=len;
  808. memcpy(cell_value.buffer,buffer2,len);
  809. break;
  810. }
  811. case SQL_LONGVARCHAR:
  812. {
  813. break;
  814. }
  815. case SQL_WCHAR:
  816. {
  817. break;
  818. }
  819. case SQL_WVARCHAR:
  820. {
  821. break;
  822. }
  823. case SQL_WLONGVARCHAR:
  824. {
  825. break;
  826. }
  827. case SQL_TINYINT:
  828. {
  829. unsigned char* buffer7=reinterpret_cast<unsigned char*>(value);
  830. len=sizeof(unsigned char);
  831. cell_value.buffer=new SQLCHAR[len];
  832. cell_value.buffer_size=len;
  833. memcpy(cell_value.buffer,buffer7,len);
  834. break;
  835. }
  836. case SQL_SMALLINT:
  837. {
  838. short* buffer8=reinterpret_cast<short*>(value);
  839. len=sizeof(short);
  840. cell_value.buffer=new SQLCHAR[len];
  841. cell_value.buffer_size=len;
  842. memcpy(cell_value.buffer,buffer8,len);
  843. break;
  844. }
  845. case SQL_INTEGER:
  846. {
  847. int* buffer9=reinterpret_cast<int*>(value);
  848. len=sizeof(int);
  849. cell_value.buffer=new SQLCHAR[len];
  850. cell_value.buffer_size=len;
  851. memcpy(cell_value.buffer,buffer9,len);
  852. break;
  853. }
  854. case SQL_BIGINT:
  855. {
  856. long* buffer10=reinterpret_cast<long*>(value);
  857. len=sizeof(long);
  858. cell_value.buffer=new SQLCHAR[len];
  859. cell_value.buffer_size=len;
  860. memcpy(cell_value.buffer,buffer10,len);
  861. break;
  862. }
  863. case SQL_DECIMAL:
  864. {
  865. break;
  866. }
  867. case SQL_NUMERIC:
  868. {
  869. break;
  870. }
  871. case SQL_REAL:
  872. {
  873. break;
  874. }
  875. case SQL_FLOAT:
  876. {
  877. float* buffer14=reinterpret_cast<float*>(value);
  878. len=sizeof(float);
  879. cell_value.buffer=new SQLCHAR[len];
  880. cell_value.buffer_size=len;
  881. memcpy(cell_value.buffer,buffer14,len);
  882. break;
  883. }
  884. case SQL_DOUBLE:
  885. {
  886. double* buffer15=reinterpret_cast<double*>(value);
  887. len=sizeof(double);
  888. cell_value.buffer=new SQLCHAR[len];
  889. cell_value.buffer_size=len;
  890. memcpy(cell_value.buffer,buffer15,len);
  891. break;
  892. }
  893. case SQL_DATE:
  894. {
  895. break;
  896. }
  897. case SQL_TIME:
  898. {
  899. break;
  900. }
  901. case SQL_TYPE_TIMESTAMP:
  902. {
  903. PTIMESTAMP buffer18=reinterpret_cast<PTIMESTAMP>(value);
  904. len=sizeof(SQL_TIMESTAMP_STRUCT);
  905. cell_value.buffer=new SQLCHAR[len];
  906. cell_value.buffer_size=len;
  907. memcpy(cell_value.buffer,buffer18,len);
  908. break;
  909. }
  910. case SQL_BINARY:
  911. {
  912. break;
  913. }
  914. case SQL_VARBINARY:
  915. {
  916. break;
  917. }
  918. case SQL_LONGVARBINARY:
  919. {
  920. break;
  921. }
  922. default:
  923. {
  924. break;
  925. }
  926. }
  927. }
  928. table_data[row_index][column_index]=cell_value;
  929. }
  931. void DBTable::setValue
  932. (
  933. const UINT& row_index,
  934. const short& column_index,
  935. const CellData& value
  936. )
  937. {
  938. CellData cell;
  939. if(!value.buffer)
  940. {
  941. cell.buffer=nullptr;
  942. cell.buffer_size=0;
  943. }
  944. else
  945. {
  946. cell.buffer_size=value.buffer_size;
  947. cell.buffer=new SQLCHAR[value.buffer_size];
  948. memcpy(cell.buffer,value.buffer,value.buffer_size);
  949. }
  950. table_data[row_index][column_index]=cell;
  951. }
  953. bool DBTable::findRow
  954. (
  955. const short& key_column_index,
  956. const CellData& value,
  957. const UINT& starting_row_index,
  958. DBRow& row
  959. )
  960. {
  961. if(total_columns==0 || total_rows==0)
  962. {
  963. return false;
  964. }
  965. for(UINT i=starting_row_index;i<total_rows;i++)
  966. {
  967. if(memcmp
  968. (
  969. table_data[i][key_column_index].buffer,
  970. value.buffer,
  971. value.buffer_size
  972. )==0)
  973. {
  974. row=getRow(i);
  975. return true;
  976. }
  977. }
  978. return false;
  979. }
  981. bool DBTable::findRowPattern
  982. (
  983. const short& key_column_index,
  984. const std::string& value,
  985. const UINT& starting_row_index,
  986. DBRow& row
  987. ) const
  988. {
  989. if(total_columns==0 || total_rows==0)
  990. {
  991. return false;
  992. }
  993. const char* pattern;
  994. CellData cell;
  995. std::string::size_type pos=value.find_first_of('%');
  997. if(pos==std::string::npos)//When search is an exact search
  998. {
  999. pattern=new char[value.size()];
  1000. memcpy((char*)pattern,value.c_str(),value.size());
  1001. for(UINT i=starting_row_index;i<total_rows;i++)
  1002. {
  1003. cell=table_data[i][key_column_index];
  1004. if(cell.buffer)
  1005. {
  1006. if(std::strcmp(reinterpret_cast<char*>(cell.buffer),pattern)==0)
  1007. {
  1008. row=getRow(i);
  1009. return true;
  1010. }
  1011. }
  1012. }
  1013. }
  1014. else if(pos==0 && value.find_last_of('%')==(value.size()-1))//When search pattern is of the form %pattern%
  1015. {
  1016. std::string::size_type len=value.size()-2;
  1017. pattern=new char[len];
  1018. memcpy((char*)pattern,value.substr(1,len).c_str(),len);
  1019. for(UINT i=starting_row_index;i<total_rows;i++)
  1020. {
  1021. cell=table_data[i][key_column_index];
  1022. if(cell.buffer)
  1023. {
  1024. if(std::strstr(reinterpret_cast<char*>(cell.buffer),pattern))
  1025. {
  1026. row=getRow(i);
  1027. return true;
  1028. }
  1029. }
  1030. }
  1031. }
  1032. else if(pos==0)//When search pattern is of the form %pattern
  1033. {
  1034. std::string::size_type len=value.size()-1;
  1035. pattern=new char[len];
  1036. memcpy((char*)pattern,value.substr(1,len).c_str(),len);
  1037. char* match;
  1038. for(UINT i=starting_row_index;i<total_rows;i++)
  1039. {
  1040. cell=table_data[i][key_column_index];
  1041. if(cell.buffer)
  1042. {
  1043. if(cell.buffer_size>=(long)len)
  1044. {
  1045. match=std::strstr(reinterpret_cast<char*>(cell.buffer),pattern);
  1046. if(match)
  1047. {
  1048. if((match-reinterpret_cast<char*>(cell.buffer))==
  1049. (long)(cell.buffer_size-len))
  1050. {
  1051. row=getRow(i);
  1052. return true;
  1053. }
  1054. }
  1055. }
  1056. }
  1057. }
  1058. }
  1059. else//When search pattern is of the form pattern%
  1060. {
  1061. std::string::size_type len=value.size()-1;
  1062. pattern=new char[len];
  1063. memcpy((char*)pattern,value.substr(0,len).c_str(),len);
  1064. char* match;
  1065. for(UINT i=starting_row_index;i<total_rows;i++)
  1066. {
  1067. cell=table_data[i][key_column_index];
  1068. if(cell.buffer)
  1069. {
  1070. if(cell.buffer_size>=(long)len)
  1071. {
  1072. match=std::strstr(reinterpret_cast<char*>(cell.buffer),pattern);
  1073. if(match)
  1074. {
  1075. if((match-reinterpret_cast<char*>(cell.buffer))==0)
  1076. {
  1077. row=getRow(i);
  1078. return true;
  1079. }
  1080. }
  1081. }
  1082. }
  1083. }
  1084. }
  1085. return false;
  1086. }
  1088. bool DBTable::getPrimaryKeys
  1089. (
  1090. short*& primary_keys,
  1091. short& total_primary_keys,
  1092. std::string& message
  1093. )
  1094. {
  1095. if(!is_primary_keys_set)
  1096. {
  1097. DBKeyColumn* table_primary_keys;
  1098. if(!DBGetPrimaryKeys
  1099. (
  1100. *this,
  1101. table_primary_keys,
  1102. total_primary_key_columns,
  1103. message
  1104. ))
  1105. {
  1106. return false;
  1107. }
  1108. primary_key_columns=new short[total_primary_key_columns];
  1109. for(short i=0;i<total_primary_key_columns;i++)
  1110. {
  1111. primary_key_columns[i]=table_primary_keys[i].key_ordinal;
  1112. }
  1113. }
  1114. total_primary_keys=total_primary_key_columns;
  1115. primary_keys=new short[total_primary_key_columns];
  1116. for(short i=0;i<total_primary_key_columns;i++)
  1117. {
  1118. primary_keys[i]=primary_key_columns[i];
  1119. }
  1120. is_primary_keys_set=true;
  1121. return true;
  1122. }
  1124. bool DBTable::getForeignKeys
  1125. (
  1126. short*& foreign_keys,
  1127. short& total_foreign_keys,
  1128. std::string& message
  1129. )
  1130. {
  1131. if(!is_foreign_keys_set)
  1132. {
  1133. DBKeyColumn* table_foreign_keys;
  1134. if(!DBGetPrimaryKeys
  1135. (
  1136. *this,
  1137. table_foreign_keys,
  1138. total_foreign_key_columns,
  1139. message
  1140. ))
  1141. {
  1142. return false;
  1143. }
  1144. foreign_key_columns=new short[total_foreign_key_columns];
  1145. for(short i=0;i<total_primary_key_columns;i++)
  1146. {
  1147. foreign_key_columns[i]=table_foreign_keys[i].key_ordinal;
  1148. }
  1149. }
  1150. total_foreign_keys=total_foreign_key_columns;
  1151. foreign_keys=new short[total_foreign_key_columns];
  1152. for(short i=0;i<total_foreign_key_columns;i++)
  1153. {
  1154. foreign_keys[i]=foreign_key_columns[i];
  1155. }
  1156. is_foreign_keys_set=true;
  1157. return true;
  1158. }
  1160. DBTable DBTable::cloneTable()
  1161. {
  1162. DBTable table;
  1163. table.sql_statement=sql_statement;
  1164. table.database_name=database_name;
  1165. table.catalog_name=catalog_name;
  1166. table.schema_name=schema_name;
  1167. table.table_name=table_name;
  1168. table.total_columns=total_columns;
  1169. table.total_primary_key_columns=total_primary_key_columns;
  1170. table.total_rows=total_rows;
  1171. table.table_columns=new DBColumn[total_columns];
  1172. table.primary_key_columns=new short[total_columns];
  1173. for(short i=0;i<total_columns;i++)
  1174. {
  1175. table.table_columns[i]=DBColumn(table_columns[i]);
  1176. table.primary_key_columns[i]=primary_key_columns[i];
  1177. }
  1178. table.table_columns=table_columns;
  1179. table.statement_handle=nullptr;
  1180. table.table_data=TableData(table_data);
  1181. return table;
  1182. }
  1184. DBTable DBTable::cloneSchema()
  1185. {
  1186. DBTable table;
  1187. table.sql_statement=sql_statement;
  1188. table.database_name=database_name;
  1189. table.catalog_name=catalog_name;
  1190. table.schema_name=schema_name;
  1191. table.table_name=table_name;
  1192. table.total_columns=total_columns;
  1193. table.total_primary_key_columns=total_primary_key_columns;
  1194. table.total_rows=total_rows;
  1195. table.table_columns=new DBColumn[total_columns];
  1196. table.primary_key_columns=new short[total_columns];
  1197. for(short i=0;i<total_columns;i++)
  1198. {
  1199. table.table_columns[i]=DBColumn(table_columns[i]);
  1200. table.primary_key_columns[i]=primary_key_columns[i];
  1201. }
  1202. table.statement_handle=nullptr;
  1203. table.table_data=TableData();
  1204. return table;
  1205. }
  1207. DBTable DBTable::getSubTable
  1208. (
  1209. const short columns_indices[],
  1210. const short& total_sub_columns
  1211. )
  1212. {
  1213. DBColumn* columns;
  1214. DBTable table;
  1215. UINT n;
  1216. CellData value;
  1218. columns=new DBColumn[total_sub_columns];
  1219. for(short i=0;i<total_sub_columns;i++)
  1220. {
  1221. columns[i]=table_columns[columns_indices[i]];
  1222. }
  1224. table=DBTable(total_sub_columns,columns);
  1226. for(UINT i=0;i<total_rows;i++)
  1227. {
  1228. table.addRow(n);
  1229. for(short j=0;j<total_sub_columns;j++)
  1230. {
  1231. getValue(i,columns_indices[j],value);
  1232. table.setValue(n,j,value);
  1233. }
  1234. }
  1236. return table;
  1237. }
  1239. void DBTable::splitPKFKDC
  1240. (
  1241. DBTable& primary_keys,
  1242. DBTable& foreign_keys,
  1243. DBTable& data_columns,
  1244. bool& has_primary_keys,
  1245. bool& has_foreign_keys
  1246. )
  1247. {
  1248. if(!is_primary_keys_set)
  1249. {
  1250. short* pk_indices;
  1251. short total_pk;
  1252. std::string message;
  1253. getPrimaryKeys(pk_indices,total_pk,message);
  1254. }
  1255. if(!is_foreign_keys_set)
  1256. {
  1257. short* fk_indices;
  1258. short total_fk;
  1259. std::string message;
  1260. getForeignKeys(fk_indices,total_fk,message);
  1261. }
  1263. UINT n;
  1264. CellData value;
  1265. short* column_iterator;
  1266. short* pk_end=primary_key_columns+total_primary_key_columns;
  1267. short* fk_end=foreign_key_columns+total_foreign_key_columns;
  1268. short pk_count=0;
  1269. short fk_count=0;
  1270. short dc_count=0;
  1271. short total_data_columns=total_columns-total_primary_key_columns
  1272. -total_foreign_key_columns;
  1273. DBColumn* pk_columns=new DBColumn[total_primary_key_columns];
  1274. DBColumn* fk_columns=new DBColumn[total_foreign_key_columns];
  1275. DBColumn* dc_columns=new DBColumn[total_data_columns];
  1276. TABLE_COLUMN_TYPES column_types[total_columns];
  1277. for(short i=0;i<total_columns;i++)
  1278. {
  1279. column_iterator=std::find
  1280. (
  1281. primary_key_columns,
  1282. pk_end,
  1283. i
  1284. );
  1285. if(column_iterator!=pk_end)
  1286. {
  1287. column_types[i]=TABLE_COLUMN_TYPES::PRIMARY_KEY;
  1288. pk_columns[pk_count]=table_columns[i];
  1289. pk_count++;
  1290. }
  1291. else
  1292. {
  1293. column_iterator=std::find
  1294. (
  1295. foreign_key_columns,
  1296. fk_end,
  1297. i
  1298. );
  1299. if(column_iterator!=fk_end)
  1300. {
  1301. column_types[i]=TABLE_COLUMN_TYPES::FOREIGN_KEY;
  1302. fk_columns[fk_count]=table_columns[i];
  1303. fk_count++;
  1304. }
  1305. else
  1306. {
  1307. column_types[i]=TABLE_COLUMN_TYPES::DATA_COLUMN;
  1308. dc_columns[dc_count]=table_columns[i];
  1309. dc_count++;
  1310. }
  1311. }
  1312. }
  1314. if(pk_count>0)
  1315. {
  1316. primary_keys=DBTable(pk_count,pk_columns);
  1317. has_primary_keys=true;
  1318. }
  1319. else
  1320. {
  1321. has_primary_keys=false;
  1322. }
  1323. if(fk_count>0)
  1324. {
  1325. foreign_keys=DBTable(fk_count,fk_columns);
  1326. has_foreign_keys=true;
  1327. }
  1328. else
  1329. {
  1330. has_foreign_keys=false;
  1331. }
  1332. if(dc_count>0)
  1333. {
  1334. data_columns=DBTable(dc_count,dc_columns);
  1335. }
  1336. pk_count=0;
  1337. fk_count=0;
  1338. dc_count=0;
  1339. for(short j=0;j<total_columns;j++)
  1340. {
  1341. switch(column_types[j])
  1342. {
  1343. case TABLE_COLUMN_TYPES::PRIMARY_KEY:
  1344. {
  1345. for(UINT i=0;i<total_rows;i++)
  1346. {
  1347. getValue(i,j,value);
  1348. primary_keys.addRow(n);
  1349. primary_keys.setValue(n,pk_count,value);
  1350. }
  1351. pk_count++;
  1352. break;
  1353. }
  1354. case TABLE_COLUMN_TYPES::FOREIGN_KEY:
  1355. {
  1356. for(UINT i=0;i<total_rows;i++)
  1357. {
  1358. getValue(i,j,value);
  1359. foreign_keys.addRow(n);
  1360. foreign_keys.setValue(n,fk_count,value);
  1361. }
  1362. fk_count++;
  1363. break;
  1364. }
  1365. case TABLE_COLUMN_TYPES::DATA_COLUMN:
  1366. {
  1367. for(UINT i=0;i<total_rows;i++)
  1368. {
  1369. getValue(i,j,value);
  1370. data_columns.addRow(n);
  1371. data_columns.setValue(n,dc_count,value);
  1372. }
  1373. dc_count++;
  1374. break;
  1375. }
  1376. }
  1377. }
  1379. }
  1381. SQLHSTMT& getStatementHandle(DBTable& table)
  1382. {
  1383. return table.statement_handle;
  1384. }
  1386. void setStatementHandle(DBTable& table,const SQLHSTMT handle)
  1387. {
  1388. table.statement_handle=handle;
  1389. }
  1390. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1391. //DBDataSet DEFINITIONS
  1393. DBDataSet::DBDataSet():
  1394. data_connection(),data_tables(),total_data_tables(0)
  1395. {
  1396. total_data_tables=0;
  1397. }
  1399. DBDataSet::DBDataSet
  1400. (
  1401. const std::string& sql_statement,
  1402. const std::string& driver,
  1403. const std::string& server,
  1404. const std::string& user,
  1405. const std::string& password
  1406. ):
  1407. data_connection(),data_tables(),total_data_tables(0)
  1408. {
  1409. DBConnect(data_connection,driver,server,user,password);
  1410. }
  1412. DBDataSet::~DBDataSet()
  1413. {}
  1415. std::vector<DBTable>::iterator DBDataSet::begin()
  1416. {
  1417. return data_tables.begin();
  1418. }
  1420. std::vector<DBTable>::iterator DBDataSet::end()
  1421. {
  1422. return data_tables.end();
  1423. }
  1424. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1425. //PROCEDURES DEFINITIONS
  1426. bool DBConnect
  1427. (
  1428. DBConnection& connection,
  1429. const std::string& driver,
  1430. const std::string& server,
  1431. const std::string& user,
  1432. const std::string& password
  1433. )
  1434. {
  1435. SQLHWND app_handle;
  1436. SQLRETURN rcode;
  1437. int nstr;
  1438. char* msg;
  1440. #ifdef __linux__
  1441. app_handle=nullptr;
  1442. #endif // __linux__
  1444. #ifdef __windows__
  1445. app_handle=GetDesktopWindow();
  1446. #endif // __windows__
  1448. //Allocate environment handle
  1449. rcode=SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&connection.environment_handle);
  1450. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1451. {
  1452. connection.environment_handle_allocated=false;
  1453. connection.last_message="\n[DBConnect] Error allocating handle in \
  1454. SQLAllocHandle!";
  1455. return false;
  1456. }
  1457. connection.environment_handle_allocated=true;
  1459. //Set ODBC version environmet attribute
  1460. rcode=SQLSetEnvAttr
  1461. (
  1462. connection.environment_handle,
  1463. SQL_ATTR_ODBC_VERSION,
  1464. (SQLPOINTER)SQL_OV_ODBC3,
  1465. 0
  1466. );
  1467. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1468. {
  1469. connection.last_message="\n[DBConnect] Error setting environment attribute in \
  1470. SQLSetEnvAttr with SQL_ATTR_ODBC_VERSION attribute!";
  1471. return false;
  1472. }
  1474. //Allocate database connection handle
  1475. rcode=SQLAllocHandle
  1476. (
  1477. SQL_HANDLE_DBC,
  1478. connection.environment_handle,
  1479. &connection.database_connection_handle
  1480. );
  1481. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1482. {
  1483. connection.connection_handle_allocated=false;
  1484. connection.last_message="\n[DBConnect] Error allocating connection handle in \
  1485. SQLAllocHandle!";
  1486. return false;
  1487. }
  1489. PSQLCHAR input_connection_string;
  1490. SQLSMALLINT input_connection_string_length;//(SQLSMALLINT)(sizeof(inConStr)/sizeof(SQLCHAR));
  1491. SQLSMALLINT output_connection_string_buffer_length=1024;//Applications should allocate at least 1,024 characters for this buffer
  1492. SQLCHAR output_connection_string[output_connection_string_buffer_length];
  1493. SQLSMALLINT output_connection_string_length;
  1494. //===========================================================================================================================================================================
  1495. //VERY SENSITIVE PART OF THE APPLICATION
  1496. //AN EXAMPLE OF CONNECTION STRING THAT WORKS IS "DRIVER={Oracle73 Ver 2.5};UID=DAVALILLOCM;ASY=ON;DBQ=OCCP05;PWD=DAVALILLOCM&PDV;SAVEFILE=CONSTR.dsn;Trusted_Connection=YES;"
  1497. //AN EXAMPLE OF FILEDSN THAT WORKS IS "FILEDSN=d:\\Documents and Settings\\davalillocm\\Escritorio\\CONNECTION.dsn;";
  1498. nstr=0;
  1499. connection.connection_string="DRIVER={DRIVERPAR};UID=UIDPAR;ASY=ON;DBQ=SERVERPAR;\
  1500. PWD=PWDPAR;SAVEFILE=CONSTR.dsn;Trusted_Connection=YES;";
  1502. //Replace driver parameter
  1503. connection.connection_string=
  1504. connection.connection_string.replace
  1505. (
  1506. connection.connection_string.find("DRIVERPAR",nstr),
  1507. 9,
  1508. driver
  1509. );
  1510. nstr+=driver.length();
  1512. //Replace user id parameter
  1513. connection.connection_string=
  1514. connection.connection_string.replace
  1515. (
  1516. connection.connection_string.find("UIDPAR",nstr),
  1517. 6,
  1518. user
  1519. );
  1520. nstr+=user.length();
  1522. //Replace server parameter
  1523. connection.connection_string=
  1524. connection.connection_string.replace
  1525. (
  1526. connection.connection_string.find("SERVERPAR",nstr),
  1527. 9,
  1528. server
  1529. );
  1530. nstr+=server.length();
  1532. //Replace password parameter
  1533. connection.connection_string=
  1534. connection.connection_string.replace
  1535. (
  1536. connection.connection_string.find("PWDPAR",nstr),
  1537. 6,
  1538. password
  1539. );
  1540. nstr+=password.length();
  1541. //===========================================================================================================================================================================
  1543. input_connection_string=(PSQLCHAR)connection.connection_string.c_str();
  1544. input_connection_string_length=(SQLSMALLINT)connection.connection_string.length();
  1545. //(SQLSMALLINT)(sizeof(inConStr)/sizeof(SQLCHAR));
  1547. rcode=SQLDriverConnect
  1548. (
  1549. connection.database_connection_handle,
  1550. app_handle,
  1551. input_connection_string,
  1552. input_connection_string_length,
  1553. output_connection_string,
  1554. output_connection_string_buffer_length,
  1555. &output_connection_string_length,
  1556. SQL_DRIVER_NOPROMPT
  1557. );//SQL_DRIVER_NOPROMPT
  1558. if(rcode != SQL_SUCCESS && rcode != SQL_SUCCESS_WITH_INFO)
  1559. {
  1560. msg=new char[output_connection_string_length+1];
  1561. memcpy
  1562. (
  1563. msg,
  1564. (char*)output_connection_string,
  1565. output_connection_string_buffer_length
  1566. );
  1567. connection.last_message="\n[DBConnect] ";
  1568. connection.last_message+=msg;
  1569. connection.last_message+=DBGetErrorMsg
  1570. (
  1571. connection.database_connection_handle,
  1572. SQL_HANDLE_DBC
  1573. );
  1574. connection.flag=(int)input_connection_string_length;//(int)rcode;
  1575. delete[] msg;
  1576. return false;
  1577. }
  1579. msg=new char[output_connection_string_length+1];
  1580. memcpy(msg,(char*)output_connection_string,output_connection_string_length);
  1581. connection.last_message=std::string(msg);
  1583. connection.is_connected=true;
  1584. connection.is_open=true;
  1585. connection.connection_string="";
  1586. connection.server_string=server;
  1587. connection.user_string=user;
  1588. connection.password_string=password;
  1589. connection.flag=0;
  1591. return true;
  1592. }
  1594. bool DBDisconnect(DBConnection& connection)
  1595. {
  1596. if(SQLDisconnect(connection.database_connection_handle)==SQL_SUCCESS)
  1597. {
  1598. return true;
  1599. }
  1600. return false;
  1601. }
  1603. VECSTR DBGetDrivers(DBConnection& connection)
  1604. {
  1605. SQLRETURN rcode;
  1606. SQLCHAR driverName[SQL_MAX_DSN_LENGTH];
  1607. SQLSMALLINT driverNameLength;
  1608. SQLCHAR driverAttr[1024];
  1609. SQLSMALLINT driverAttrLength;
  1611. bool odbcsucceed;
  1612. int n;
  1613. int m;
  1614. VECSTR drivers=VECSTR();
  1616. odbcsucceed=true;
  1617. while(odbcsucceed)
  1618. {
  1619. rcode=SQLDrivers
  1620. (
  1621. connection.environment_handle,
  1622. SQL_FETCH_NEXT,
  1623. driverName,
  1624. SQL_MAX_DSN_LENGTH,
  1625. &driverNameLength,
  1626. driverAttr,
  1627. 1024,
  1628. &driverAttrLength
  1629. );
  1630. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1631. {
  1632. odbcsucceed=false;
  1633. }
  1634. else
  1635. {
  1636. n=(int)driverNameLength+1;
  1637. m=(int)driverAttrLength+1;
  1638. char DN[n];
  1639. char DNAttrs[m];
  1640. memcpy(DN,(char*)driverName,n);
  1641. memcpy(DNAttrs,(char*)driverAttr,m);
  1642. drivers.push_back(std::string(DN));
  1643. drivers.push_back(std::string(DNAttrs));
  1644. }
  1645. }
  1646. return drivers;
  1647. }
  1649. VECSTR DBGetDataSources(DBConnection& connection)
  1650. {
  1651. SQLRETURN rcode;
  1652. SQLSMALLINT bufferLengthSN=SQL_MAX_DSN_LENGTH;
  1653. SQLCHAR sourceName[bufferLengthSN];
  1654. SQLSMALLINT sourceNameLength;
  1655. SQLCHAR sourceNameDesc[1024];
  1656. SQLSMALLINT sourceNameDescLength;
  1658. bool odbcsucceed;
  1659. int n;
  1660. int m;
  1661. VECSTR dataSources=VECSTR();
  1663. rcode=SQLDataSources
  1664. (
  1665. connection.environment_handle,
  1666. SQL_FETCH_FIRST,
  1667. sourceName,
  1668. bufferLengthSN,
  1669. &sourceNameLength,
  1670. sourceNameDesc,
  1671. 1024,
  1672. &sourceNameDescLength
  1673. );
  1674. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1675. {
  1676. return dataSources;
  1677. }
  1678. n=(int)sourceNameLength+1;
  1679. m=(int)sourceNameDescLength+1;
  1680. char SN[n];
  1681. char SNDesc[m];
  1682. memcpy(SN,(char*)sourceName,n);
  1683. memcpy(SNDesc,(char*)sourceNameDesc,m);
  1684. dataSources.push_back(std::string(SN));
  1685. dataSources.push_back(std::string(SNDesc));
  1686. odbcsucceed=true;
  1687. while(odbcsucceed)
  1688. {
  1689. rcode=SQLDataSources
  1690. (
  1691. connection.environment_handle,
  1692. SQL_FETCH_NEXT,
  1693. sourceName,
  1694. bufferLengthSN,
  1695. &sourceNameLength,
  1696. sourceNameDesc,
  1697. 1024,
  1698. &sourceNameDescLength
  1699. );
  1700. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1701. {
  1702. odbcsucceed=false;
  1703. }
  1704. else
  1705. {
  1706. n=(int)sourceNameLength+1;
  1707. m=(int)sourceNameDescLength+1;
  1708. char SNI[n];
  1709. char SNIDesc[m];
  1710. memcpy(SNI,(char*)sourceName,n);
  1711. memcpy(SNIDesc,(char*)sourceNameDesc,m);
  1712. dataSources.push_back(std::string(SNI));
  1713. dataSources.push_back(std::string(SNIDesc));
  1714. }
  1715. }
  1716. return dataSources;
  1717. }
  1719. bool DBSelect(DBConnection& connection,const std::string& sqlcmd,DBTable& select_table)
  1720. {
  1721. //Prevents go any further if the connection is closed
  1722. if(!connection.is_open)
  1723. {
  1724. connection.last_message="\n[DBSelect] Connection not established or closed!";
  1725. return false;
  1726. }
  1728. SQLHSTMT statement_handle;
  1730. //Prepare the SQL statement
  1731. if(!DBPrepareSelect(connection,statement_handle,sqlcmd))
  1732. {
  1733. return false;
  1734. }
  1736. SQLRETURN rcode;
  1737. SQLSMALLINT stmt_columns=0;
  1738. DBColumn* sql_columns=nullptr;
  1739. SQLSMALLINT i;
  1740. SQLCHAR sql_command_text[MAX_COMMAND_LENGTH];
  1741. SQLINTEGER sql_command_length;
  1743. //==================================================================
  1744. //EXECUTE STATEMENT
  1745. rcode=SQLExecDirect
  1746. (
  1747. statement_handle,
  1748. (PSQLCHAR)sqlcmd.c_str(),
  1749. (SQLINTEGER)sqlcmd.length()
  1750. );
  1751. while(rcode==SQL_STILL_EXECUTING)
  1752. {
  1753. rcode=SQLExecDirect
  1754. (
  1755. statement_handle,
  1756. (PSQLCHAR)sqlcmd.c_str(),
  1757. (SQLINTEGER)sqlcmd.length()
  1758. );
  1759. }
  1760. if(rcode==SQL_ERROR && rcode!=SQL_SUCCESS_WITH_INFO)
  1761. {
  1762. connection.last_message="\n[DBSelect] SQLExecDirect error!";
  1763. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1764. return false;
  1765. }
  1766. else if(rcode==SQL_NEED_DATA)
  1767. {
  1768. connection.last_message="\n[DBSelect] SQLExecDirect execution requires \
  1769. data!";
  1770. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1771. return false;
  1772. }
  1773. //cout << "SQLExecDirect execution succeed!" << endl;
  1774. //==================================================================
  1775. //==================================================================
  1776. //SHOW EXECUTED SQL COMMAND
  1777. rcode=SQLNativeSql
  1778. (
  1779. connection.database_connection_handle,
  1780. (PSQLCHAR)sqlcmd.c_str(),
  1781. (SQLINTEGER)sqlcmd.length(),
  1782. sql_command_text,
  1783. MAX_COMMAND_LENGTH,
  1784. &sql_command_length
  1785. );
  1786. if(rcode==SQL_SUCCESS || rcode==SQL_SUCCESS_WITH_INFO)
  1787. {
  1788. std::string sended_command;
  1789. sended_command=std::string((size_t)sql_command_length,'\0');
  1790. std::copy
  1791. (
  1792. sql_command_text,
  1793. sql_command_text+sql_command_length,
  1794. sended_command.begin()
  1795. );
  1796. //cout << "\n \n Command executed \n \n " << endl;
  1797. //cout << sended_command << " \n \n " << endl;
  1798. }
  1799. else
  1800. {
  1801. connection.last_message="\n[DBSelect] SQLNativeSql error requesting sent \
  1802. statement!";
  1803. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1804. return false;
  1805. }
  1806. //==================================================================
  1807. //==================================================================
  1808. //GET NUMBER OF COLUMNS
  1809. //After be prepared the total number of columns must be retrieved
  1810. //but before the statement execution is performed
  1811. rcode=SQLNumResultCols(statement_handle,&stmt_columns);
  1812. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1813. {
  1814. connection.last_message="\n[DBSelect] SQLNumResultCols error getting the \
  1815. total number of columns!";
  1816. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1817. return false;
  1818. }
  1819. //==================================================================
  1820. //==================================================================
  1821. //CREATE COLUMNS AND BIND THEM
  1822. if(!DBGetColumnsAndBind(connection,statement_handle,stmt_columns,sql_columns))
  1823. {
  1824. return false;
  1825. }
  1826. select_table=DBTable(stmt_columns,sql_columns);
  1827. //==================================================================
  1828. //==================================================================
  1829. //FETCH VALUES
  1830. select_table.total_rows=0;
  1831. UINT row_index;
  1833. //Call SQLFetch function
  1834. rcode=SQL_SUCCESS;
  1835. while(rcode==SQL_SUCCESS)
  1836. {
  1837. DBSELECT_FETCH:
  1838. rcode=SQLFetch(statement_handle);
  1839. if(rcode==SQL_STILL_EXECUTING)
  1840. {
  1841. goto DBSELECT_FETCH;
  1842. }
  1843. if(rcode==SQL_SUCCESS || rcode==SQL_SUCCESS_WITH_INFO)
  1844. {
  1845. select_table.addRow(row_index);//Add an empty row
  1847. for(i=0;i<stmt_columns;i++)
  1848. {
  1849. CellData value;
  1850. if(sql_columns[i].data_length_indicator==SQL_NULL_DATA)
  1851. {
  1852. value.buffer=nullptr;
  1853. value.buffer_size=0;
  1854. //cout << "row field is NULL " << endl;
  1855. }
  1856. else
  1857. {
  1858. value.buffer=new SQLCHAR[sql_columns[i].data_length_indicator];
  1859. value.buffer_size=sql_columns[i].data_length_indicator;
  1860. memcpy
  1861. (
  1862. value.buffer,
  1863. sql_columns[i].column_buffer,
  1864. sql_columns[i].data_length_indicator
  1865. );
  1866. }
  1867. select_table.setValue(row_index,i,value);
  1868. }
  1870. if(rcode==SQL_SUCCESS_WITH_INFO)
  1871. {
  1872. //Show state
  1873. connection.last_message+="\n Row state ";
  1874. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1875. //cout << connection.last_message << endl;
  1876. }
  1877. }
  1878. }
  1880. switch(rcode)
  1881. {
  1882. case SQL_SUCCESS_WITH_INFO:
  1883. {
  1884. //Show state
  1885. connection.last_message+="\n";
  1886. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1887. //cout << connection.last_message << endl;
  1888. break;
  1889. }
  1890. case SQL_NO_DATA:
  1891. {
  1892. //Show state
  1893. connection.last_message+="\n[DBSelect] All rows fetched!";
  1894. //cout << connection.last_message << endl;
  1895. break;
  1896. }
  1897. case SQL_ERROR:
  1898. {
  1899. //Show error
  1900. connection.last_message+="\n[DBSelect] Error in SQLFetch ";
  1901. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1902. //cout << "Error setting cursor's position!" << endl;
  1903. return false;
  1904. }
  1905. case SQL_INVALID_HANDLE:
  1906. {
  1907. connection.last_message+="\n[DBSelect] Invalid statement handle!";
  1908. //cout << "Invalid statement handle!" << endl;
  1909. return false;
  1910. }
  1911. default:
  1912. {
  1913. break;
  1914. }
  1915. }
  1916. //==================================================================
  1918. //cout << "Total rows " << select_table.total_rows << endl;
  1919. setStatementHandle(select_table,statement_handle);
  1920. //==================================================================
  1921. //TO SET TABLE NAME, CATALOG NAME AND SCHEMA NAME
  1922. select_table.catalog_name=std::string
  1923. (
  1924. (char*)select_table.table_columns[0].catalog_name
  1925. );
  1926. select_table.schema_name=std::string
  1927. (
  1928. (char*)select_table.table_columns[0].schema_name
  1929. );
  1930. select_table.table_name=std::string
  1931. (
  1932. (char*)select_table.table_columns[0].table_name
  1933. );
  1934. //==================================================================
  1936. //Close the cursor
  1937. rcode=SQLCloseCursor(statement_handle);
  1938. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1939. {
  1940. connection.last_message="\n[DBSelect] SQLCloseCursor error closing cursor!";
  1941. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1942. return false;
  1943. }
  1945. rcode=SQLFreeStmt(statement_handle,SQL_RESET_PARAMS);
  1946. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  1947. {
  1948. connection.last_message="\n[DBSelect] SQLFreeStmt error resetting parameters!";
  1949. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  1950. return false;
  1951. }
  1953. return true;
  1954. }
  1956. bool DBInsert
  1957. (
  1958. DBConnection& connection,
  1959. const std::string& sqlcmd,
  1960. const DBTable& rows_to_insert,
  1961. DBTable& rows_rejected
  1962. )
  1963. {
  1964. //Prevents go any further if the connection is closed
  1965. if(!connection.is_open)
  1966. {
  1967. connection.last_message="\n[DBInsert] Connection not established or closed!";
  1968. return false;
  1969. }
  1971. SQLRETURN rcode;
  1972. SQLHSTMT statement_handle;
  1973. DBColumn* sql_columns=new DBColumn[rows_to_insert.total_columns];
  1975. for(short i=0;i<rows_to_insert.total_columns;i++)
  1976. {
  1977. sql_columns[i]=rows_to_insert.table_columns[i];
  1978. }
  1980. //Prepare the SQL statement
  1981. if(!DBPrepareInsert(connection,statement_handle,sqlcmd))
  1982. {
  1983. return false;
  1984. }
  1986. if(!DBBindInsertParameters
  1987. (
  1988. connection,
  1989. statement_handle,
  1990. rows_to_insert.total_columns,
  1991. sql_columns
  1992. ))
  1993. {
  1994. return false;
  1995. }
  1996. //cout << "SQL parameters bounded!" << endl;
  1998. //Prepare SQl command
  1999. rcode=SQLPrepare
  2000. (
  2001. statement_handle,
  2002. (PSQLCHAR)sqlcmd.c_str(),
  2003. (SQLINTEGER)strlen(sqlcmd.c_str())
  2004. );
  2005. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2006. {
  2007. connection.sql_command_prepared=false;
  2008. connection.last_message="\n[DBInsert] Can't prepare SQL statement!";
  2009. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2010. return false;
  2011. }
  2012. connection.sql_command_prepared=true;
  2013. //cout << "SQL Insert prepared!" << endl;
  2015. rows_rejected=DBTable(rows_to_insert.total_columns,rows_to_insert.table_columns);
  2017. for(UINT i=0;i<rows_to_insert.total_rows;i++)
  2018. {
  2019. //Set data to bounded buffer
  2020. for(short j=0;j<rows_to_insert.total_columns;j++)
  2021. {
  2022. CellData value;
  2023. rows_to_insert.getValue(i,j,value);
  2024. if(!value.buffer)
  2025. {
  2026. sql_columns[j].column_buffer_length=0;
  2027. sql_columns[j].data_length_indicator=SQL_NULL_DATA;
  2028. }
  2029. else
  2030. {
  2031. memcpy(sql_columns[j].column_buffer,value.buffer,value.buffer_size);
  2032. sql_columns[j].data_length_indicator=value.buffer_size;
  2033. }
  2034. }
  2036. rcode=SQLExecute(statement_handle);
  2038. if(rcode != SQL_SUCCESS && rcode != SQL_SUCCESS_WITH_INFO)
  2039. {
  2040. DBRow rejected;
  2041. rejected=rows_to_insert.getRow(i);
  2042. rows_rejected.addRow(rejected);
  2043. //cout << "Row " << i << " rejected" << endl;
  2044. //cout << DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT) << endl;
  2045. }
  2046. }
  2048. rcode=SQLFreeStmt(statement_handle,SQL_RESET_PARAMS);
  2049. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2050. {
  2051. connection.last_message="\n[DBInsert] SQLFreeStmt error resetting parameters!";
  2052. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2053. return false;
  2054. }
  2056. return true;
  2057. }
  2059. bool DBUpdate
  2060. (
  2061. DBConnection& connection,
  2062. const std::string& sqlcmd,
  2063. const DBTable& rows_to_update,
  2064. const DBTable& primary_keys_values,
  2065. DBTable& rows_rejected
  2066. )
  2067. {
  2068. //Prevents go any further if the connection is closed
  2069. if(!connection.is_open)
  2070. {
  2071. connection.last_message="\n[DBUpdate] Connection not established or closed!";
  2072. return false;
  2073. }
  2075. SQLRETURN rcode;
  2076. SQLHSTMT statement_handle;
  2077. DBColumn* sql_columns=new DBColumn[rows_to_update.total_columns];
  2078. DBColumn* pk_columns=new DBColumn[primary_keys_values.total_columns];
  2079. CellData value;
  2081. for(short i=0;i<rows_to_update.total_columns;i++)
  2082. {
  2083. sql_columns[i]=rows_to_update.table_columns[i];
  2084. }
  2086. for(short i=0;i<primary_keys_values.total_columns;i++)
  2087. {
  2088. pk_columns[i]=primary_keys_values.table_columns[i];
  2089. }
  2091. //Prepare the SQL statement
  2092. if(!DBPrepareUpdate(connection,statement_handle,sqlcmd))
  2093. {
  2094. return false;
  2095. }
  2097. if(!DBBindUpdateParameters
  2098. (
  2099. connection,
  2100. statement_handle,
  2101. rows_to_update.total_columns,
  2102. primary_keys_values.total_columns,
  2103. sql_columns,
  2104. pk_columns
  2105. ))
  2106. {
  2107. return false;
  2108. }
  2109. //cout << "SQL parameters bounded!" << endl;
  2111. //Prepare SQl command
  2112. rcode=SQLPrepare
  2113. (
  2114. statement_handle,
  2115. (PSQLCHAR)sqlcmd.c_str(),
  2116. (SQLINTEGER)strlen(sqlcmd.c_str())
  2117. );
  2118. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2119. {
  2120. connection.sql_command_prepared=false;
  2121. connection.last_message="\n[DBUpdate] Can't prepare SQL statement!";
  2122. connection.last_message+="";
  2123. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2124. return false;
  2125. }
  2126. connection.sql_command_prepared=true;
  2127. //cout << "SQL Update prepared!" << endl;
  2129. rows_rejected=DBTable(rows_to_update.total_columns,rows_to_update.table_columns);
  2131. for(UINT i=0;i<rows_to_update.total_rows;i++)
  2132. {
  2133. //Set data to bounded buffer
  2134. for(short j=0;j<rows_to_update.total_columns;j++)
  2135. {
  2136. rows_to_update.getValue(i,j,value);
  2137. if(!value.buffer)
  2138. {
  2139. sql_columns[j].column_buffer_length=0;
  2140. sql_columns[j].data_length_indicator=SQL_NULL_DATA;
  2141. }
  2142. else
  2143. {
  2144. sql_columns[j].column_buffer_length=value.buffer_size;
  2145. sql_columns[j].data_length_indicator=value.buffer_size;
  2146. memcpy(sql_columns[j].column_buffer,value.buffer,value.buffer_size);
  2147. }
  2148. }
  2150. for(short j=0;j<primary_keys_values.total_columns;j++)
  2151. {
  2152. primary_keys_values.getValue(i,j,value);
  2153. pk_columns[j].column_buffer_length=value.buffer_size;
  2154. pk_columns[j].data_length_indicator=value.buffer_size;
  2155. memcpy(pk_columns[j].column_buffer,value.buffer,value.buffer_size);
  2156. }
  2158. rcode=SQLExecute(statement_handle);
  2160. if(rcode != SQL_SUCCESS && rcode != SQL_SUCCESS_WITH_INFO)
  2161. {
  2162. DBRow rejected;
  2163. rejected=rows_to_update.getRow(i);
  2164. rows_rejected.addRow(rejected);
  2165. //cout << "Row " << i << " rejected" << endl;
  2166. //cout << DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT) << endl;
  2167. }
  2169. }
  2171. return true;
  2172. }
  2174. bool DBDelete
  2175. (
  2176. DBConnection& connection,
  2177. const std::string& sqlcmd,
  2178. const DBTable& primary_keys_values,
  2179. DBTable& rows_rejected
  2180. )
  2181. {
  2182. //Prevents go any further if the connection is closed
  2183. if(!connection.is_open)
  2184. {
  2185. connection.last_message="\n[DBDelete] Connection not established or closed!";
  2186. return false;
  2187. }
  2189. SQLRETURN rcode;
  2190. SQLHSTMT statement_handle;
  2191. DBColumn* pk_columns=new DBColumn[primary_keys_values.total_columns];
  2192. CellData value;
  2194. for(short i=0;i<primary_keys_values.total_columns;i++)
  2195. {
  2196. pk_columns[i]=primary_keys_values.table_columns[i];
  2197. }
  2199. //Prepare the SQL statement
  2200. if(!DBPrepareDelete(connection,statement_handle,sqlcmd))
  2201. {
  2202. return false;
  2203. }
  2205. if(!DBBindDeleteParameters
  2206. (
  2207. connection,
  2208. statement_handle,
  2209. primary_keys_values.total_columns,
  2210. pk_columns
  2211. ))
  2212. {
  2213. return false;
  2214. }
  2215. //cout << "SQL parameters bounded!" << endl;
  2217. //Prepare SQl command
  2218. rcode=SQLPrepare
  2219. (
  2220. statement_handle,
  2221. (PSQLCHAR)sqlcmd.c_str(),
  2222. (SQLINTEGER)strlen(sqlcmd.c_str())
  2223. );
  2224. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2225. {
  2226. connection.sql_command_prepared=false;
  2227. connection.last_message="\n[DBDelete] Can't prepare SQL statement!";
  2228. connection.last_message+="";
  2229. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2230. return false;
  2231. }
  2232. connection.sql_command_prepared=true;
  2233. //cout << "SQL Delete prepared!" << endl;
  2235. rows_rejected=DBTable
  2236. (
  2237. primary_keys_values.total_columns,
  2238. primary_keys_values.table_columns
  2239. );
  2241. for(UINT i=0;i<primary_keys_values.total_rows;i++)
  2242. {
  2243. for(short j=0;j<primary_keys_values.total_columns;j++)
  2244. {
  2245. primary_keys_values.getValue(i,j,value);
  2246. pk_columns[j].column_buffer_length=value.buffer_size;
  2247. pk_columns[j].data_length_indicator=value.buffer_size;
  2248. memcpy(pk_columns[j].column_buffer,value.buffer,value.buffer_size);
  2249. }
  2251. rcode=SQLExecute(statement_handle);
  2253. if(rcode != SQL_SUCCESS && rcode != SQL_SUCCESS_WITH_INFO)
  2254. {
  2255. DBRow rejected;
  2256. rejected=primary_keys_values.getRow(i);
  2257. rows_rejected.addRow(rejected);
  2258. //cout << "Row " << i << " rejected" << endl;
  2259. //cout << DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT) << endl;
  2260. }
  2262. }
  2265. return true;
  2266. }
  2268. bool DBGetPrimaryKeys
  2269. (
  2270. DBTable& table,
  2271. DBKeyColumn*& primary_keys,
  2272. short& total_primary_keys,
  2273. std::string& message
  2274. )
  2275. {
  2276. SQLRETURN rcode;
  2277. HSTMT handle=getStatementHandle(table);
  2278. PSQLCHAR table_catalog_name=(PSQLCHAR)table.catalog_name.c_str();
  2279. PSQLCHAR table_schema_name=(PSQLCHAR)table.schema_name.c_str();
  2280. PSQLCHAR table_name=(PSQLCHAR)table.table_name.c_str();
  2281. SQLSMALLINT table_catalog_name_length=(SQLSMALLINT)table.catalog_name.size();
  2282. SQLSMALLINT table_schema_name_length=(SQLSMALLINT)table.schema_name.size();
  2283. SQLSMALLINT table_name_length=(SQLSMALLINT)table.table_name.size();
  2284. SQLSMALLINT key_ordinal;
  2285. SQLSMALLINT k;
  2286. std::vector<DBKeyColumn> table_primary_keys;
  2288. SQLBindCol(handle,6,SQL_C_SSHORT,(SQLPOINTER)&key_ordinal,sizeof(SQLSMALLINT),NULL);
  2290. rcode=SQLPrimaryKeys
  2291. (
  2292. handle,
  2293. table_catalog_name,
  2294. table_catalog_name_length,
  2295. table_schema_name,
  2296. table_schema_name_length,
  2297. table_name,
  2298. table_name_length
  2299. );
  2300. while(rcode==SQL_STILL_EXECUTING)
  2301. {
  2302. rcode=SQLPrimaryKeys
  2303. (
  2304. handle,
  2305. table_catalog_name,
  2306. table_catalog_name_length,
  2307. table_schema_name,
  2308. table_schema_name_length,
  2309. table_name,
  2310. table_name_length
  2311. );
  2312. }
  2313. if(rcode==SQL_ERROR)
  2314. {
  2315. message="\n[DBGetPrimaryKeys] Error executing SQLPrimaryKeys!\n";
  2316. message+=DBGetErrorMsg(handle,SQL_HANDLE_STMT);
  2317. return false;
  2318. }
  2319. while(rcode==SQL_SUCCESS || rcode==SQL_SUCCESS_WITH_INFO)
  2320. {
  2321. rcode=SQLFetch(handle);
  2322. while(rcode==SQL_STILL_EXECUTING)
  2323. {
  2324. rcode=SQLFetch(handle);
  2325. }
  2327. if(rcode==SQL_SUCCESS || rcode==SQL_SUCCESS_WITH_INFO)
  2328. {
  2329. DBKeyColumn key;
  2330. memcpy
  2331. (
  2332. key.key_catalog_name,
  2333. table_catalog_name,
  2334. table_catalog_name_length
  2335. );
  2336. memcpy
  2337. (
  2338. key.key_schema_name,
  2339. table_schema_name,
  2340. table_schema_name_length
  2341. );
  2342. memcpy
  2343. (
  2344. key.key_table_name,
  2345. table_name,
  2346. table_name_length
  2347. );
  2348. k=key_ordinal;
  2349. memcpy
  2350. (
  2351. key.key_column_name,
  2352. table.table_columns[k].column_name,
  2353. table.table_columns[k].column_name_length
  2354. );
  2355. key.key_ordinal=key_ordinal;
  2356. key.key_catalog_name_length=table_catalog_name_length;
  2357. key.key_schema_name_length=table_schema_name_length;
  2358. key.key_table_name_length=table_name_length;
  2359. key.key_column_name_length=table.table_columns[k].column_name_length;
  2360. key.key_name_length=0;
  2361. table_primary_keys.push_back(key);
  2362. }
  2363. }
  2365. primary_keys=new DBKeyColumn[table_primary_keys.size()];
  2366. for(size_t i=0;i<table_primary_keys.size();i++)
  2367. {
  2368. primary_keys[i]=table_primary_keys[i];
  2369. }
  2370. total_primary_keys=(short)table_primary_keys.size();
  2372. rcode=SQLFreeStmt(handle,SQL_RESET_PARAMS);
  2373. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2374. {
  2375. message="\n[DBGetPrimaryKeys] SQLFreeStmt error resetting parameters!";
  2376. message+=DBGetErrorMsg(handle,SQL_HANDLE_STMT);
  2377. return false;
  2378. }
  2380. return true;
  2381. }
  2383. bool DBGetForeignKeys
  2384. (
  2385. DBTable& table,
  2386. DBKeyColumn*& foreign_keys,
  2387. short& total_foreign_keys,
  2388. std::string& message
  2389. )
  2390. {
  2391. SQLRETURN rcode;
  2392. HSTMT handle=getStatementHandle(table);
  2393. PSQLCHAR table_catalog_name=(PSQLCHAR)table.catalog_name.c_str();
  2394. PSQLCHAR table_schema_name=(PSQLCHAR)table.schema_name.c_str();
  2395. PSQLCHAR table_name=(PSQLCHAR)table.table_name.c_str();
  2396. SQLSMALLINT table_catalog_name_length=(SQLSMALLINT)table.catalog_name.size();
  2397. SQLSMALLINT table_schema_name_length=(SQLSMALLINT)table.schema_name.size();
  2398. SQLSMALLINT table_name_length=(SQLSMALLINT)table.table_name.size();
  2399. SQLSMALLINT key_ordinal;
  2400. SQLSMALLINT k;
  2401. std::vector<DBKeyColumn> table_foreign_keys;
  2403. SQLBindCol(handle,6,SQL_C_SSHORT,(SQLPOINTER)&key_ordinal,sizeof(SQLSMALLINT),NULL);
  2405. rcode=SQLForeignKeys
  2406. (
  2407. handle,
  2408. NULL,
  2409. 0,
  2410. NULL,
  2411. 0,
  2412. NULL,
  2413. 0,
  2414. table_catalog_name,
  2415. table_catalog_name_length,
  2416. table_schema_name,
  2417. table_schema_name_length,
  2418. table_name,
  2419. table_name_length
  2420. );
  2421. while(rcode==SQL_STILL_EXECUTING)
  2422. {
  2423. rcode=SQLForeignKeys
  2424. (
  2425. handle,
  2426. NULL,
  2427. 0,
  2428. NULL,
  2429. 0,
  2430. NULL,
  2431. 0,
  2432. table_catalog_name,
  2433. table_catalog_name_length,
  2434. table_schema_name,
  2435. table_schema_name_length,
  2436. table_name,
  2437. table_name_length
  2438. );
  2439. }
  2440. if(rcode==SQL_ERROR)
  2441. {
  2442. message="\n[DBGetPrimaryKeys] Error executing SQLPrimaryKeys!\n";
  2443. message+=DBGetErrorMsg(handle,SQL_HANDLE_STMT);
  2444. return false;
  2445. }
  2446. while(rcode==SQL_SUCCESS || rcode==SQL_SUCCESS_WITH_INFO)
  2447. {
  2448. rcode=SQLFetch(handle);
  2449. while(rcode==SQL_STILL_EXECUTING)
  2450. {
  2451. rcode=SQLFetch(handle);
  2452. }
  2454. if(rcode==SQL_SUCCESS || rcode==SQL_SUCCESS_WITH_INFO)
  2455. {
  2456. DBKeyColumn key;
  2457. memcpy
  2458. (
  2459. key.key_catalog_name,
  2460. table_catalog_name,
  2461. table_catalog_name_length
  2462. );
  2463. memcpy
  2464. (
  2465. key.key_schema_name,
  2466. table_schema_name,
  2467. table_schema_name_length
  2468. );
  2469. memcpy
  2470. (
  2471. key.key_table_name,
  2472. table_name,
  2473. table_name_length
  2474. );
  2475. k=key_ordinal;
  2476. memcpy
  2477. (
  2478. key.key_column_name,
  2479. table.table_columns[k].column_name,
  2480. table.table_columns[k].column_name_length
  2481. );
  2482. key.key_ordinal=key_ordinal;
  2483. key.key_catalog_name_length=table_catalog_name_length;
  2484. key.key_schema_name_length=table_schema_name_length;
  2485. key.key_table_name_length=table_name_length;
  2486. key.key_column_name_length=table.table_columns[k].column_name_length;
  2487. key.key_name_length=0;
  2488. table_foreign_keys.push_back(key);
  2489. }
  2490. }
  2492. foreign_keys=new DBKeyColumn[table_foreign_keys.size()];
  2493. for(size_t i=0;i<table_foreign_keys.size();i++)
  2494. {
  2495. foreign_keys[i]=table_foreign_keys[i];
  2496. }
  2497. total_foreign_keys=(short)table_foreign_keys.size();
  2499. rcode=SQLFreeStmt(handle,SQL_RESET_PARAMS);
  2500. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2501. {
  2502. message="\n[DBGetForeignKeys] SQLFreeStmt error resetting parameters!";
  2503. message+=DBGetErrorMsg(handle,SQL_HANDLE_STMT);
  2504. return false;
  2505. }
  2507. return true;
  2508. }
  2510. short DBGetNumberOfColumns(SQLHSTMT& statement_handle)
  2511. {
  2512. SQLRETURN rcode;
  2513. SQLSMALLINT total_columns;
  2514. rcode=SQLNumResultCols(statement_handle,&total_columns);
  2515. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2516. {
  2517. return -1;
  2518. }
  2519. return (short)total_columns;
  2520. }
  2522. UINT DBGetNumberOfRows(SQLHSTMT& statement_handle)
  2523. {
  2524. SQLRETURN rcode;
  2525. SQLLEN total_rows;
  2526. rcode=SQLRowCount(statement_handle,&total_rows);
  2527. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  2528. {
  2529. return -1;
  2530. }
  2531. return (UINT)total_rows;
  2532. }
  2534. std::string DBGetErrorMsg(SQLHANDLE handle,SQLSMALLINT handle_type)
  2535. {
  2536. std::string msg="";
  2537. std::string error_message;
  2538. std::string error_message_code;
  2539. SQLSMALLINT total_messages=1;
  2540. SQLRETURN rcode;
  2541. SQLCHAR sql_state[6];
  2542. SQLCHAR sql_error_message[SQL_MAX_MESSAGE_LENGTH];
  2543. SQLINTEGER sql_native_error;
  2544. SQLSMALLINT sql_error_message_length;
  2545. SQLSMALLINT handle_type_enum;
  2547. switch(handle_type)
  2548. {
  2549. case SQL_HANDLE_DBC:
  2550. {
  2551. handle_type_enum=SQL_HANDLE_DBC;
  2552. break;
  2553. }
  2554. case SQL_HANDLE_DESC:
  2555. {
  2556. handle_type_enum=SQL_HANDLE_DESC;
  2557. break;
  2558. }
  2559. case SQL_HANDLE_ENV:
  2560. {
  2561. handle_type_enum=SQL_HANDLE_ENV;
  2562. break;
  2563. }
  2564. case SQL_HANDLE_STMT:
  2565. {
  2566. handle_type_enum=SQL_HANDLE_STMT;
  2567. break;
  2568. }
  2569. default:
  2570. break;
  2571. }
  2572. while(true)
  2573. {
  2574. rcode = SQLGetDiagRec
  2575. (
  2576. handle_type_enum,
  2577. handle,
  2578. total_messages,
  2579. sql_state,
  2580. &sql_native_error,
  2581. sql_error_message,
  2582. SQL_MAX_MESSAGE_LENGTH,
  2583. &sql_error_message_length
  2584. );
  2585. if(rcode==SQL_SUCCESS)
  2586. {
  2587. error_message=std::string((size_t)sql_error_message_length,'\0');
  2588. std::copy
  2589. (
  2590. sql_error_message,
  2591. sql_error_message+sql_error_message_length,
  2592. error_message.begin()
  2593. );
  2594. error_message_code="\n["+std::string((char*)sql_state)+"]";
  2595. msg+=error_message_code+error_message+"";
  2596. total_messages++;
  2597. if(total_messages>MAX_ERROR_MESSAGES)
  2598. {
  2599. break;
  2600. }
  2601. }
  2602. else
  2603. {
  2604. break;
  2605. }
  2606. }
  2607. if(!(msg.compare("")==0))
  2608. {
  2609. msg+="";
  2610. }
  2611. return msg;
  2612. }
  2614. std::string GetSQLTypeName(const short sql_type_id,bool& is_type_variable)
  2615. {
  2616. std::string type_name;
  2617. is_type_variable=false;
  2618. switch(sql_type_id)
  2619. {
  2620. case SQL_BIT:
  2621. {
  2622. type_name="SQL_BIT";
  2623. break;
  2624. }
  2625. case SQL_CHAR:
  2626. {
  2627. type_name="SQL_CHAR";
  2628. break;
  2629. }
  2630. case SQL_VARCHAR:
  2631. {
  2632. type_name="SQL_VARCHAR";
  2633. break;
  2634. }
  2635. case SQL_LONGVARCHAR:
  2636. {
  2637. type_name="SQL_LONGVARCHAR";
  2638. break;
  2639. }
  2640. case SQL_WCHAR:
  2641. {
  2642. type_name="SQL_WCHAR";
  2643. is_type_variable=true;
  2644. break;
  2645. }
  2646. case SQL_WVARCHAR:
  2647. {
  2648. type_name="SQL_WVARCHAR";
  2649. is_type_variable=true;
  2650. break;
  2651. }
  2652. case SQL_WLONGVARCHAR:
  2653. {
  2654. type_name="SQL_WLONGVARCHAR";
  2655. is_type_variable=true;
  2656. break;
  2657. }
  2658. case SQL_TINYINT:
  2659. {
  2660. type_name="SQL_TINYINT";
  2661. break;
  2662. }
  2663. case SQL_SMALLINT:
  2664. {
  2665. type_name="SQL_SMALLINT";
  2666. break;
  2667. }
  2668. case SQL_INTEGER:
  2669. {
  2670. type_name="SQL_INTEGER";
  2671. break;
  2672. }
  2673. case SQL_BIGINT:
  2674. {
  2675. type_name="SQL_BIGINT";
  2676. break;
  2677. }
  2678. case SQL_DECIMAL:
  2679. {
  2680. type_name="SQL_DECIMAL";
  2681. break;
  2682. }
  2683. case SQL_NUMERIC:
  2684. {
  2685. type_name="SQL_NUMERIC";
  2686. break;
  2687. }
  2688. case SQL_REAL:
  2689. {
  2690. type_name="SQL_REAL";
  2691. break;
  2692. }
  2693. case SQL_FLOAT:
  2694. {
  2695. type_name="SQL_FLOAT";
  2696. break;
  2697. }
  2698. case SQL_DOUBLE:
  2699. {
  2700. type_name="SQL_DOUBLE";
  2701. break;
  2702. }
  2703. case SQL_DATE:
  2704. {
  2705. type_name="SQL_DATE";
  2706. break;
  2707. }
  2708. case SQL_TIME:
  2709. {
  2710. type_name="SQL_TIME";
  2711. break;
  2712. }
  2713. case SQL_TIMESTAMP:
  2714. {
  2715. type_name="SQL_TIMESTAMP";
  2716. break;
  2717. }
  2718. case SQL_BINARY:
  2719. {
  2720. type_name="SQL_BINARY";
  2721. is_type_variable=true;
  2722. break;
  2723. }
  2724. case SQL_VARBINARY:
  2725. {
  2726. type_name="SQL_VARBINARY";
  2727. is_type_variable=true;
  2728. break;
  2729. }
  2730. case SQL_LONGVARBINARY:
  2731. {
  2732. type_name="SQL_LONGVARBINARY";
  2733. is_type_variable=true;
  2734. break;
  2735. }
  2736. default:
  2737. {
  2738. type_name="SQL_INTEGER";
  2739. break;
  2740. }
  2741. }
  2743. return type_name;
  2744. }
  2746. //==========================================================================================
  2747. //METHODS FOR INTEROPERABILITY WITH EXCEL LIBREOFFICE MACRO
  2749. bool DBGetColumnsAndBind
  2750. (
  2751. DBConnection& connection,
  2752. SQLHSTMT& statement_handle,
  2753. const short& total_columns,
  2754. DBColumn*& columns
  2755. )
  2756. {
  2757. SQLRETURN rcode;
  2758. SQLSMALLINT type_enum;
  2759. short i,j;
  2760. long column_type;
  2761. long column_length;
  2762. columns=new DBColumn[total_columns];
  2764. for(i=0;i<total_columns;i++)
  2765. {
  2766. j=i+1;
  2767. //some drivers may only write the lower 32-bit or 16-bit of a buffer and leave
  2768. //the higher-order bit unchanged. Therefore, applications should initialize the
  2769. //value to 0 before calling SQLColAttribute
  2770. column_type=0;
  2771. column_length=0;
  2773. //Get the column's type
  2774. rcode=SQLColAttribute
  2775. (
  2776. statement_handle,
  2777. j,
  2778. SQL_DESC_CONCISE_TYPE,
  2779. NULL,
  2780. 0,
  2781. NULL,
  2782. &column_type
  2783. );
  2784. if(rcode!=SQL_SUCCESS)
  2785. {
  2786. //Show state
  2787. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2788. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2789. //cout << connection.last_message << endl;
  2790. return false;
  2791. }
  2792. columns[i].column_type=(short)(column_type);
  2794. //Get the column's byte length
  2795. rcode=SQLColAttribute
  2796. (
  2797. statement_handle,
  2798. j,
  2799. SQL_COLUMN_LENGTH,
  2800. NULL,
  2801. 0,
  2802. NULL,
  2803. &column_length
  2804. );
  2805. if(rcode!=SQL_SUCCESS)
  2806. {
  2807. //Show state
  2808. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2809. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2810. //cout << connection.last_message << endl;
  2811. return false;
  2812. }
  2813. columns[i].column_buffer_length=column_length;
  2815. //Get column's name
  2816. rcode=SQLColAttribute
  2817. (
  2818. statement_handle,
  2819. j,
  2820. SQL_DESC_NAME,
  2821. columns[i].column_name,
  2822. SQL_MAX_COLUMN_NAME_LEN,
  2823. &columns[i].column_name_length,
  2824. NULL
  2825. );
  2826. if(rcode!=SQL_SUCCESS)
  2827. {
  2828. //Show state
  2829. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2830. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2831. //cout << connection.last_message << endl;
  2832. return false;
  2833. }
  2835. //Get table name that contains the column
  2836. rcode=SQLColAttribute
  2837. (
  2838. statement_handle,
  2839. j,
  2840. SQL_COLUMN_TABLE_NAME,
  2841. columns[i].table_name,
  2842. SQL_MAX_TABLE_NAME_LEN,
  2843. &columns[i].table_name_length,
  2844. NULL
  2845. );
  2846. if(rcode!=SQL_SUCCESS)
  2847. {
  2848. //Show state
  2849. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2850. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2851. //cout << connection.last_message << endl;
  2852. return false;
  2853. }
  2855. //Get column's type name
  2856. rcode=SQLColAttribute
  2857. (
  2858. statement_handle,
  2859. j,
  2860. SQL_DESC_TYPE_NAME,
  2861. columns[i].column_type_name,
  2862. MAX_COL_TYPE_NAME_LENGTH,
  2863. &columns[i].column_type_name_length,
  2864. NULL
  2865. );
  2866. if(rcode!=SQL_SUCCESS)
  2867. {
  2868. //Show state
  2869. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2870. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2871. //cout << connection.last_message << endl;
  2872. return false;
  2873. }
  2875. //Get column's catalog name
  2876. rcode=SQLColAttribute
  2877. (
  2878. statement_handle,
  2879. j,
  2880. SQL_DESC_CATALOG_NAME,
  2881. columns[i].catalog_name,
  2882. SQL_MAX_CATALOG_NAME_LEN,
  2883. &columns[i].catalog_name_length,
  2884. NULL
  2885. );
  2886. if(rcode!=SQL_SUCCESS)
  2887. {
  2888. //Show state
  2889. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2890. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2891. //cout << connection.last_message << endl;
  2892. return false;
  2893. }
  2895. //Get column's schema name
  2896. rcode=SQLColAttribute
  2897. (
  2898. statement_handle,
  2899. j,
  2900. SQL_DESC_SCHEMA_NAME,
  2901. columns[i].schema_name,
  2902. SQL_MAX_SCHEMA_NAME_LEN,
  2903. &columns[i].schema_name_length,
  2904. NULL
  2905. );
  2906. if(rcode!=SQL_SUCCESS)
  2907. {
  2908. //Show state
  2909. connection.last_message+="\n[DBGetColumnsAndBind] SQLColAttribute error!";
  2910. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  2911. //cout << connection.last_message << endl;
  2912. return false;
  2913. }
  2915. columns[i].column_buffer=new SQLCHAR[column_length];
  2917. switch(columns[i].column_type)
  2918. {
  2919. case SQL_BIT:
  2920. {
  2921. break;
  2922. }
  2923. case SQL_CHAR:
  2924. {
  2925. type_enum=SQL_C_CHAR;
  2926. break;
  2927. }
  2928. case SQL_VARCHAR:
  2929. {
  2930. type_enum=SQL_C_CHAR;
  2931. break;
  2932. }
  2933. case SQL_LONGVARCHAR:
  2934. {
  2936. break;
  2937. }
  2938. case SQL_WCHAR:
  2939. {
  2940. break;
  2941. }
  2942. case SQL_WVARCHAR:
  2943. {
  2945. break;
  2946. }
  2947. case SQL_WLONGVARCHAR:
  2948. {
  2950. break;
  2951. }
  2952. case SQL_TINYINT:
  2953. {
  2954. type_enum=SQL_C_TINYINT;
  2955. break;
  2956. }
  2957. case SQL_SMALLINT:
  2958. {
  2959. type_enum=SQL_C_SHORT;
  2960. break;
  2961. }
  2962. case SQL_INTEGER:
  2963. {
  2964. type_enum=SQL_C_LONG;
  2965. break;
  2966. }
  2967. case SQL_BIGINT:
  2968. {
  2969. type_enum=SQL_C_SBIGINT;
  2970. break;
  2971. }
  2972. case SQL_DECIMAL:
  2973. {
  2974. break;
  2975. }
  2976. case SQL_NUMERIC:
  2977. {
  2978. break;
  2979. }
  2980. case SQL_REAL:
  2981. {
  2982. break;
  2983. }
  2984. case SQL_FLOAT:
  2985. {
  2986. type_enum=SQL_C_FLOAT;
  2987. break;
  2988. }
  2989. case SQL_DOUBLE:
  2990. {
  2991. type_enum=SQL_C_DOUBLE;
  2992. break;
  2993. }
  2994. case SQL_DATE:
  2995. {
  2996. break;
  2997. }
  2998. case SQL_TIME:
  2999. {
  3000. break;
  3001. }
  3002. case SQL_TYPE_TIMESTAMP:
  3003. {
  3004. type_enum=SQL_C_TYPE_TIMESTAMP;
  3005. break;
  3006. }
  3007. case SQL_BINARY:
  3008. {
  3009. break;
  3010. }
  3011. case SQL_VARBINARY:
  3012. {
  3014. break;
  3015. }
  3016. case SQL_LONGVARBINARY:
  3017. {
  3019. break;
  3020. }
  3021. default:
  3022. {
  3023. break;
  3024. }
  3025. }
  3027. rcode=SQLBindCol
  3028. (
  3029. statement_handle,
  3030. j,
  3031. type_enum,
  3032. columns[i].column_buffer,
  3033. columns[i].column_buffer_length,
  3034. &columns[i].data_length_indicator
  3035. );
  3036. if(rcode!=SQL_SUCCESS)
  3037. {
  3038. //Show state
  3039. connection.last_message+="\n[DBGetColumnsAndBind] SQLBindCol error!";
  3040. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3041. return false;
  3042. }
  3044. }
  3046. return true;
  3047. }
  3049. bool DBBindInsertParameters
  3050. (
  3051. DBConnection& connection,
  3052. SQLHSTMT& statement_handle,
  3053. const short& total_columns,
  3054. DBColumn*& columns
  3055. )
  3056. {
  3058. SQLRETURN rcode;
  3059. SQLSMALLINT type_enum;
  3060. SQLSMALLINT format_size=0;
  3061. short i,j;
  3063. for(i=0;i<total_columns;i++)
  3064. {
  3065. j=i+1;
  3067. switch(columns[i].column_type)
  3068. {
  3069. case SQL_BIT:
  3070. {
  3071. break;
  3072. }
  3073. case SQL_CHAR:
  3074. {
  3075. type_enum=SQL_C_CHAR;
  3076. columns[i].data_length_indicator=sizeof(char);
  3077. break;
  3078. }
  3079. case SQL_VARCHAR:
  3080. {
  3081. type_enum=SQL_C_CHAR;
  3082. columns[i].data_length_indicator=SQL_NTS;
  3083. break;
  3084. }
  3085. case SQL_LONGVARCHAR:
  3086. {
  3088. break;
  3089. }
  3090. case SQL_WCHAR:
  3091. {
  3092. break;
  3093. }
  3094. case SQL_WVARCHAR:
  3095. {
  3097. break;
  3098. }
  3099. case SQL_WLONGVARCHAR:
  3100. {
  3102. break;
  3103. }
  3104. case SQL_TINYINT:
  3105. {
  3106. type_enum=SQL_C_TINYINT;
  3107. columns[i].data_length_indicator=sizeof(unsigned char);
  3108. break;
  3109. }
  3110. case SQL_SMALLINT:
  3111. {
  3112. type_enum=SQL_C_SHORT;
  3113. columns[i].data_length_indicator=sizeof(short);
  3114. break;
  3115. }
  3116. case SQL_INTEGER:
  3117. {
  3118. type_enum=SQL_C_LONG;
  3119. columns[i].data_length_indicator=sizeof(int);
  3120. break;
  3121. }
  3122. case SQL_BIGINT:
  3123. {
  3124. type_enum=SQL_C_SBIGINT;
  3125. columns[i].data_length_indicator=sizeof(long);
  3126. break;
  3127. }
  3128. case SQL_DECIMAL:
  3129. {
  3130. break;
  3131. }
  3132. case SQL_NUMERIC:
  3133. {
  3134. break;
  3135. }
  3136. case SQL_REAL:
  3137. {
  3138. break;
  3139. }
  3140. case SQL_FLOAT:
  3141. {
  3142. type_enum=SQL_C_FLOAT;
  3143. format_size=9;
  3144. columns[i].data_length_indicator=sizeof(float);
  3145. break;
  3146. }
  3147. case SQL_DOUBLE:
  3148. {
  3149. type_enum=SQL_C_DOUBLE;
  3150. columns[i].data_length_indicator=sizeof(double);
  3151. format_size=16;
  3152. break;
  3153. }
  3154. case SQL_DATE:
  3155. {
  3156. break;
  3157. }
  3158. case SQL_TIME:
  3159. {
  3160. break;
  3161. }
  3162. case SQL_TYPE_TIMESTAMP:
  3163. {
  3164. type_enum=SQL_C_TYPE_TIMESTAMP;
  3165. format_size=4;
  3166. columns[i].data_length_indicator=sizeof(SQL_TIMESTAMP_STRUCT);
  3167. break;
  3168. }
  3169. case SQL_BINARY:
  3170. {
  3171. break;
  3172. }
  3173. case SQL_VARBINARY:
  3174. {
  3176. break;
  3177. }
  3178. case SQL_LONGVARBINARY:
  3179. {
  3181. break;
  3182. }
  3183. default:
  3184. {
  3185. break;
  3186. }
  3187. }
  3189. rcode = SQLBindParameter
  3190. (
  3191. statement_handle,
  3192. j,
  3193. SQL_PARAM_INPUT,
  3194. type_enum,
  3195. columns[i].column_type,
  3196. columns[i].column_buffer_length,
  3197. format_size,
  3198. columns[i].column_buffer,
  3199. columns[i].column_buffer_length,
  3200. &columns[i].data_length_indicator
  3201. );
  3202. if(rcode!=SQL_SUCCESS)
  3203. {
  3204. //Show state
  3205. connection.last_message+="\n[DBBindInsertParameters] ";
  3206. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3207. //cout << connection.last_message << endl;
  3208. return false;
  3209. }
  3211. }
  3213. return true;
  3214. }
  3216. bool DBBindUpdateParameters
  3217. (
  3218. DBConnection& connection,
  3219. SQLHSTMT& statement_handle,
  3220. const short& total_data_columns,
  3221. const short& total_primary_keys,
  3222. DBColumn*& data_columns,
  3223. DBColumn*& primary_keys
  3224. )
  3225. {
  3227. SQLRETURN rcode;
  3228. SQLSMALLINT type_enum;
  3229. SQLSMALLINT format_size=0;
  3230. short i;
  3231. short parameter_count=0;
  3233. for(i=0;i<total_data_columns;i++)
  3234. {
  3235. parameter_count++;
  3237. switch(data_columns[i].column_type)
  3238. {
  3239. case SQL_BIT:
  3240. {
  3241. break;
  3242. }
  3243. case SQL_CHAR:
  3244. {
  3245. type_enum=SQL_C_CHAR;
  3246. data_columns[i].data_length_indicator=sizeof(char);
  3247. break;
  3248. }
  3249. case SQL_VARCHAR:
  3250. {
  3251. type_enum=SQL_C_CHAR;
  3252. data_columns[i].data_length_indicator=SQL_NTS;
  3253. break;
  3254. }
  3255. case SQL_LONGVARCHAR:
  3256. {
  3258. break;
  3259. }
  3260. case SQL_WCHAR:
  3261. {
  3262. break;
  3263. }
  3264. case SQL_WVARCHAR:
  3265. {
  3267. break;
  3268. }
  3269. case SQL_WLONGVARCHAR:
  3270. {
  3272. break;
  3273. }
  3274. case SQL_TINYINT:
  3275. {
  3276. type_enum=SQL_C_TINYINT;
  3277. data_columns[i].data_length_indicator=sizeof(unsigned char);
  3278. break;
  3279. }
  3280. case SQL_SMALLINT:
  3281. {
  3282. type_enum=SQL_C_SHORT;
  3283. data_columns[i].data_length_indicator=sizeof(short);
  3284. break;
  3285. }
  3286. case SQL_INTEGER:
  3287. {
  3288. type_enum=SQL_C_LONG;
  3289. data_columns[i].data_length_indicator=sizeof(int);
  3290. break;
  3291. }
  3292. case SQL_BIGINT:
  3293. {
  3294. type_enum=SQL_C_SBIGINT;
  3295. data_columns[i].data_length_indicator=sizeof(long);
  3296. break;
  3297. }
  3298. case SQL_DECIMAL:
  3299. {
  3300. break;
  3301. }
  3302. case SQL_NUMERIC:
  3303. {
  3304. break;
  3305. }
  3306. case SQL_REAL:
  3307. {
  3308. break;
  3309. }
  3310. case SQL_FLOAT:
  3311. {
  3312. type_enum=SQL_C_FLOAT;
  3313. format_size=9;
  3314. data_columns[i].data_length_indicator=sizeof(float);
  3315. break;
  3316. }
  3317. case SQL_DOUBLE:
  3318. {
  3319. type_enum=SQL_C_DOUBLE;
  3320. data_columns[i].data_length_indicator=sizeof(double);
  3321. format_size=16;
  3322. break;
  3323. }
  3324. case SQL_DATE:
  3325. {
  3326. break;
  3327. }
  3328. case SQL_TIME:
  3329. {
  3330. break;
  3331. }
  3332. case SQL_TYPE_TIMESTAMP:
  3333. {
  3334. type_enum=SQL_C_TYPE_TIMESTAMP;
  3335. format_size=4;
  3336. data_columns[i].data_length_indicator=sizeof(SQL_TIMESTAMP_STRUCT);
  3337. break;
  3338. }
  3339. case SQL_BINARY:
  3340. {
  3341. break;
  3342. }
  3343. case SQL_VARBINARY:
  3344. {
  3346. break;
  3347. }
  3348. case SQL_LONGVARBINARY:
  3349. {
  3351. break;
  3352. }
  3353. default:
  3354. {
  3355. break;
  3356. }
  3357. }
  3359. rcode = SQLBindParameter
  3360. (
  3361. statement_handle,
  3362. parameter_count,
  3363. SQL_PARAM_INPUT,
  3364. type_enum,
  3365. data_columns[i].column_type,
  3366. data_columns[i].data_length_indicator,
  3367. format_size,
  3368. data_columns[i].column_buffer,
  3369. data_columns[i].column_buffer_length,
  3370. &data_columns[i].data_length_indicator
  3371. );
  3372. if(rcode!=SQL_SUCCESS)
  3373. {
  3374. //Show state
  3375. connection.last_message+="\n[DBBindUpdateParameters] error executing \
  3376. SQLBindParameter at columns!\n";
  3377. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3378. //cout << connection.last_message << endl;
  3379. return false;
  3380. }
  3382. }
  3384. for(i=0;i<total_primary_keys;i++)
  3385. {
  3386. parameter_count++;
  3388. switch(primary_keys[i].column_type)
  3389. {
  3390. case SQL_BIT:
  3391. {
  3392. break;
  3393. }
  3394. case SQL_CHAR:
  3395. {
  3396. type_enum=SQL_C_CHAR;
  3397. primary_keys[i].data_length_indicator=sizeof(char);
  3398. break;
  3399. }
  3400. case SQL_VARCHAR:
  3401. {
  3402. type_enum=SQL_C_CHAR;
  3403. primary_keys[i].data_length_indicator=SQL_NTS;
  3404. break;
  3405. }
  3406. case SQL_LONGVARCHAR:
  3407. {
  3409. break;
  3410. }
  3411. case SQL_WCHAR:
  3412. {
  3413. break;
  3414. }
  3415. case SQL_WVARCHAR:
  3416. {
  3418. break;
  3419. }
  3420. case SQL_WLONGVARCHAR:
  3421. {
  3423. break;
  3424. }
  3425. case SQL_TINYINT:
  3426. {
  3427. type_enum=SQL_C_TINYINT;
  3428. primary_keys[i].data_length_indicator=sizeof(unsigned char);
  3429. break;
  3430. }
  3431. case SQL_SMALLINT:
  3432. {
  3433. type_enum=SQL_C_SHORT;
  3434. primary_keys[i].data_length_indicator=sizeof(short);
  3435. break;
  3436. }
  3437. case SQL_INTEGER:
  3438. {
  3439. type_enum=SQL_C_LONG;
  3440. primary_keys[i].data_length_indicator=sizeof(int);
  3441. break;
  3442. }
  3443. case SQL_BIGINT:
  3444. {
  3445. type_enum=SQL_C_SBIGINT;
  3446. primary_keys[i].data_length_indicator=sizeof(long);
  3447. break;
  3448. }
  3449. case SQL_DECIMAL:
  3450. {
  3451. break;
  3452. }
  3453. case SQL_NUMERIC:
  3454. {
  3455. break;
  3456. }
  3457. case SQL_REAL:
  3458. {
  3459. break;
  3460. }
  3461. case SQL_FLOAT:
  3462. {
  3463. type_enum=SQL_C_FLOAT;
  3464. format_size=9;
  3465. primary_keys[i].data_length_indicator=sizeof(float);
  3466. break;
  3467. }
  3468. case SQL_DOUBLE:
  3469. {
  3470. type_enum=SQL_C_DOUBLE;
  3471. primary_keys[i].data_length_indicator=sizeof(double);
  3472. format_size=16;
  3473. break;
  3474. }
  3475. case SQL_DATE:
  3476. {
  3477. break;
  3478. }
  3479. case SQL_TIME:
  3480. {
  3481. break;
  3482. }
  3483. case SQL_TYPE_TIMESTAMP:
  3484. {
  3485. type_enum=SQL_C_TYPE_TIMESTAMP;
  3486. format_size=4;
  3487. primary_keys[i].data_length_indicator=sizeof(SQL_TIMESTAMP_STRUCT);
  3488. break;
  3489. }
  3490. case SQL_BINARY:
  3491. {
  3492. break;
  3493. }
  3494. case SQL_VARBINARY:
  3495. {
  3497. break;
  3498. }
  3499. case SQL_LONGVARBINARY:
  3500. {
  3502. break;
  3503. }
  3504. default:
  3505. {
  3506. break;
  3507. }
  3508. }
  3510. rcode = SQLBindParameter
  3511. (
  3512. statement_handle,
  3513. parameter_count,
  3514. SQL_PARAM_INPUT,
  3515. type_enum,
  3516. primary_keys[i].column_type,
  3517. primary_keys[i].data_length_indicator,
  3518. format_size,
  3519. primary_keys[i].column_buffer,
  3520. primary_keys[i].column_buffer_length,
  3521. &primary_keys[i].data_length_indicator
  3522. );
  3523. if(rcode!=SQL_SUCCESS)
  3524. {
  3525. //Show state
  3526. connection.last_message+="\n[DBBindUpdateParameters] error executing \
  3527. SQLBindParameter at primary keys!\n";
  3528. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3529. //cout << connection.last_message << endl;
  3530. return false;
  3531. }
  3533. }
  3535. return true;
  3536. }
  3538. bool DBBindDeleteParameters
  3539. (
  3540. DBConnection& connection,
  3541. SQLHSTMT& statement_handle,
  3542. const short& total_primary_keys,
  3543. DBColumn*& primary_keys
  3544. )
  3545. {
  3546. SQLRETURN rcode;
  3547. SQLSMALLINT type_enum;
  3548. SQLSMALLINT format_size=0;
  3549. short i;
  3550. short parameter_count=0;
  3552. for(i=0;i<total_primary_keys;i++)
  3553. {
  3554. parameter_count++;
  3556. switch(primary_keys[i].column_type)
  3557. {
  3558. case SQL_BIT:
  3559. {
  3560. break;
  3561. }
  3562. case SQL_CHAR:
  3563. {
  3564. type_enum=SQL_C_CHAR;
  3565. primary_keys[i].data_length_indicator=sizeof(char);
  3566. break;
  3567. }
  3568. case SQL_VARCHAR:
  3569. {
  3570. type_enum=SQL_C_CHAR;
  3571. primary_keys[i].data_length_indicator=SQL_NTS;
  3572. break;
  3573. }
  3574. case SQL_LONGVARCHAR:
  3575. {
  3577. break;
  3578. }
  3579. case SQL_WCHAR:
  3580. {
  3581. break;
  3582. }
  3583. case SQL_WVARCHAR:
  3584. {
  3586. break;
  3587. }
  3588. case SQL_WLONGVARCHAR:
  3589. {
  3591. break;
  3592. }
  3593. case SQL_TINYINT:
  3594. {
  3595. type_enum=SQL_C_TINYINT;
  3596. primary_keys[i].data_length_indicator=sizeof(unsigned char);
  3597. break;
  3598. }
  3599. case SQL_SMALLINT:
  3600. {
  3601. type_enum=SQL_C_SHORT;
  3602. primary_keys[i].data_length_indicator=sizeof(short);
  3603. break;
  3604. }
  3605. case SQL_INTEGER:
  3606. {
  3607. type_enum=SQL_C_LONG;
  3608. primary_keys[i].data_length_indicator=sizeof(int);
  3609. break;
  3610. }
  3611. case SQL_BIGINT:
  3612. {
  3613. type_enum=SQL_C_SBIGINT;
  3614. primary_keys[i].data_length_indicator=sizeof(long);
  3615. break;
  3616. }
  3617. case SQL_DECIMAL:
  3618. {
  3619. break;
  3620. }
  3621. case SQL_NUMERIC:
  3622. {
  3623. break;
  3624. }
  3625. case SQL_REAL:
  3626. {
  3627. break;
  3628. }
  3629. case SQL_FLOAT:
  3630. {
  3631. type_enum=SQL_C_FLOAT;
  3632. format_size=9;
  3633. primary_keys[i].data_length_indicator=sizeof(float);
  3634. break;
  3635. }
  3636. case SQL_DOUBLE:
  3637. {
  3638. type_enum=SQL_C_DOUBLE;
  3639. primary_keys[i].data_length_indicator=sizeof(double);
  3640. format_size=16;
  3641. break;
  3642. }
  3643. case SQL_DATE:
  3644. {
  3645. break;
  3646. }
  3647. case SQL_TIME:
  3648. {
  3649. break;
  3650. }
  3651. case SQL_TYPE_TIMESTAMP:
  3652. {
  3653. type_enum=SQL_C_TYPE_TIMESTAMP;
  3654. format_size=4;
  3655. primary_keys[i].data_length_indicator=sizeof(SQL_TIMESTAMP_STRUCT);
  3656. break;
  3657. }
  3658. case SQL_BINARY:
  3659. {
  3660. break;
  3661. }
  3662. case SQL_VARBINARY:
  3663. {
  3665. break;
  3666. }
  3667. case SQL_LONGVARBINARY:
  3668. {
  3670. break;
  3671. }
  3672. default:
  3673. {
  3674. break;
  3675. }
  3676. }
  3678. rcode = SQLBindParameter
  3679. (
  3680. statement_handle,
  3681. parameter_count,
  3682. SQL_PARAM_INPUT,
  3683. type_enum,
  3684. primary_keys[i].column_type,
  3685. primary_keys[i].data_length_indicator,
  3686. format_size,
  3687. primary_keys[i].column_buffer,
  3688. primary_keys[i].column_buffer_length,
  3689. &primary_keys[i].data_length_indicator
  3690. );
  3691. if(rcode!=SQL_SUCCESS)
  3692. {
  3693. //Show state
  3694. connection.last_message+="\n[DBBindDeleteParameters] error executing \
  3695. SQLBindParameter at primary keys!\n";
  3696. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3697. //cout << connection.last_message << endl;
  3698. return false;
  3699. }
  3701. }
  3703. return true;
  3704. }
  3706. bool DBPrepareSelect
  3707. (
  3708. DBConnection& connection,
  3709. SQLHSTMT& statement_handle,
  3710. const std::string& sqlcmd
  3711. )
  3712. {
  3713. SQLRETURN rcode;
  3715. //Allocate statement handle
  3716. rcode=SQLAllocHandle
  3717. (
  3718. SQL_HANDLE_STMT,
  3719. connection.database_connection_handle,
  3720. &statement_handle
  3721. );
  3722. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3723. {
  3724. connection.last_message="\n[DBPrepareSelect] Can't allocate statement handle!";
  3725. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3726. return false;
  3727. }
  3729. //Set cursor statement attribute
  3730. rcode=SQLSetStmtAttr
  3731. (
  3732. statement_handle,
  3733. SQL_ATTR_CURSOR_TYPE,
  3734. (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,
  3735. 0
  3736. );
  3737. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3738. {
  3739. connection.last_message="\n[DBPrepareSelect] Can't set cursor attribute!";
  3740. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3741. return false;
  3742. }
  3744. //Set cursor row size statement attribute
  3745. rcode=SQLSetStmtAttr
  3746. (
  3747. statement_handle,
  3748. SQL_ATTR_ROW_ARRAY_SIZE,
  3749. (SQLPOINTER)1,
  3750. SQL_IS_UINTEGER
  3751. );
  3752. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3753. {
  3754. connection.last_message="\n[DBPrepareSelect] Can't set cursor size attribute!";
  3755. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3756. return false;
  3757. }
  3759. //Set concurrency statement attribute
  3760. rcode=SQLSetStmtAttr
  3761. (
  3762. statement_handle,
  3763. SQL_ATTR_CONCURRENCY,
  3764. (SQLPOINTER)SQL_CONCUR_READ_ONLY,
  3765. 0
  3766. );
  3767. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3768. {
  3769. connection.last_message="\n[DBPrepareSelect] Can't set concurrency attribute!";
  3770. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3771. return false;
  3772. }
  3774. //Prepare SQl command
  3775. rcode=SQLPrepare
  3776. (
  3777. statement_handle,
  3778. (PSQLCHAR)sqlcmd.c_str(),
  3779. (SQLINTEGER)strlen(sqlcmd.c_str())
  3780. );
  3781. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3782. {
  3783. connection.sql_command_prepared=false;
  3784. connection.last_message="\n[DBPrepareSelect] Can't prepare SQL statement!";
  3785. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3786. return false;
  3787. }
  3788. connection.sql_command_prepared=true;
  3790. //THE ASYNCHRONOUS SUPPORT FOR NOW IS NOT USED GIVEN THAT DM (DRIVER MANAGER)
  3791. //IS A TOO OLD VERSION THAT NOT SUPPORT ASKING FOR ASYNCHRONOUS TASKS TO FINISH
  3792. //FOR NOW THIS PROBLEM CANNOT BE HANDLED
  3793. //Set asynchronous support statement attribute
  3794. //rcode=SQLSetStmtAttr(connection.statement_handle,SQL_ATTR_ASYNC_ENABLE,(SQLPOINTER)SQL_ASYNC_ENABLE_ON,0);
  3795. //if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3796. //{
  3797. // connection.last_message="\n[DBPrepareStatement]Can't set asynchronous support attribute!";
  3798. // connection.last_message+="";
  3799. // connection.last_message+=DBGetErrorMsg(connection,SQL_HANDLE_STMT);
  3800. // return false;
  3801. //}
  3803. return true;
  3804. }
  3806. bool DBPrepareInsert
  3807. (
  3808. DBConnection& connection,
  3809. SQLHSTMT& statement_handle,
  3810. const std::string& sqlcmd
  3811. )
  3812. {
  3813. SQLRETURN rcode;
  3815. //Allocate statement handle
  3816. rcode=SQLAllocHandle
  3817. (
  3818. SQL_HANDLE_STMT,
  3819. connection.database_connection_handle,
  3820. &statement_handle
  3821. );
  3822. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3823. {
  3824. connection.last_message="\n[DBPrepareInsert] Can't allocate statement handle!";
  3825. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3826. return false;
  3827. }
  3829. //Set cursor statement attribute
  3830. rcode=SQLSetStmtAttr
  3831. (
  3832. statement_handle,
  3833. SQL_ATTR_CURSOR_TYPE,
  3834. (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,
  3835. 0
  3836. );
  3837. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3838. {
  3839. connection.last_message="\n[DBPrepareInsert] Can't set cursor attribute!";
  3840. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3841. return false;
  3842. }
  3844. //Set cursor row size statement attribute
  3845. rcode=SQLSetStmtAttr
  3846. (
  3847. statement_handle,
  3848. SQL_ATTR_ROW_ARRAY_SIZE,
  3849. (SQLPOINTER)1,
  3850. SQL_IS_UINTEGER
  3851. );
  3852. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3853. {
  3854. connection.last_message="\n[DBPrepareInsert] Can't set cursor size attribute!";
  3855. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3856. return false;
  3857. }
  3859. //Set concurrency statement attribute
  3860. rcode=SQLSetStmtAttr
  3861. (
  3862. statement_handle,
  3863. SQL_ATTR_CONCURRENCY,
  3864. (SQLPOINTER)SQL_CONCUR_DEFAULT,
  3865. 0
  3866. );
  3867. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3868. {
  3869. connection.last_message="\n[DBPrepareInsert] Can't set concurrency attribute!";
  3870. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3871. return false;
  3872. }
  3874. //To indicate column binding
  3875. rcode=SQLSetStmtAttr
  3876. (
  3877. statement_handle,
  3878. SQL_ATTR_PARAM_BIND_TYPE,
  3879. SQL_PARAM_BIND_BY_COLUMN,
  3880. 0
  3881. );
  3882. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3883. {
  3884. connection.last_message="\n[DBPrepareInsert] Can't set parameter binding type \
  3885. attribute!";
  3886. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3887. return false;
  3888. }
  3890. //To indicate the number of parameters to bind
  3891. SQLUSMALLINT total_parameters;
  3892. size_t n=std::count(sqlcmd.begin(), sqlcmd.end(),'?');
  3893. if(n>0)
  3894. {
  3895. total_parameters=(SQLUSMALLINT)n;
  3896. }
  3897. else
  3898. {
  3899. connection.last_message="\n[DBPrepareInsert] Bad SQL command!";
  3900. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3901. return false;
  3902. }
  3903. rcode=SQLSetStmtAttr
  3904. (
  3905. statement_handle,
  3906. SQL_ATTR_PARAMSET_SIZE,
  3907. (SQLPOINTER)(&total_parameters),
  3908. 0
  3909. );
  3910. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3911. {
  3912. connection.last_message="\n[DBPrepareInsert] Can't set the number of parameters \
  3913. binding attribute!";
  3914. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3915. return false;
  3916. }
  3918. //To indicate the rows per parameter set
  3919. rcode=SQLSetStmtAttr
  3920. (
  3921. statement_handle,
  3922. SQL_ATTR_PARAMSET_SIZE,
  3923. (SQLPOINTER)1,
  3924. 0
  3925. );
  3926. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3927. {
  3928. connection.last_message="\n[DBPrepareInsert] Can't set parameter binding type \
  3929. attribute!";
  3930. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3931. return false;
  3932. }
  3934. // //Prepare SQl command
  3935. // rcode=SQLPrepare(connection.statement_handle,(PSQLCHAR)sqlcmd.c_str(),
  3936. // (SQLINTEGER)strlen(sqlcmd.c_str()));
  3937. // if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3938. // {
  3939. // connection.sql_command_prepared=false;
  3940. // connection.last_message="\n[DBPrepareInsert] Can't prepare SQL statement!";
  3941. // connection.last_message+="";
  3942. // connection.last_message+=DBGetErrorMsg(connection,SQL_HANDLE_STMT);
  3943. // return false;
  3944. // }
  3945. // connection.sql_command_prepared=true;
  3947. return true;
  3948. }
  3950. bool DBPrepareUpdate
  3951. (
  3952. DBConnection& connection,
  3953. SQLHSTMT& statement_handle,
  3954. const std::string& sqlcmd
  3955. )
  3956. {
  3957. SQLRETURN rcode;
  3959. //Allocate statement handle
  3960. rcode=SQLAllocHandle
  3961. (
  3962. SQL_HANDLE_STMT,
  3963. connection.database_connection_handle,
  3964. &statement_handle
  3965. );
  3966. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3967. {
  3968. connection.last_message="\n[DBPrepareUpdate] Can't allocate statement handle!";
  3969. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3970. return false;
  3971. }
  3973. //Set cursor statement attribute
  3974. rcode=SQLSetStmtAttr
  3975. (
  3976. statement_handle,
  3977. SQL_ATTR_CURSOR_TYPE,
  3978. (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,
  3979. 0
  3980. );
  3981. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3982. {
  3983. connection.last_message="\n[DBPrepareUpdate] Can't set cursor attribute!";
  3984. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  3985. return false;
  3986. }
  3988. //Set cursor row size statement attribute
  3989. rcode=SQLSetStmtAttr
  3990. (
  3991. statement_handle,
  3992. SQL_ATTR_ROW_ARRAY_SIZE,
  3993. (SQLPOINTER)1,
  3994. SQL_IS_UINTEGER
  3995. );
  3996. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  3997. {
  3998. connection.last_message="\n[DBPrepareUpdate] Can't set cursor size attribute!";
  3999. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4000. return false;
  4001. }
  4003. //Set concurrency statement attribute
  4004. rcode=SQLSetStmtAttr
  4005. (
  4006. statement_handle,
  4007. SQL_ATTR_CONCURRENCY,
  4008. (SQLPOINTER)SQL_CONCUR_DEFAULT,
  4009. 0
  4010. );
  4011. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4012. {
  4013. connection.last_message="\n[DBPrepareUpdate] Can't set concurrency attribute!";
  4014. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4015. return false;
  4016. }
  4018. //To indicate column binding
  4019. rcode=SQLSetStmtAttr
  4020. (
  4021. statement_handle,
  4022. SQL_ATTR_PARAM_BIND_TYPE,
  4023. SQL_PARAM_BIND_BY_COLUMN,
  4024. 0
  4025. );
  4026. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4027. {
  4028. connection.last_message="\n[DBPrepareUpdate] Can't set parameter binding type \
  4029. attribute!";
  4030. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4031. return false;
  4032. }
  4034. return true;
  4035. }
  4037. bool DBPrepareDelete
  4038. (
  4039. DBConnection& connection,
  4040. SQLHSTMT& statement_handle,
  4041. const std::string& sqlcmd
  4042. )
  4043. {
  4044. SQLRETURN rcode;
  4046. //Allocate statement handle
  4047. rcode=SQLAllocHandle
  4048. (
  4049. SQL_HANDLE_STMT,
  4050. connection.database_connection_handle,
  4051. &statement_handle
  4052. );
  4053. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4054. {
  4055. connection.last_message="\n[DBPrepareDelete] Can't allocate statement handle!";
  4056. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4057. return false;
  4058. }
  4060. //Set cursor statement attribute
  4061. rcode=SQLSetStmtAttr
  4062. (
  4063. statement_handle,
  4064. SQL_ATTR_CURSOR_TYPE,
  4065. (SQLPOINTER)SQL_CURSOR_FORWARD_ONLY,
  4066. 0
  4067. );
  4068. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4069. {
  4070. connection.last_message="\n[DBPrepareDelete] Can't set cursor attribute!";
  4071. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4072. return false;
  4073. }
  4075. //Set cursor row size statement attribute
  4076. rcode=SQLSetStmtAttr
  4077. (
  4078. statement_handle,
  4079. SQL_ATTR_ROW_ARRAY_SIZE,
  4080. (SQLPOINTER)1,
  4081. SQL_IS_UINTEGER
  4082. );
  4083. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4084. {
  4085. connection.last_message="\n[DBPrepareDelete] Can't set cursor size attribute!";
  4086. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4087. return false;
  4088. }
  4090. //Set concurrency statement attribute
  4091. rcode=SQLSetStmtAttr
  4092. (
  4093. statement_handle,
  4094. SQL_ATTR_CONCURRENCY,
  4095. (SQLPOINTER)SQL_CONCUR_DEFAULT,
  4096. 0
  4097. );
  4098. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4099. {
  4100. connection.last_message="\n[DBPrepareDelete] Can't set concurrency attribute!";
  4101. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4102. return false;
  4103. }
  4105. //To indicate column binding
  4106. rcode=SQLSetStmtAttr
  4107. (
  4108. statement_handle,
  4109. SQL_ATTR_PARAM_BIND_TYPE,
  4110. SQL_PARAM_BIND_BY_COLUMN,
  4111. 0
  4112. );
  4113. if(rcode!=SQL_SUCCESS && rcode!=SQL_SUCCESS_WITH_INFO)
  4114. {
  4115. connection.last_message="\n[DBPrepareDelete] Can't set parameter binding type \
  4116. attribute!";
  4117. connection.last_message+=DBGetErrorMsg(statement_handle,SQL_HANDLE_STMT);
  4118. return false;
  4119. }
  4121. return true;
  4122. }
  4124. }//odbc_database_operations namespace
  4126. }//databases namespace
comments powered by Disqus