开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 文件操作 > 查看源码
CSpreadSheet.h
资源名称：Excel.rar　[点击查看]
上传用户：aymxxn
上传日期：2014-11-29
资源大小：135k
文件大小：33k
源码类别：

文件操作

开发平台：

Visual C++

CSpreadSheet.h：源码内容
  1. // Class to read and write to Excel and text delimited spreadsheet
  2. //
  3. // Created by Yap Chun Wei
  4. // December 2001
  5. // 
  6. // Version 1.1
  7. // Updates: Fix bug in ReadRow() which prevent reading of single column spreadsheet
  8. // Modified by jingzhou xu
  10. #ifndef CSPREADSHEET_H
  11. #define CSPREADSHEET_H
  13. #include <odbcinst.h>
  14. #include <afxdb.h>
  16. class CSpreadSheet
  17. {
  18. public:
  19. CSpreadSheet(CString File, CString SheetOrSeparator, bool Backup = true); // Open spreadsheet for reading and writing
  20. ~CSpreadSheet(); // Perform some cleanup functions
  21. bool AddHeaders(CStringArray &FieldNames, bool replace = false); // Add header row to spreadsheet
  22. bool DeleteSheet(); // Clear text delimited file content
  23. bool DeleteSheet(CString SheetName); // Clear entire Excel spreadsheet content. The sheet itself is not deleted
  24. bool AddRow(CStringArray &RowValues, long row = 0, bool replace = false); // Insert or replace a row into spreadsheet. Default is add new row. 
  25. bool AddCell(CString CellValue, CString column, long row = 0, bool Auto = true); // Replace or add a cell into Excel spreadsheet using header row or column alphabet. Default is add cell into new row. Set Auto to false if want to force column to be used as header name
  26. bool AddCell(CString CellValue, short column, long row = 0); // Replace or add a cell into spreadsheet using column number. Default is add cell into new row. 
  27. bool ReplaceRows(CStringArray &NewRowValues, CStringArray &OldRowValues); // Search and replace rows in Excel spreadsheet
  28. bool ReadRow(CStringArray &RowValues, long row = 0); // Read a row from spreadsheet. Default is read the next row
  29. bool ReadColumn(CStringArray &ColumnValues, CString column, bool Auto = true); // Read a column from Excel spreadsheet using header row or column alphabet. Set Auto to false if want to force column to be used as header name
  30. bool ReadColumn(CStringArray &ColumnValues, short column); // Read a column from spreadsheet using column number
  31. bool ReadCell (CString &CellValue, CString column, long row = 0, bool Auto = true); // Read a cell from Excel spreadsheet using header row or column alphabet. Default is read the next cell in next row. Set Auto to false if want to force column to be used as header name
  32. bool ReadCell (CString &CellValue, short column, long row = 0); // Read a cell from spreadsheet using column number. Default is read the next cell in next row.
  33. void BeginTransaction(); // Begin transaction
  34. bool Commit(); // Save changes to spreadsheet
  35. bool RollBack(); // Undo changes to spreadsheet
  36. bool Convert(CString SheetOrSeparator);
  37. inline void GetFieldNames (CStringArray &FieldNames) {FieldNames.RemoveAll(); FieldNames.Copy(m_aFieldNames);} // Get the header row from spreadsheet
  38. inline long GetTotalRows() {return m_dTotalRows;} // Get total number of rows in  spreadsheet
  39. inline short GetTotalColumns() {return m_dTotalColumns;} // Get total number of columns in  spreadsheet
  40. inline long GetCurrentRow() {return m_dCurrentRow;} // Get the currently selected row in  spreadsheet
  41. inline bool GetBackupStatus() {return m_bBackup;} // Get status of backup. True if backup is successful, False if spreadsheet is not backup
  42. inline bool GetTransactionStatus() {return m_bTransaction;} // Get status of Transaction. True if Transaction is started, False if Transaction is not started or has error in starting
  43. inline CString GetLastError() {return m_sLastError;} // Get last error message
  45. private:
  46. bool Open(); // Open a text delimited file for reading or writing
  47. void GetExcelDriver(); // Get the name of the Excel-ODBC driver
  48. short CalculateColumnNumber(CString column, bool Auto); // Convert Excel column in alphabet into column number
  50. bool m_bAppend; // Internal flag to denote newly created spreadsheet or previously created spreadsheet
  51. bool m_bBackup; // Internal flag to denote status of Backup
  52. bool m_bExcel; // Internal flag to denote whether file is Excel spreadsheet or text delimited spreadsheet
  53. bool m_bTransaction; // Internal flag to denote status of Transaction
  55. long m_dCurrentRow; // Index of current row, starting from 1
  56. long m_dTotalRows; // Total number of rows in spreadsheet
  57. short m_dTotalColumns; // Total number of columns in Excel spreadsheet. Largest number of columns in text delimited spreadsheet
  59. CString m_sSql; // SQL statement to open Excel spreadsheet for reading
  60. CString m_sDsn; // DSN string to open Excel spreadsheet for reading and writing
  61. CString m_stempSql; // Temporary string for SQL statements or for use by functions
  62. CString m_stempString; // Temporary string for use by functions
  63. CString m_sSheetName; // Sheet name of Excel spreadsheet
  64. CString m_sExcelDriver; // Name of Excel Driver
  65. CString m_sFile; // Spreadsheet file name
  66. CString m_sSeparator; // Separator in text delimited spreadsheet
  67. CString m_sLastError; // Last error message
  69. CStringArray m_atempArray; // Temporary array for use by functions
  70. CStringArray m_aFieldNames; // Header row in spreadsheet
  71. CStringArray m_aRows; // Content of all the rows in spreadsheet
  73. CDatabase *m_Database; // Database variable for Excel spreadsheet
  74. CRecordset *m_rSheet; // Recordset for Excel spreadsheet
  75. };
  77. // Open spreadsheet for reading and writing
  78. CSpreadSheet::CSpreadSheet(CString File, CString SheetOrSeparator, bool Backup) :
  79. m_Database(NULL), m_rSheet(NULL), m_sFile(File),
  80. m_dTotalRows(0), m_dTotalColumns(0), m_dCurrentRow(1),
  81. m_bAppend(false), m_bBackup(Backup), m_bTransaction(false)
  82. {
  83. // Detect whether file is an Excel spreadsheet or a text delimited file
  84. m_stempString = m_sFile.Right(4);
  85. m_stempString.MakeLower();
  86. if (m_stempString == ".xls") // File is an Excel spreadsheet
  87. {
  88. m_bExcel = true;
  89. m_sSheetName = SheetOrSeparator;
  90. m_sSeparator = ",;.?";
  91. }
  92. else // File is a text delimited file
  93. {
  94. m_bExcel = false;
  95. m_sSeparator = SheetOrSeparator;
  96. }
  98. if (m_bExcel) // If file is an Excel spreadsheet
  99. {
  100. m_Database = new CDatabase;
  101. GetExcelDriver();
  102. m_sDsn.Format("DRIVER={%s};DSN='';FIRSTROWHASNAMES=1;READONLY=FALSE;CREATE_DB="%s";DBQ=%s", m_sExcelDriver, m_sFile, m_sFile);
  104. if (Open())
  105. {
  106. if (m_bBackup)
  107. {
  108. if ((m_bBackup) && (m_bAppend))
  109. {
  110. CString tempSheetName = m_sSheetName;
  111. m_sSheetName = "CSpreadSheetBackup";
  112. m_bAppend = false;
  113. if (!Commit())
  114. {
  115. m_bBackup = false;
  116. }
  117. m_bAppend = true;
  118. m_sSheetName = tempSheetName;
  119. m_dCurrentRow = 1;
  120. }
  121. }
  122. }
  123. }
  124. else // if file is a text delimited file
  125. {
  126. if (Open())
  127. {
  128. if ((m_bBackup) && (m_bAppend))
  129. {
  130. m_stempString = m_sFile;
  131. m_stempSql.Format("%s.bak", m_sFile);
  132. m_sFile = m_stempSql;
  133. if (!Commit())
  134. {
  135. m_bBackup = false;
  136. }
  137. m_sFile = m_stempString;
  138. }
  139. }
  140. }
  141. }
  143. // Perform some cleanup functions
  144. CSpreadSheet::~CSpreadSheet()
  145. {
  146. if (m_Database != NULL)
  147. {
  148. m_Database->Close();
  149. delete m_Database;
  150. }
  151. }
  153. // Add header row to spreadsheet
  154. bool CSpreadSheet::AddHeaders(CStringArray &FieldNames, bool replace)
  155. {
  156. if (m_bAppend) // Append to old Sheet
  157. {
  158. if (replace) // Replacing header row rather than adding new columns
  159. {
  160. if (!AddRow(FieldNames, 1, true))
  161. {
  162. return false;
  163. }
  164. else
  165. {
  166. return true;
  167. }
  168. }
  170. if (ReadRow(m_atempArray, 1)) // Add new columns
  171. {
  172. if (m_bExcel)
  173. {
  174. // Check for duplicate header row field
  175. for (int i = 0; i < FieldNames.GetSize(); i++)
  176. {
  177. for (int j = 0; j < m_atempArray.GetSize(); j++)
  178. {
  179. if (FieldNames.GetAt(i) == m_atempArray.GetAt(j))
  180. {
  181. m_sLastError.Format("Duplicate header row field:%sn", FieldNames.GetAt(i));
  182. return false;
  183. }
  184. }
  185. }
  186. }
  188. m_atempArray.Append(FieldNames);
  189. if (!AddRow(m_atempArray, 1, true))
  190. {
  191. m_sLastError = "Problems with adding headersn";
  192. return false;
  193. }
  195. // Update largest number of columns if necessary
  196. if (m_atempArray.GetSize() > m_dTotalColumns)
  197. {
  198. m_dTotalColumns = m_atempArray.GetSize();
  199. }
  200. return true;
  201. }
  202. return false;
  203. }
  204. else // New Sheet
  205. {
  206. m_dTotalColumns = FieldNames.GetSize();
  207. if (!AddRow(FieldNames, 1, true))
  208. {
  209. return false;
  210. }
  211. else
  212. {
  213. m_dTotalRows = 1;
  214. return true;
  215. }
  216. }
  217. }
  219. // Clear text delimited file content
  220. bool CSpreadSheet::DeleteSheet()
  221. {
  222. if (m_bExcel)
  223. {
  224. if (DeleteSheet(m_sSheetName))
  225. {
  226. return true;
  227. }
  228. else
  229. {
  230. m_sLastError = "Error deleting sheetn";
  231. return false;
  232. }
  233. }
  234. else
  235. {
  236. m_aRows.RemoveAll();
  237. m_aFieldNames.RemoveAll();
  238. m_dTotalColumns = 0;
  239. m_dTotalRows = 0;
  240. if (!m_bTransaction)
  241. {
  242. Commit();
  243. }
  244. m_bAppend = false; // Set flag to new sheet
  245. return true;
  246. }
  247. }
  249. // Clear entire Excel spreadsheet content. The sheet itself is not deleted
  250. bool CSpreadSheet::DeleteSheet(CString SheetName)
  251. {
  252. if (m_bExcel) // If file is an Excel spreadsheet
  253. {
  254. // Delete sheet
  255. m_Database->OpenEx(m_sDsn, CDatabase::noOdbcDialog);
  256. SheetName = "[" + SheetName + "$A1:IV65536]";
  257. m_stempSql.Format ("DROP TABLE %s", SheetName);
  258. try
  259. {
  260. m_Database->ExecuteSQL(m_stempSql);
  261. m_Database->Close();
  262. m_aRows.RemoveAll();
  263. m_aFieldNames.RemoveAll();
  264. m_dTotalColumns = 0;
  265. m_dTotalRows = 0;
  266. }
  267. catch(CDBException *e)
  268. {
  269. m_sLastError = e->m_strError;
  270. m_Database->Close();
  271. return false;
  272. }
  273. return true;
  274. }
  275. else // if file is a text delimited file
  276. {
  277. return DeleteSheet();
  278. }
  279. }
  281. // Insert or replace a row into spreadsheet. 
  282. // Default is add new row.
  283. bool CSpreadSheet::AddRow(CStringArray &RowValues, long row, bool replace)
  284. {
  285. long tempRow;
  287. if (row == 1)
  288. {
  289. if (m_bExcel) 
  290. {
  291. // Check for duplicate header row field for Excel spreadsheet
  292. for (int i = 0; i < RowValues.GetSize(); i++)
  293. {
  294. for (int j = 0; j < RowValues.GetSize(); j++)
  295. {
  296. if ((i != j) && (RowValues.GetAt(i) == RowValues.GetAt(j)))
  297. {
  298. m_sLastError.Format("Duplicate header row field:%sn", RowValues.GetAt(i));
  299. return false;
  300. }
  301. }
  302. }
  304. // Check for reduced header row columns
  305. if (RowValues.GetSize() < m_dTotalColumns)
  306. {
  307. m_sLastError = "Number of columns in new header row cannot be less than the number of columns in previous header row";
  308. return false;
  309. }
  310. m_dTotalColumns = RowValues.GetSize();
  311. }
  313. // Update header row
  314. m_aFieldNames.RemoveAll();
  315. m_aFieldNames.Copy(RowValues);
  316. }
  317. else
  318. {
  319. if (m_bExcel)
  320. {
  321. if (m_dTotalColumns == 0)
  322. {
  323. m_sLastError = "No header row. Add header row firstn";
  324. return false;
  325. }
  326. }
  327. }
  329. if (m_bExcel) // For Excel spreadsheet
  330. {
  331. if (RowValues.GetSize() > m_aFieldNames.GetSize())
  332. {
  333. m_sLastError = "Number of columns to be added cannot be greater than the number of fieldsn";
  334. return false;
  335. }
  336. }
  337. else // For text delimited spreadsheet
  338. {
  339. // Update largest number of columns if necessary
  340. if (RowValues.GetSize() > m_dTotalColumns)
  341. {
  342. m_dTotalColumns = RowValues.GetSize();
  343. }
  344. }
  346. // Convert row values
  347. m_stempString.Empty();
  348. for (int i = 0; i < RowValues.GetSize(); i++)
  349. {
  350. if (i != RowValues.GetSize()-1) // Not last column
  351. {
  352. m_stempSql.Format(""%s"%s", RowValues.GetAt(i), m_sSeparator);
  353. m_stempString += m_stempSql;
  354. }
  355. else // Last column
  356. {
  357. m_stempSql.Format(""%s"", RowValues.GetAt(i));
  358. m_stempString += m_stempSql;
  359. }
  360. }
  362. if (row)
  363. {
  364. if (row <= m_dTotalRows) // Not adding new rows
  365. {
  366. if (replace) // Replacing row
  367. {
  368. m_aRows.SetAt(row-1, m_stempString);
  369. }
  370. else // Inserting row
  371. {
  372. m_aRows.InsertAt(row-1, m_stempString);
  373. m_dTotalRows++;
  374. }
  376. if (!m_bTransaction)
  377. {
  378. Commit();
  379. }
  380. return true;
  381. }
  382. else // Adding new rows
  383. {
  384. // Insert null rows until specified row
  385. m_dCurrentRow = m_dTotalRows;
  386. m_stempSql.Empty();
  387. CString nullString;
  388. for (int i = 1; i <= m_dTotalColumns; i++)
  389. {
  390. if (i != m_dTotalColumns)
  391. {
  392. if (m_bExcel)
  393. {
  394. nullString.Format("" "%s", m_sSeparator);
  395. }
  396. else
  397. {
  398. nullString.Format("""%s", m_sSeparator);
  399. }
  400. m_stempSql += nullString;
  401. }
  402. else
  403. {
  404. if (m_bExcel)
  405. {
  406. m_stempSql += "" "";
  407. }
  408. else
  409. {
  410. m_stempSql += """";
  411. }
  412. }
  413. }
  414. for (int j = m_dTotalRows + 1; j < row; j++)
  415. {
  416. m_dCurrentRow++;
  417. m_aRows.Add(m_stempSql);
  418. }
  419. }
  420. }
  421. else
  422. {
  423. tempRow = m_dCurrentRow;
  424. m_dCurrentRow = m_dTotalRows;
  425. }
  427. // Insert new row
  428. m_dCurrentRow++;
  429. m_aRows.Add(m_stempString);
  431. if (row > m_dTotalRows)
  432. {
  433. m_dTotalRows = row;
  434. }
  435. else if (!row)
  436. {
  437. m_dTotalRows = m_dCurrentRow;
  438. m_dCurrentRow = tempRow;
  439. }
  440. if (!m_bTransaction)
  441. {
  442. Commit();
  443. }
  444. return true;
  445. }
  447. // Replace or add a cell into Excel spreadsheet using header row or column alphabet. 
  448. // Default is add cell into new row.
  449. // Set Auto to false if want to force column to be used as header name
  450. bool CSpreadSheet::AddCell(CString CellValue, CString column, long row, bool Auto)
  451. {
  452. short columnIndex = CalculateColumnNumber(column, Auto);
  453. if (columnIndex == 0)
  454. {
  455. return false;
  456. }
  458. if (AddCell(CellValue, columnIndex, row))
  459. {
  460. return true;
  461. }
  462. return false;
  463. }
  465. // Replace or add a cell into spreadsheet using column number
  466. // Default is add cell into new row.
  467. bool CSpreadSheet::AddCell(CString CellValue, short column, long row)
  468. {
  469. if (column == 0)
  470. {
  471. m_sLastError = "Column cannot be zeron";
  472. return false;
  473. }
  475. long tempRow;
  477. if (m_bExcel) // For Excel spreadsheet
  478. {
  479. if (column > m_aFieldNames.GetSize() + 1)
  480. {
  481. m_sLastError = "Cell column to be added cannot be greater than the number of fieldsn";
  482. return false;
  483. }
  484. }
  485. else // For text delimited spreadsheet
  486. {
  487. // Update largest number of columns if necessary
  488. if (column > m_dTotalColumns)
  489. {
  490. m_dTotalColumns = column;
  491. }
  492. }
  494. if (row)
  495. {
  496. if (row <= m_dTotalRows)
  497. {
  498. ReadRow(m_atempArray, row);
  500. // Change desired row
  501. m_atempArray.SetAtGrow(column-1, CellValue);
  503. if (row == 1)
  504. {
  505. if (m_bExcel) // Check for duplicate header row field
  506. {
  507. for (int i = 0; i < m_atempArray.GetSize(); i++)
  508. {
  509. for (int j = 0; j < m_atempArray.GetSize(); j++)
  510. {
  511. if ((i != j) && (m_atempArray.GetAt(i) == m_atempArray.GetAt(j)))
  512. {
  513. m_sLastError.Format("Duplicate header row field:%sn", m_atempArray.GetAt(i));
  514. return false;
  515. }
  516. }
  517. }
  518. }
  520. // Update header row
  521. m_aFieldNames.RemoveAll();
  522. m_aFieldNames.Copy(m_atempArray);
  523. }
  525. if (!AddRow(m_atempArray, row, true))
  526. {
  527. return false;
  528. }
  530. if (!m_bTransaction)
  531. {
  532. Commit();
  533. }
  534. return true;
  535. }
  536. else
  537. {
  538. // Insert null rows until specified row
  539. m_dCurrentRow = m_dTotalRows;
  540. m_stempSql.Empty();
  541. CString nullString;
  542. for (int i = 1; i <= m_dTotalColumns; i++)
  543. {
  544. if (i != m_dTotalColumns)
  545. {
  546. if (m_bExcel)
  547. {
  548. nullString.Format("" "%s", m_sSeparator);
  549. }
  550. else
  551. {
  552. nullString.Format("""%s", m_sSeparator);
  553. }
  554. m_stempSql += nullString;
  555. }
  556. else
  557. {
  558. if (m_bExcel)
  559. {
  560. m_stempSql += "" "";
  561. }
  562. else
  563. {
  564. m_stempSql += """";
  565. }
  566. }
  567. }
  568. for (int j = m_dTotalRows + 1; j < row; j++)
  569. {
  570. m_dCurrentRow++;
  571. m_aRows.Add(m_stempSql);
  572. }
  573. }
  574. }
  575. else
  576. {
  577. tempRow = m_dCurrentRow;
  578. m_dCurrentRow = m_dTotalRows;
  579. }
  581. // Insert cell
  582. m_dCurrentRow++;
  583. m_stempString.Empty();
  584. for (int j = 1; j <= m_dTotalColumns; j++)
  585. {
  586. if (j != m_dTotalColumns) // Not last column
  587. {
  588. if (j != column)
  589. {
  590. if (m_bExcel)
  591. {
  592. m_stempSql.Format("" "%s", m_sSeparator);
  593. }
  594. else
  595. {
  596. m_stempSql.Format("""%s", m_sSeparator);
  597. }
  598. m_stempString += m_stempSql;
  599. }
  600. else
  601. {
  602. m_stempSql.Format(""%s"%s", CellValue, m_sSeparator);
  603. m_stempString += m_stempSql;
  604. }
  605. }
  606. else // Last column
  607. {
  608. if (j != column)
  609. {
  610. if (m_bExcel)
  611. {
  612. m_stempString += "" "";
  613. }
  614. else
  615. {
  616. m_stempString += """";
  617. }
  618. }
  619. else
  620. {
  621. m_stempSql.Format(""%s"", CellValue);
  622. m_stempString += m_stempSql;
  623. }
  624. }
  625. }
  627. m_aRows.Add(m_stempString);
  629. if (row > m_dTotalRows)
  630. {
  631. m_dTotalRows = row;
  632. }
  633. else if (!row)
  634. {
  635. m_dTotalRows = m_dCurrentRow;
  636. m_dCurrentRow = tempRow;
  637. }
  638. if (!m_bTransaction)
  639. {
  640. Commit();
  641. }
  642. return true;
  643. }
  645. // Search and replace rows in Excel spreadsheet
  646. bool CSpreadSheet::ReplaceRows(CStringArray &NewRowValues, CStringArray &OldRowValues)
  647. {
  648. if (m_bExcel) // If file is an Excel spreadsheet
  649. {
  650. m_Database->OpenEx(m_sDsn, CDatabase::noOdbcDialog);
  651. m_stempSql.Format("UPDATE [%s] SET ", m_sSheetName);
  652. for (int i = 0; i < NewRowValues.GetSize(); i++)
  653. {
  654. m_stempString.Format("[%s]='%s', ", m_aFieldNames.GetAt(i), NewRowValues.GetAt(i));
  655. m_stempSql = m_stempSql + m_stempString;
  656. }
  657. m_stempSql.Delete(m_stempSql.GetLength()-2, 2);
  658. m_stempSql = m_stempSql + " WHERE (";
  659. for (int j = 0; j < OldRowValues.GetSize()-1; j++)
  660. {
  661. m_stempString.Format("[%s]='%s' AND ", m_aFieldNames.GetAt(j), OldRowValues.GetAt(j));
  662. m_stempSql = m_stempSql + m_stempString;
  663. }
  664. m_stempSql.Delete(m_stempSql.GetLength()-4, 5);
  665. m_stempSql += ")";
  667. try
  668. {
  669. m_Database->ExecuteSQL(m_stempSql);
  670. m_Database->Close();
  671. Open();
  672. return true;
  673. }
  674. catch(CDBException *e)
  675. {
  676. m_sLastError = e->m_strError;
  677. m_Database->Close();
  678. return false;
  679. }
  680. }
  681. else // if file is a text delimited file
  682. {
  683. m_sLastError = "Function not available for text delimited filen";
  684. return false;
  685. }
  686. }
  688. // Read a row from spreadsheet. 
  689. // Default is read the next row
  690. bool CSpreadSheet::ReadRow(CStringArray &RowValues, long row)
  691. {
  692. // Check if row entered is more than number of rows in sheet
  693. if (row <= m_aRows.GetSize())
  694. {
  695. if (row != 0)
  696. {
  697. m_dCurrentRow = row;
  698. }
  699. else if (m_dCurrentRow > m_aRows.GetSize())
  700. {
  701. return false;
  702. }
  703. // Read the desired row
  704. RowValues.RemoveAll();
  705. m_stempString = m_aRows.GetAt(m_dCurrentRow-1);
  706. m_dCurrentRow++;
  708. // Search for separator to split row
  709. int separatorPosition;
  710. m_stempSql.Format(""%s"", m_sSeparator);
  711. separatorPosition = m_stempString.Find(m_stempSql); // If separator is "?"
  712. if (separatorPosition != -1)
  713. {
  714. // Save columns
  715. int nCount = 0;
  716. int stringStartingPosition = 0;
  717. while (separatorPosition != -1)
  718. {
  719. nCount = separatorPosition - stringStartingPosition;
  720. RowValues.Add(m_stempString.Mid(stringStartingPosition, nCount));
  721. stringStartingPosition = separatorPosition + m_stempSql.GetLength();
  722. separatorPosition = m_stempString.Find(m_stempSql, stringStartingPosition);
  723. }
  724. nCount = m_stempString.GetLength() - stringStartingPosition;
  725. RowValues.Add(m_stempString.Mid(stringStartingPosition, nCount));
  727. // Remove quotes from first column
  728. m_stempString = RowValues.GetAt(0);
  729. m_stempString.Delete(0, 1);
  730. RowValues.SetAt(0, m_stempString);
  732. // Remove quotes from last column
  733. m_stempString = RowValues.GetAt(RowValues.GetSize()-1);
  734. m_stempString.Delete(m_stempString.GetLength()-1, 1);
  735. RowValues.SetAt(RowValues.GetSize()-1, m_stempString);
  737. return true;
  738. }
  739. else
  740. {
  741. // Save columns
  742. separatorPosition = m_stempString.Find(m_sSeparator); // if separator is ?
  743. if (separatorPosition != -1)
  744. {
  745. int nCount = 0;
  746. int stringStartingPosition = 0;
  747. while (separatorPosition != -1)
  748. {
  749. nCount = separatorPosition - stringStartingPosition;
  750. RowValues.Add(m_stempString.Mid(stringStartingPosition, nCount));
  751. stringStartingPosition = separatorPosition + m_sSeparator.GetLength();
  752. separatorPosition = m_stempString.Find(m_sSeparator, stringStartingPosition);
  753. }
  754. nCount = m_stempString.GetLength() - stringStartingPosition;
  755. RowValues.Add(m_stempString.Mid(stringStartingPosition, nCount));
  756. return true;
  757. }
  758. else // Treat spreadsheet as having one column
  759. {
  760. // Remove opening and ending quotes if any
  761. int quoteBegPos = m_stempString.Find('"');
  762. int quoteEndPos = m_stempString.ReverseFind('"');
  763. if ((quoteBegPos == 0) && (quoteEndPos == m_stempString.GetLength()-1))
  764. {
  765. m_stempString.Delete(0, 1);
  766. m_stempString.Delete(m_stempString.GetLength()-1, 1);
  767. }
  769. RowValues.Add(m_stempString);
  770. }
  771. }
  772. }
  773. m_sLastError = "Desired row is greater than total number of rows in spreadsheetn";
  774. return false;
  775. }
  777. // Read a column from Excel spreadsheet using header row or column alphabet. 
  778. // Set Auto to false if want to force column to be used as header name
  779. bool CSpreadSheet::ReadColumn(CStringArray &ColumnValues, CString column, bool Auto)
  780. {
  781. short columnIndex = CalculateColumnNumber(column, Auto);
  782. if (columnIndex == 0)
  783. {
  784. return false;
  785. }
  787. if (ReadColumn(ColumnValues, columnIndex))
  788. {
  789. return true;
  790. }
  791. return false;
  792. }
  794. // Read a column from spreadsheet using column number
  795. bool CSpreadSheet::ReadColumn(CStringArray &ColumnValues, short column)
  796. {
  797. if (column == 0)
  798. {
  799. m_sLastError = "Column cannot be zeron";
  800. return false;
  801. }
  803. int tempRow = m_dCurrentRow;
  804. m_dCurrentRow = 1;
  805. ColumnValues.RemoveAll();
  806. for (int i = 1; i <= m_aRows.GetSize(); i++)
  807. {
  808. // Read each row
  809. if (ReadRow(m_atempArray, i))
  810. {
  811. // Get value of cell in desired column
  812. if (column <= m_atempArray.GetSize())
  813. {
  814. ColumnValues.Add(m_atempArray.GetAt(column-1));
  815. }
  816. else
  817. {
  818. ColumnValues.Add("");
  819. }
  820. }
  821. else
  822. {
  823. m_dCurrentRow = tempRow;
  824. m_sLastError = "Error reading rown";
  825. return false;
  826. }
  827. }
  828. m_dCurrentRow = tempRow;
  829. return true;
  830. }
  832. // Read a cell from Excel spreadsheet using header row or column alphabet. 
  833. // Default is read the next cell in next row. 
  834. // Set Auto to false if want to force column to be used as header name
  835. bool CSpreadSheet::ReadCell (CString &CellValue, CString column, long row, bool Auto)
  836. {
  837. short columnIndex = CalculateColumnNumber(column, Auto);
  838. if (columnIndex == 0)
  839. {
  840. return false;
  841. }
  843. if (ReadCell(CellValue, columnIndex, row))
  844. {
  845. return true;
  846. }
  847. return false;
  848. }
  850. // Read a cell from spreadsheet using column number. 
  851. // Default is read the next cell in next row.
  852. bool CSpreadSheet::ReadCell (CString &CellValue, short column, long row)
  853. {
  854. if (column == 0)
  855. {
  856. m_sLastError = "Column cannot be zeron";
  857. return false;
  858. }
  860. int tempRow = m_dCurrentRow;
  861. if (row)
  862. {
  863. m_dCurrentRow = row;
  864. }
  865. if (ReadRow(m_atempArray, m_dCurrentRow))
  866. {
  867. // Get value of cell in desired column
  868. if (column <= m_atempArray.GetSize())
  869. {
  870. CellValue = m_atempArray.GetAt(column-1);
  871. }
  872. else
  873. {
  874. CellValue.Empty();
  875. m_dCurrentRow = tempRow;
  876. return false;
  877. }
  878. m_dCurrentRow = tempRow;
  879. return true;
  880. }
  881. m_dCurrentRow = tempRow;
  882. m_sLastError = "Error reading rown";
  883. return false;
  884. }
  886. // Begin transaction
  887. void CSpreadSheet::BeginTransaction()
  888. {
  889. m_bTransaction = true;
  890. }
  892. // Save changes to spreadsheet
  893. bool CSpreadSheet::Commit()
  894. {
  895. if (m_bExcel) // If file is an Excel spreadsheet
  896. {
  897. m_Database->OpenEx(m_sDsn, CDatabase::noOdbcDialog);
  899. if (m_bAppend)
  900. {
  901. // Delete old sheet if it exists
  902. m_stempString= "[" + m_sSheetName + "$A1:IV65536]";
  903. m_stempSql.Format ("DROP TABLE %s", m_stempString);
  904. try
  905. {
  906. m_Database->ExecuteSQL(m_stempSql);
  907. }
  908. catch(CDBException *e)
  909. {
  910. m_sLastError = e->m_strError;
  911. m_Database->Close();
  912. return false;
  913. }
  915. // Create new sheet
  916. m_stempSql.Format("CREATE TABLE [%s$A1:IV65536] (", m_sSheetName);
  917. for (int j = 0; j < m_aFieldNames.GetSize(); j++)
  918. {
  919. m_stempSql = m_stempSql + "[" + m_aFieldNames.GetAt(j) +"]" + " char(255), ";
  920. }
  921. m_stempSql.Delete(m_stempSql.GetLength()-2, 2);
  922. m_stempSql += ")";
  923. }
  924. else
  925. {
  926. // Create new sheet
  927. m_stempSql.Format("CREATE TABLE [%s] (", m_sSheetName);
  928. for (int i = 0; i < m_aFieldNames.GetSize(); i++)
  929. {
  930. m_stempSql = m_stempSql + "[" + m_aFieldNames.GetAt(i) +"]" + " char(255), ";
  931. }
  932. m_stempSql.Delete(m_stempSql.GetLength()-2, 2);
  933. m_stempSql += ")";
  934. }
  936. try
  937. {
  938. m_Database->ExecuteSQL(m_stempSql);
  939. if (!m_bAppend)
  940. {
  941. m_dTotalColumns = m_aFieldNames.GetSize();
  942. m_bAppend = true;
  943. }
  944. }
  945. catch(CDBException *e)
  946. {
  947. m_sLastError = e->m_strError;
  948. m_Database->Close();
  949. return false;
  950. }
  952. // Save changed data
  953. for (int k = 1; k < m_dTotalRows; k++)
  954. {
  955. ReadRow(m_atempArray, k+1);
  957. // Create Insert SQL
  958. m_stempSql.Format("INSERT INTO [%s$A1:IV%d] (", m_sSheetName, k);
  959. for (int i = 0; i < m_atempArray.GetSize(); i++)
  960. {
  961. m_stempString.Format("[%s], ", m_aFieldNames.GetAt(i));
  962. m_stempSql = m_stempSql + m_stempString;
  963. }
  964. m_stempSql.Delete(m_stempSql.GetLength()-2, 2);
  965. m_stempSql += ") VALUES (";
  966. for (int j = 0; j < m_atempArray.GetSize(); j++)
  967. {
  968. m_stempString.Format("'%s', ", m_atempArray.GetAt(j));
  969. m_stempSql = m_stempSql + m_stempString;
  970. }
  971. m_stempSql.Delete(m_stempSql.GetLength()-2, 2);
  972. m_stempSql += ")";
  974. // Add row
  975. try
  976. {
  977. m_Database->ExecuteSQL(m_stempSql);
  978. }
  979. catch(CDBException *e)
  980. {
  981. m_sLastError = e->m_strError;
  982. m_Database->Close();
  983. return false;
  984. }
  985. }
  986. m_Database->Close();
  987. m_bTransaction = false;
  988. return true;
  989. }
  990. else // if file is a text delimited file
  991. {
  992. try
  993. {
  994. CFile *File = NULL;
  995. File = new CFile(m_sFile, CFile::modeCreate | CFile::modeWrite  | CFile::shareDenyNone);
  996. if (File != NULL)
  997. {
  998. CArchive *Archive = NULL;
  999. Archive = new CArchive(File, CArchive::store);
  1000. if (Archive != NULL)
  1001. {
  1002. for (int i = 0; i < m_aRows.GetSize(); i++)
  1003. {
  1004. Archive->WriteString(m_aRows.GetAt(i));
  1005. Archive->WriteString("rn");
  1006. }
  1007. delete Archive;
  1008. delete File;
  1009. m_bTransaction = false;
  1010. return true;
  1011. }
  1012. delete File;
  1013. }
  1014. }
  1015. catch(...)
  1016. {
  1017. }
  1018. m_sLastError = "Error writing filen";
  1019. return false;
  1020. }
  1021. }
  1023. // Undo changes to spreadsheet
  1024. bool CSpreadSheet::RollBack()
  1025. {
  1026. if (Open())
  1027. {
  1028. m_bTransaction = false;
  1029. return true;
  1030. }
  1031. m_sLastError = "Error in returning to previous staten";
  1032. return false;
  1033. }
  1035. bool CSpreadSheet::Convert(CString SheetOrSeparator)
  1036. {
  1037. // Prepare file
  1038. m_stempString = m_sFile;
  1039. m_stempString.Delete(m_stempString.GetLength()-4, 4);
  1040. if (m_bExcel) // If file is an Excel spreadsheet
  1041. {
  1042. m_stempString += ".csv";
  1043. CSpreadSheet tempSheet(m_stempString, SheetOrSeparator, false);
  1045. // Stop convert if text delimited file exists
  1046. if (tempSheet.GetTotalColumns() != 0)
  1047. {
  1048. return false;
  1049. }
  1051. tempSheet.BeginTransaction();
  1053. for (int i = 1; i <= m_dTotalRows; i++)
  1054. {
  1055. if (!ReadRow(m_atempArray, i))
  1056. {
  1057. return false;
  1058. }
  1059. if (!tempSheet.AddRow(m_atempArray, i))
  1060. {
  1061. return false;
  1062. }
  1063. }
  1064. if (!tempSheet.Commit())
  1065. {
  1066. return false;
  1067. }
  1068. return true;
  1069. }
  1070. else // if file is a text delimited file
  1071. {
  1072. m_stempString += ".xls";
  1073. CSpreadSheet tempSheet(m_stempString, SheetOrSeparator, false);
  1075. // Stop convert if Excel file exists
  1076. if (tempSheet.GetTotalColumns() != 0)
  1077. {
  1078. return false;
  1079. }
  1081. GetFieldNames(m_atempArray);
  1083. // Check for duplicate header row field
  1084. bool duplicate = false;
  1085. for (int i = 0; i < m_atempArray.GetSize(); i++)
  1086. {
  1087. for (int j = 0; j < m_atempArray.GetSize(); j++)
  1088. {
  1089. if ((i != j) && (m_atempArray.GetAt(i) == m_atempArray.GetAt(j)))
  1090. {
  1091. m_sLastError.Format("Duplicate header row field:%sn", m_atempArray.GetAt(i));
  1092. duplicate = true;
  1093. }
  1094. }
  1095. }
  1097. if (duplicate) // Create dummy header row
  1098. {
  1099. m_atempArray.RemoveAll();
  1100. for (int k = 1; k <= m_dTotalColumns; k++)
  1101. {
  1102. m_stempString.Format("%d", k);
  1103. m_atempArray.Add(m_stempString);
  1104. }
  1106. if (!tempSheet.AddHeaders(m_atempArray))
  1107. {
  1108. return false;
  1109. }
  1111. for (int l = 1; l <= m_dTotalRows; l++)
  1112. {
  1113. if (!ReadRow(m_atempArray, l))
  1114. {
  1115. return false;
  1116. }
  1117. if (!tempSheet.AddRow(m_atempArray, l+1))
  1118. {
  1119. return false;
  1120. }
  1121. }
  1122. return true;
  1123. }
  1124. else
  1125. {
  1126. if (!tempSheet.AddHeaders(m_atempArray))
  1127. {
  1128. return false;
  1129. }
  1131. for (int l = 2; l <= m_dTotalRows; l++)
  1132. {
  1133. if (!ReadRow(m_atempArray, l))
  1134. {
  1135. return false;
  1136. }
  1137. if (!tempSheet.AddRow(m_atempArray, l))
  1138. {
  1139. return false;
  1140. }
  1141. }
  1142. return true;
  1143. }
  1144. }
  1145. }
  1147. // Open a text delimited file for reading or writing
  1148. bool CSpreadSheet::Open()
  1149. {
  1150. if (m_bExcel) // If file is an Excel spreadsheet
  1151. {
  1152. m_Database->OpenEx(m_sDsn, CDatabase::noOdbcDialog);
  1154. // Open Sheet
  1155. m_rSheet = new CRecordset( m_Database );
  1156. m_sSql.Format("SELECT * FROM [%s$A1:IV65536]", m_sSheetName);
  1157. try
  1158. {
  1159. m_rSheet->Open(CRecordset::forwardOnly, m_sSql, CRecordset::readOnly);
  1160. }
  1161. catch(...)
  1162. {
  1163. delete m_rSheet;
  1164. m_rSheet = NULL;
  1165. m_Database->Close();
  1166. return false;
  1167. }
  1169. // Get number of columns
  1170. m_dTotalColumns = m_rSheet->m_nResultCols;
  1172. if (m_dTotalColumns != 0)
  1173. {
  1174. m_aRows.RemoveAll();
  1175. m_stempString.Empty();
  1176. m_bAppend = true;
  1177. m_dTotalRows++; // Keep count of total number of rows
  1179. // Get field names i.e header row
  1180. for (int i = 0; i < m_dTotalColumns; i++)
  1181. {
  1182. m_stempSql = m_rSheet->m_rgODBCFieldInfos[i].m_strName;
  1183. m_aFieldNames.Add(m_stempSql);
  1185. // Join up all the columns into a string
  1186. if (i != m_dTotalColumns-1) // Not last column
  1187. {
  1188. m_stempString = m_stempString + """ + m_stempSql + """ + m_sSeparator;
  1189. }
  1190. else // Last column
  1191. {
  1192. m_stempString = m_stempString + """ + m_stempSql + """;
  1193. }
  1194. }
  1196. // Store the header row as the first row in memory
  1197. m_aRows.Add(m_stempString);
  1199. // Read and store the rest of the rows in memory
  1200. while (!m_rSheet->IsEOF())
  1201. {
  1202. m_dTotalRows++; // Keep count of total number of rows
  1203. try
  1204. {
  1205. // Get all the columns in a row
  1206. m_stempString.Empty();
  1207. for (short column = 0; column < m_dTotalColumns; column++)
  1208. {
  1209. m_rSheet->GetFieldValue(column, m_stempSql);
  1211. // Join up all the columns into a string
  1212. if (column != m_dTotalColumns-1) // Not last column
  1213. {
  1214. m_stempString = m_stempString + """ + m_stempSql + """ + m_sSeparator;
  1215. }
  1216. else // Last column
  1217. {
  1218. m_stempString = m_stempString + """ + m_stempSql + """;
  1219. }
  1220. }
  1222. // Store the obtained row in memory
  1223. m_aRows.Add(m_stempString);
  1224. m_rSheet->MoveNext();
  1225. }
  1226. catch (...)
  1227. {
  1228. m_sLastError = "Error reading rown";
  1229. delete m_rSheet;
  1230. m_rSheet = NULL;
  1231. m_Database->Close();
  1232. return false;
  1233. }
  1234. }
  1235. }
  1237. m_rSheet->Close();
  1238. delete m_rSheet;
  1239. m_rSheet = NULL;
  1240. m_Database->Close();
  1241. m_dCurrentRow = 1;
  1242. return true;
  1243. }
  1244. else // if file is a text delimited file
  1245. {
  1246. try
  1247. {
  1248. CFile *File = NULL;
  1249. File = new CFile(m_sFile, CFile::modeRead | CFile::shareDenyNone);
  1250. if (File != NULL)
  1251. {
  1252. CArchive *Archive = NULL;
  1253. Archive = new CArchive(File, CArchive::load);
  1254. if (Archive != NULL)
  1255. {
  1256. m_aRows.RemoveAll();
  1257. // Read and store all rows in memory
  1258. while(Archive->ReadString(m_stempString))
  1259. {
  1260. m_aRows.Add(m_stempString);
  1261. }
  1262. ReadRow(m_aFieldNames, 1); // Get field names i.e header row
  1263. delete Archive;
  1264. delete File;
  1266. // Get total number of rows
  1267. m_dTotalRows = m_aRows.GetSize();
  1269. // Get the largest number of columns
  1270. for (int i = 0; i < m_aRows.GetSize(); i++)
  1271. {
  1272. ReadRow(m_atempArray, i);
  1273. if (m_atempArray.GetSize() > m_dTotalColumns)
  1274. {
  1275. m_dTotalColumns = m_atempArray.GetSize();
  1276. }
  1277. }
  1279. if (m_dTotalColumns != 0)
  1280. {
  1281. m_bAppend = true;
  1282. }
  1283. return true;
  1284. }
  1285. delete File;
  1286. }
  1287. }
  1288. catch(...)
  1289. {
  1290. }
  1291. m_sLastError = "Error in opening filen";
  1292. return false;
  1293. }
  1294. }
  1296. // Convert Excel column in alphabet into column number
  1297. short CSpreadSheet::CalculateColumnNumber(CString column, bool Auto)
  1298. {
  1299. if (Auto)
  1300. {
  1301. int firstLetter, secondLetter;
  1302. column.MakeUpper();
  1304. if (column.GetLength() == 1)
  1305. {
  1306. firstLetter = column.GetAt(0);
  1307. return (firstLetter - 65 + 1); // 65 is A in ascii
  1308. }
  1309. else if (column.GetLength() == 2)
  1310. {
  1311. firstLetter = column.GetAt(0);
  1312. secondLetter = column.GetAt(1);
  1313. return ((firstLetter - 65 + 1)*26 + (secondLetter - 65 + 1)); // 65 is A in ascii
  1314. }
  1315. }
  1317. // Check if it is a valid field name
  1318. for (int i = 0; i < m_aFieldNames.GetSize(); i++)
  1319. {
  1320. if (!column.Compare(m_aFieldNames.GetAt(i)))
  1321. {
  1322. return (i + 1);
  1323. }
  1324. }
  1325. m_sLastError = "Invalid field name or column alphabetn";
  1326. return 0;
  1327. }
  1329. // Get the name of the Excel-ODBC driver
  1330. void CSpreadSheet::GetExcelDriver()
  1331. {
  1332. char szBuf[2001];
  1333. WORD cbBufMax = 2000;
  1334. WORD cbBufOut;
  1335. char *pszBuf = szBuf;
  1337. // Get the names of the installed drivers ("odbcinst.h" has to be included )
  1338. if(!SQLGetInstalledDrivers(szBuf,cbBufMax,& cbBufOut))
  1339. {
  1340. m_sExcelDriver = "";
  1341. }
  1343. // Search for the driver...
  1344. do
  1345. {
  1346. if( strstr( pszBuf, "Excel" ) != 0 )
  1347. {
  1348. // Found !
  1349. m_sExcelDriver = CString( pszBuf );
  1350. break;
  1351. }
  1352. pszBuf = strchr( pszBuf, '' ) + 1;
  1353. }
  1354. while( pszBuf[1] != '' );
  1355. }
  1357. #endif