创建

  1. if [ ! -d /opt/dbspace ]
  2. then
  3.     mkdir /opt/dbspace
  4. fi
  5.  
  6. if [ -f /opt/dbspace/.memo.db ]
  7. then
  8.     rm /opt/dbspace/.memo.db;
  9. fi
  10.  
  11. if [ -f /opt/dbspace/.memo.db-journal ]
  12. then
  13.     rm /opt/dbspace/.memo.db-journal
  14. fi
  15.  
  16. sqlite3 /opt/dbspace/.memo.db 'PRAGMA journal_mode = PERSIST;
  17.     create  table memo_list (
  18.     memo_id INTEGER PRIMARY KEY AUTOINCREMENT,
  19.     is_selected INTEGER default ,
  20.     time  INTEGER default ,
  21.     year  INTEGER default ,
  22.     month  INTEGER default ,
  23.     day  INTEGER default ,
  24.     hour  INTEGER default ,
  25.     minute  INTEGER default ,
  26.     wday  INTEGER default ,
  27.     thumb_path TEXT NOT NULL,
  28.     memo_text TEXT,
  29.     image_path TEXT,
  30.     image_x INTEGER,
  31.     image_y INTEGER,
  32.     image_w INTEGER,
  33.     image_h INTEGER,
  34.     handwrite_path TEXT,
  35.     record_path TEXT,
  36.     record_length INTEGER,
  37.     UNIQUE (memo_id)
  38.     );
  39. '
  40.  
  41. chown : /opt/dbspace/.memo.db
  42. chown : /opt/dbspace/.memo.db-journal
  43. chmod  /opt/dbspace/.memo.db
  44. chmod  /opt/dbspace/.memo.db-journal
  45. chsmack -a 'memo::db' /opt/dbspace/.memo.db*

cmake

  1. CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
  2. PROJECT(memo-database CXX)
  3.  
  4. INCLUDE(FindPkgConfig)
  5. pkg_check_modules(pkgs REQUIRED
  6.         sqlite3
  7.         dlog
  8. )
  9.  
  10. INCLUDE_DIRECTORIES(${pkgs_INCLUDE_DIRS})
  11. LINK_DIRECTORIES(${pkgs_LIBRARY_DIRS})
  12.  
  13. FOREACH(flag ${pkgs_CFLAGS})
  14.     SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
  15. ENDFOREACH(flag)
  16.  
  17. SET(CMAKE_CXX_FLAGS "${EXTRA_CFLAGS} -O2 -Wall -Wcast-align -Wcast-qual -Werror -Wextra -Wnon-virtual-dtor -Wno-unused-parameter -Wshadow -Wwrite-strings -fno-omit-frame-pointer -fno-optimize-sibling-calls -fno-strict-aliasing -fsigned-char -fstrict-overflow -Wno-ignored-qualifiers -Wno-array-bounds -Wno-empty-body -Wno-error")
  18.  
  19. SET(LIB_NAME "${PROJECT_NAME}")
  20. SET(LIB_PREFIX ${CMAKE_INSTALL_PREFIX})
  21. SET(LIB_DIR "${LIB_PREFIX}/lib")
  22. SET(LIB_INCLUDE_DIR "${LIB_PREFIX}/include")
  23. SET(LIB_PKGCONFIG_DIR "/usr/lib/pkgconfig")
  24.  
  25. SET(SRCS
  26.     src/MemoDb.cpp
  27. )
  28.  
  29. INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)
  30.  
  31. ADD_LIBRARY( ${LIB_NAME} SHARED ${SRCS} )
  32. TARGET_LINK_LIBRARIES(${LIB_NAME} ${pkgs_LDFLAGS})
  33.  
  34. CONFIGURE_FILE(${LIB_NAME}.pc.in ${LIB_NAME}.pc @ONLY)
  35. INSTALL(TARGETS ${LIB_NAME} DESTINATION ${LIB_DIR})
  36. INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${LIB_NAME}.pc DESTINATION ${LIB_PKGCONFIG_DIR})
  37. INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/MemoDb.h DESTINATION ${LIB_INCLUDE_DIR} )

spec

  1. Name: memo-database
  2. Summary: app control api
  3. Version: 0.1.
  4. Release:
  5. License: Flora License
  6. Source0: %{name}-%{version}.tar.gz
  7.  
  8. BuildRequires:    cmake
  9. BuildRequires:  pkgconfig(sqlite3)
  10. BuildRequires:  pkgconfig(dlog)
  11. Provides: libmemo-database.so
  12.  
  13. %description
  14. App Control API Library
  15.  
  16. %package devel
  17. Summary: app control api (devel)
  18. Requires: %{name} = %{version}
  19.  
  20. %description devel
  21. App Control API devel package
  22.  
  23. %prep
  24. %setup -q
  25.  
  26. %build
  27. cmake . -DVERSION=%{version} \
  28.     -DCMAKE_INSTALL_PREFIX=%{_prefix}
  29.  
  30. make %{?jobs:-j%jobs}
  31.  
  32. %install
  33. %make_install
  34.  
  35. %files
  36. %{_libdir}/*.so
  37. %manifest memo-database.manifest
  38.  
  39. %files devel
  40. %{_libdir}/pkgconfig/%{name}.pc
  41. %{_includedir}/*
  42.  
  43. %post
  44. /sbin/ldconfig
  45.  
  46. if [ ! -d /opt/dbspace ]
  47. then
  48.     mkdir /opt/dbspace
  49. fi
  50.  
  51. if [ -f /opt/dbspace/.memo.db ]
  52. then
  53.     rm /opt/dbspace/.memo.db;
  54. fi
  55.  
  56. if [ -f /opt/dbspace/.memo.db-journal ]
  57. then
  58.     rm /opt/dbspace/.memo.db-journal
  59. fi
  60.  
  61. sqlite3 /opt/dbspace/.memo.db 'PRAGMA journal_mode = PERSIST;
  62.     create  table memo_list (
  63.     memo_id INTEGER PRIMARY KEY AUTOINCREMENT,
  64.     is_selected INTEGER default 0,
  65.     time  INTEGER default 0,
  66.     year  INTEGER default 0,
  67.     month  INTEGER default 0,
  68.     day  INTEGER default 0,
  69.     hour  INTEGER default 0,
  70.     minute  INTEGER default 0,
  71.     wday  INTEGER default 0,
  72.     thumb_path TEXT NOT NULL,
  73.     memo_text TEXT,
  74.     image_path TEXT,
  75.     image_x INTEGER,
  76.     image_y INTEGER,
  77.     image_w INTEGER,
  78.     image_h INTEGER,
  79.     handwrite_path TEXT,
  80.     record_path TEXT,
  81.     record_length INTEGER,
  82.     UNIQUE (memo_id)
  83.     );
  84. '
  85.  
  86. chown :5000 /opt/dbspace/.memo.db
  87. chown :5000 /opt/dbspace/.memo.db-journal
  88. chmod 660 /opt/dbspace/.memo.db
  89. chmod 660 /opt/dbspace/.memo.db-journal
  90. chsmack -a 'memo::db' /opt/dbspace/.memo.db*

头文件

  1. #ifndef __MEMO_DB_H__
  2. #define __MEMO_DB_H__
  3.  
  4. #include <errno.h>
  5. #include <unistd.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <vector>
  9. #include <sqlite3.h>
  10.  
  11. using std::vector;
  12.  
  13. #define DBDIR "/opt/dbspace"
  14. #define DBFILE ".memo.db"
  15. #define DBPATH DBDIR"/"DBFILE
  16. #define MEMO_EMPTY_STR ""
  17. #define MEMO_CHECK_STR(p) ((p) ? (p) : MEMO_EMPTY_STR)
  18.  
  19. typedef enum _memo_db_error
  20. {
  21.     MEMO_ERROR_NONE = ,/**< Success */
  22.     MEMO_ERROR_INVALID_DATA = -,/**< Invalid parameter */
  23.     MEMO_ERROR_NO_MEMORY = -,/**< No memory */
  24.     MEMO_ERROR_FROM_DB = -,/**< Error from DB query */
  25.     MEMO_ERROR_ALREADY_EXIST_ID = -,/**< Already exist private ID */
  26.     MEMO_ERROR_FROM_DBUS = -,/**< Error from DBus */
  27.     MEMO_ERROR_NOT_EXIST_ID = -,/**< Not exist private ID */
  28.     MEMO_ERROR_IO = -,/**< disk i/o error */
  29.     MEMO_ERROR_SERVICE_NOT_READY = -,/**< no reponse from master */
  30. } memo_db_error_e;
  31.  
  32. typedef struct
  33. {
  34.     int nMemoId;
  35.     bool bIsSelected;
  36.     long int nTime;
  37.     int nYear;
  38.     int nMonth;
  39.     int nDay;
  40.     int nHour;
  41.     int nMinute;
  42.     int nWeekday;
  43.     const char *strThumbPath;
  44.     const char *strMemoText;
  45.     char *strImagePath;
  46.     int nImageX;
  47.     int nImageY;
  48.     int nImageW;
  49.     int nImageH;
  50.     const char *strHandwritePath;
  51.     const char *strRecordPath;
  52.     int nRecordLength;
  53. }MemoDbData;
  54.  
  55. class CMemoDb
  56. {
  57. public:
  58.     CMemoDb() {};
  59.     virtual ~CMemoDb() {};
  60.  
  61.     int OpenMemoDb();
  62.     int CloseMemoDb();
  63.  
  64.     int InsertMemoDb(MemoDbData *MemoData);
  65.     int UpdateMemoDb(MemoDbData *MemoData);
  66.     int DelMemoDb(int nMemoId);
  67.     int GetDataFromDb(vector<MemoDbData> *MemoVector);
  68.     int GetDataById(int nMemoId, MemoDbData *MemoData);
  69.     static CMemoDb* GetInstance();
  70.     int GetFirstData(MemoDbData *MemoData);
  71.     int GetTop3Memo(vector<MemoDbData> *MemoVector);
  72.  
  73. private:
  74.     int m_ExecMemoDb(const char *query);
  75.     char *m_GetColumnText(sqlite3_stmt *stmt, int col);
  76.     static CMemoDb* m_pMemoDbInstance;
  77.     sqlite3 *db;
  78. };
  79.  
  80. #endif/* __EPG_DB_H__ */

src文件

  1. #include "MemoDb.h"
  2. #include "dbg.h"
  3.  
  4. CMemoDb* CMemoDb::m_pMemoDbInstance = NULL;
  5.  
  6. CMemoDb* CMemoDb::GetInstance()
  7. {
  8.     if(m_pMemoDbInstance == NULL)
  9.     {
  10.         m_pMemoDbInstance = new CMemoDb();
  11.     }
  12.  
  13.     return m_pMemoDbInstance;
  14. }
  15.  
  16. int CMemoDb::OpenMemoDb()
  17. {
  18.     _DBG("OpenMemoDb------------------------------0");
  19.  
  20.     int ret = ;
  21.  
  22.     ret = sqlite3_open(DBPATH, &db);
  23.     if (ret != SQLITE_OK)
  24.     {
  25.         _ERR("DB open error(%d), %s", ret, DBPATH);
  26.         return -;
  27.     }
  28.     _DBG("OpenMemoDb------------------------------1");
  29.  
  30.     return ;
  31. }
  32.  
  33. int CMemoDb::CloseMemoDb()
  34. {
  35.     int ret = ;
  36.  
  37.     if (!db)
  38.     {
  39.         return MEMO_ERROR_INVALID_DATA;
  40.     }
  41.  
  42.     ret = sqlite3_close(db);
  43.     if (ret != SQLITE_OK)
  44.     {
  45.         _ERR("DB close error(%d)", ret);
  46.         return MEMO_ERROR_FROM_DB;
  47.     }
  48.  
  49.     db = NULL;
  50.  
  51.     _DBG("CloseMemoDb################################");
  52.     return MEMO_ERROR_NONE;
  53. }
  54.  
  55. int CMemoDb::m_ExecMemoDb( const char *query)
  56. {
  57.     _DBG("m_ExecMemoDb,  query is %s", query);
  58.     int ret = ;
  59.     char *err_msg = NULL;
  60.  
  61.     if (!db)
  62.     {
  63.         return MEMO_ERROR_INVALID_DATA;
  64.     }
  65.  
  66.     ret = sqlite3_exec(db, query, NULL, NULL, &err_msg);
  67.  
  68.     if (ret != SQLITE_OK)
  69.     {
  70.         _ERR("SQL error(%d) : %s", ret, err_msg);
  71.         sqlite3_free(err_msg);
  72.         return MEMO_ERROR_FROM_DB;
  73.     }
  74.     _DBG("m_ExecMemoDb finish");
  75.     return MEMO_ERROR_NONE;
  76. }
  77.  
  78. char *CMemoDb::m_GetColumnText(sqlite3_stmt *stmt, int col)
  79. {
  80.     const unsigned char *col_text = NULL;
  81.  
  82.     col_text = sqlite3_column_text(stmt, col);
  83.     if (!col_text || col_text[] == '\0')
  84.     {
  85.         return NULL;
  86.     }
  87.  
  88.     return strdup((char *)col_text);
  89. }
  90.  
  91. int CMemoDb::InsertMemoDb(MemoDbData *MemoData)
  92. {
  93.     _DBG("InsertMemoDb");
  94.     char *query = NULL;
  95.  
  96.     if (!db)
  97.     {
  98.         return MEMO_ERROR_FROM_DB;
  99.     }
  100.  
  101.     query = sqlite3_mprintf("insert into memo_list("
  102.             "memo_id, is_selected, "
  103.             "time, year, month, day, hour, minute, wday, "
  104.             "thumb_path, memo_text, image_path, "
  105.             "image_x, image_y, image_w, image_h, "
  106.             "handwrite_path, "
  107.             "record_path,record_length) values ("
  108.             "null, %d, "
  109.             "%ld, %d, %d, %d, %d, %d, %d, "
  110.             "'%s', '%s', '%s', "
  111.             "%d, %d, %d, %d, "
  112.             "'%s', "
  113.             "'%s', %d)",
  114.             MemoData->bIsSelected,
  115.             MemoData->nTime,
  116.             MemoData->nYear,
  117.             MemoData->nMonth,
  118.             MemoData->nDay,
  119.             MemoData->nHour,
  120.             MemoData->nMinute,
  121.             MemoData->nWeekday,
  122.             MemoData->strThumbPath,
  123.             MemoData->strMemoText,
  124.             MemoData->strImagePath,
  125.             MemoData->nImageX,
  126.             MemoData->nImageY,
  127.             MemoData->nImageW,
  128.             MemoData->nImageH,
  129.             MemoData->strHandwritePath,
  130.             MemoData->strRecordPath,
  131.             MemoData->nRecordLength);
  132.  
  133.     if (m_ExecMemoDb((const char *)query) != MEMO_ERROR_NONE)
  134.     {
  135.             return MEMO_ERROR_FROM_DB;
  136.     }
  137.  
  138.     return MEMO_ERROR_NONE;
  139. }
  140.  
  141. int CMemoDb::UpdateMemoDb(MemoDbData *MemoData)
  142. {
  143.     _DBG("here should implement");
  144.     char *query = NULL;
  145.  
  146.     if (!db)
  147.     {
  148.         return MEMO_ERROR_FROM_DB;
  149.     }
  150.  
  151.     query = sqlite3_mprintf("update memo_list set "
  152.             "is_selected = %d, "
  153.             "time = %ld, year = %d, month = %d, day = %d, hour = %d, minute = %d, wday = %d, "
  154.             "thumb_path = '%s', memo_text = '%s', image_path = '%s', "
  155.             "image_x = %d, image_y = %d, image_w = %d, image_h = %d, "
  156.             "handwrite_path = '%s', "
  157.             "record_path = '%s', record_length = %d "
  158.             "where memo_id = %d",
  159.             MemoData->bIsSelected,
  160.             MemoData->nTime,
  161.             MemoData->nYear,
  162.             MemoData->nMonth,
  163.             MemoData->nDay,
  164.             MemoData->nHour,
  165.             MemoData->nMinute,
  166.             MemoData->nWeekday,
  167.             MemoData->strThumbPath,
  168.             MemoData->strMemoText,
  169.             MemoData->strImagePath,
  170.             MemoData->nImageX,
  171.             MemoData->nImageY,
  172.             MemoData->nImageW,
  173.             MemoData->nImageH,
  174.             MemoData->strHandwritePath,
  175.             MemoData->strRecordPath,
  176.             MemoData->nRecordLength,
  177.             MemoData->nMemoId);
  178.  
  179.     if (m_ExecMemoDb((const char *)query) != MEMO_ERROR_NONE)
  180.     {
  181.         return MEMO_ERROR_FROM_DB;
  182.     }
  183.  
  184.     return MEMO_ERROR_NONE;
  185. }
  186. int CMemoDb::DelMemoDb(int nMemoId)
  187. {
  188.     char *query = NULL;
  189.  
  190.     if (!db)
  191.     {
  192.         return MEMO_ERROR_FROM_DB;
  193.     }
  194.  
  195.     query = sqlite3_mprintf("delete from memo_list where memo_id = %d",
  196.             nMemoId);
  197.  
  198.     if (m_ExecMemoDb( query) != MEMO_ERROR_NONE)
  199.     {
  200.         return MEMO_ERROR_FROM_DB;
  201.     }
  202.  
  203.     return MEMO_ERROR_NONE;
  204. }
  205.  
  206. int CMemoDb::GetDataById(int nMemoId, MemoDbData *MemoData)
  207. {
  208.     sqlite3_stmt *stmt;
  209.     char *query = NULL;
  210.     int ret;
  211.  
  212.     if (!db)
  213.     {
  214.         return MEMO_ERROR_FROM_DB;
  215.     }
  216.  
  217.     query = sqlite3_mprintf("select memo_id, is_selected, "
  218.             "time, year, month, day, hour, minute, wday, "
  219.             "thumb_path, "
  220.             "memo_text, "
  221.             "image_path, "
  222.             "image_x, "
  223.             "image_y, "
  224.             "image_w, "
  225.             "image_h, "
  226.             "handwrite_path, "
  227.             "record_path, "
  228.             "record_length "
  229.             "from memo_list where memo_id = %d", nMemoId);
  230.  
  231.     ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
  232.     if (ret != SQLITE_OK)
  233.     {
  234.         _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
  235.         return MEMO_ERROR_FROM_DB;
  236.     }
  237.  
  238.     if (sqlite3_step(stmt) == SQLITE_ROW)
  239.     {
  240.         MemoData->bIsSelected = sqlite3_column_int(stmt, );
  241.         MemoData->nTime = sqlite3_column_int(stmt, );
  242.         MemoData->nYear = sqlite3_column_int(stmt, );
  243.         MemoData->nMonth = sqlite3_column_int(stmt, );
  244.         MemoData->nDay = sqlite3_column_int(stmt, );
  245.         MemoData->nHour = sqlite3_column_int(stmt, );
  246.         MemoData->nMinute = sqlite3_column_int(stmt, );
  247.         MemoData->nWeekday = sqlite3_column_int(stmt, );
  248.         MemoData->strThumbPath = m_GetColumnText(stmt, );
  249.         MemoData->strMemoText= m_GetColumnText(stmt, );
  250.         MemoData->strImagePath = m_GetColumnText(stmt, );
  251.         MemoData->nImageX = sqlite3_column_int(stmt, );
  252.         MemoData->nImageY = sqlite3_column_int(stmt, );
  253.         MemoData->nImageW = sqlite3_column_int(stmt, );
  254.         MemoData->nImageH = sqlite3_column_int(stmt, );
  255.         MemoData->strHandwritePath = m_GetColumnText(stmt, );
  256.         MemoData->strRecordPath = m_GetColumnText(stmt, );
  257.         MemoData->nRecordLength= sqlite3_column_int(stmt, );
  258.     }
  259.  
  260.     sqlite3_finalize(stmt);
  261.  
  262.     return MEMO_ERROR_NONE;
  263. }
  264.  
  265. int CMemoDb::GetDataFromDb(vector<MemoDbData> *MemoVector)
  266. {
  267.     sqlite3_stmt *stmt;
  268.     char *query = NULL;
  269.     MemoDbData MemoData;
  270.     int ret;
  271.  
  272.     if (!db)
  273.     {
  274.         return MEMO_ERROR_FROM_DB;
  275.     }
  276.  
  277.     query = sqlite3_mprintf("select memo_id, is_selected, "
  278.             "time, year, month, day, hour, minute, wday, "
  279.             "thumb_path, "
  280.             "memo_text, "
  281.             "image_path, "
  282.             "image_x, "
  283.             "image_y, "
  284.             "image_w, "
  285.             "image_h, "
  286.             "handwrite_path, "
  287.             "record_path, "
  288.             "record_length "
  289.             "from memo_list order by time desc");
  290.  
  291.     ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
  292.     if (ret != SQLITE_OK)
  293.     {
  294.         _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
  295.         return MEMO_ERROR_FROM_DB;
  296.     }
  297.  
  298.     while(sqlite3_step(stmt) == SQLITE_ROW)
  299.     {
  300.         MemoData.nMemoId = sqlite3_column_int(stmt , );
  301.         MemoData.bIsSelected = sqlite3_column_int(stmt, );
  302.         MemoData.nTime = sqlite3_column_int(stmt, );
  303.         MemoData.nYear = sqlite3_column_int(stmt, );
  304.         MemoData.nMonth = sqlite3_column_int(stmt, );
  305.         MemoData.nDay = sqlite3_column_int(stmt, );
  306.         MemoData.nHour = sqlite3_column_int(stmt, );
  307.         MemoData.nMinute = sqlite3_column_int(stmt, );
  308.         MemoData.nWeekday = sqlite3_column_int(stmt, );
  309.         MemoData.strThumbPath = m_GetColumnText(stmt, );
  310.         MemoData.strMemoText= m_GetColumnText(stmt, );
  311.         MemoData.strImagePath = m_GetColumnText(stmt, );
  312.         MemoData.nImageX = sqlite3_column_int(stmt, );
  313.         MemoData.nImageY = sqlite3_column_int(stmt, );
  314.         MemoData.nImageW = sqlite3_column_int(stmt, );
  315.         MemoData.nImageH = sqlite3_column_int(stmt, );
  316.         MemoData.strHandwritePath = m_GetColumnText(stmt, );
  317.         MemoData.strRecordPath = m_GetColumnText(stmt, );
  318.         MemoData.nRecordLength= sqlite3_column_int(stmt, );
  319.  
  320.         MemoVector->push_back(MemoData);
  321.     }
  322.  
  323.     sqlite3_finalize(stmt);
  324.  
  325.     return MEMO_ERROR_NONE;
  326. }
  327.  
  328. int CMemoDb::GetFirstData(MemoDbData *MemoData)
  329. {
  330.     sqlite3_stmt *stmt;
  331.     char *query = NULL;
  332.     int ret;
  333.  
  334.     if (!db)
  335.     {
  336.         return MEMO_ERROR_FROM_DB;
  337.     }
  338.  
  339.     query = sqlite3_mprintf("select memo_id, is_selected, "
  340.             "time, year, month, day, hour, minute, wday, "
  341.             "thumb_path, "
  342.             "memo_text, "
  343.             "image_path, "
  344.             "image_x, "
  345.             "image_y, "
  346.             "image_w, "
  347.             "image_h, "
  348.             "handwrite_path, "
  349.             "record_path, "
  350.             "record_length "
  351.             "from memo_list  order by time desc");
  352.  
  353.     ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
  354.     if (ret != SQLITE_OK)
  355.     {
  356.         _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
  357.         return MEMO_ERROR_FROM_DB;
  358.     }
  359.  
  360.     if (sqlite3_step(stmt) == SQLITE_ROW)
  361.     {
  362.         MemoData->bIsSelected = sqlite3_column_int(stmt, );
  363.         MemoData->nTime = sqlite3_column_int(stmt, );
  364.         MemoData->nYear = sqlite3_column_int(stmt, );
  365.         MemoData->nMonth = sqlite3_column_int(stmt, );
  366.         MemoData->nDay = sqlite3_column_int(stmt, );
  367.         MemoData->nHour = sqlite3_column_int(stmt, );
  368.         MemoData->nMinute = sqlite3_column_int(stmt, );
  369.         MemoData->nWeekday = sqlite3_column_int(stmt, );
  370.         MemoData->strThumbPath = m_GetColumnText(stmt, );
  371.         MemoData->strMemoText= m_GetColumnText(stmt, );
  372.         MemoData->strImagePath = m_GetColumnText(stmt, );
  373.         MemoData->nImageX = sqlite3_column_int(stmt, );
  374.         MemoData->nImageY = sqlite3_column_int(stmt, );
  375.         MemoData->nImageW = sqlite3_column_int(stmt, );
  376.         MemoData->nImageH = sqlite3_column_int(stmt, );
  377.         MemoData->strHandwritePath = m_GetColumnText(stmt, );
  378.         MemoData->strRecordPath = m_GetColumnText(stmt, );
  379.         MemoData->nRecordLength= sqlite3_column_int(stmt, );
  380.     }
  381.  
  382.     sqlite3_finalize(stmt);
  383.  
  384.     return MEMO_ERROR_NONE;
  385. }
  386.  
  387. int CMemoDb::GetTop3Memo(vector<MemoDbData> *MemoVector)
  388. {
  389.     sqlite3_stmt *stmt;
  390.     char *query = NULL;
  391.     MemoDbData MemoData;
  392.     int ret;
  393.  
  394.     if (!db)
  395.     {
  396.         return MEMO_ERROR_FROM_DB;
  397.     }
  398.  
  399.     query = sqlite3_mprintf("select memo_id, is_selected, "
  400.             "time, year, month, day, hour, minute, wday, "
  401.             "thumb_path, "
  402.             "memo_text, "
  403.             "image_path, "
  404.             "image_x, "
  405.             "image_y, "
  406.             "image_w, "
  407.             "image_h, "
  408.             "handwrite_path, "
  409.             "record_path, "
  410.             "record_length "
  411.             "from memo_list where is_selected = 1 order by time desc");
  412.  
  413.     ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
  414.     if (ret != SQLITE_OK)
  415.     {
  416.         _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
  417.         return MEMO_ERROR_FROM_DB;
  418.     }
  419.  
  420.     while(sqlite3_step(stmt) == SQLITE_ROW)
  421.     {
  422.         MemoData.nMemoId = sqlite3_column_int(stmt , );
  423.         MemoData.bIsSelected = sqlite3_column_int(stmt, );
  424.         MemoData.nTime = sqlite3_column_int(stmt, );
  425.         MemoData.nYear = sqlite3_column_int(stmt, );
  426.         MemoData.nMonth = sqlite3_column_int(stmt, );
  427.         MemoData.nDay = sqlite3_column_int(stmt, );
  428.         MemoData.nHour = sqlite3_column_int(stmt, );
  429.         MemoData.nMinute = sqlite3_column_int(stmt, );
  430.         MemoData.nWeekday = sqlite3_column_int(stmt, );
  431.         MemoData.strThumbPath = m_GetColumnText(stmt, );
  432.         MemoData.strMemoText= m_GetColumnText(stmt, );
  433.         MemoData.strImagePath = m_GetColumnText(stmt, );
  434.         MemoData.nImageX = sqlite3_column_int(stmt, );
  435.         MemoData.nImageY = sqlite3_column_int(stmt, );
  436.         MemoData.nImageW = sqlite3_column_int(stmt, );
  437.         MemoData.nImageH = sqlite3_column_int(stmt, );
  438.         MemoData.strHandwritePath = m_GetColumnText(stmt, );
  439.         MemoData.strRecordPath = m_GetColumnText(stmt, );
  440.         MemoData.nRecordLength= sqlite3_column_int(stmt, );
  441.  
  442.         MemoVector->push_back(MemoData);
  443.     }
  444.  
  445.     sqlite3_finalize(stmt);
  446.  
  447.     return MEMO_ERROR_NONE;
  448. }

数据库 --> sqlite3之api使用的更多相关文章

  1. sqlite3 C API编程

    1,创建测试数据库,表;

  2. Linux下用到数据库sqlite3

    最近在Linux下用到数据库sqlite3,于是开始了该方面的学习. 0. 引言 我们这篇文章主要讲述了如何在C/C++语言中调用 sqlite 的函数接口来实现对数据库的管理, 包括创建数据库.创建 ...

  3. iOS开发中的4种数据持久化方式【二、数据库 SQLite3、Core Data 的运用】

                   在上文,我们介绍了ios开发中的其中2种数据持久化方式:属性列表.归档解档.本节将继续介绍另外2种iOS持久化数据的方法:数据库 SQLite3.Core Data 的运 ...

  4. 数据库(SQLITE3函数总结): sqlite3_open, sqlite3_exec, slite3_close,sqlite3_prepare_v2,sqlite3_column_text,

    Sqlite3 的确非常好用.小巧.速度快.近期研究它,有一些收获,这里把我对 sqlite3 的研究列出来,以备忘记. 导入SQLLite library并引入头文件. libsqlite3.dyl ...

  5. 应用程序员眼中的数据库管理系统：API+数据库语言

    应用程序员眼中的数据库管理系统:API+数据库语言 sqlite3_open_v2 https://www.cnblogs.com/cchust/p/5121559.html

  6. beego的orm ,用的数据库sqlite3

    测试 beego的orm ,用的数据库sqlite3 1 package main import ( "fmt" "github.com/astaxie/beego/or ...

  7. 数据库sqlite3在linux中的使用

    在linux下我们首先要获取root权限 当然也可是使用 sudo命令 接着让我们来安装sqlite3吧!博主当然是已经安装好了! 别急,的确你是安装好了sqlite3但是有一点必须要记住,你还没有安 ...

  8. 如何在Linux下用C/C++语言操作数据库sqlite3（很不错！设计编译链接等很多问题！）

    from : http://blog.chinaunix.NET/uid-21556133-id-118208.html 安装Sqlite3: 从www.sqlite.org上下载Sqlite3.2. ...

  9. HTML5权威指南--Web Storage,本地数据库,本地缓存API,Web Sockets API,Geolocation API(简要学习笔记二)

    1.Web Storage HTML5除了Canvas元素之外,还有一个非常重要的功能那就是客户端本地保存数据的Web Storage功能. 以前都是用cookies保存用户名等简单信息.   但是c ...

随机推荐

  1. ffmpeg结构体以及函数介绍（三）

    1 AVPacket typedef struct AVPacket { /** * Presentation timestamp in AVStream->time_base units; t ...

  2. 阿里巴巴开源前端框架--Weex实践

    Weex是最近很火很NB的一个技术产品,因为本篇介绍的是怎样使用Weex的最佳实践,所以就不罗里吧嗦的夸它怎么怎么好了,感兴趣的可以访问Weex HomePage,或加入旺旺群:1330170019. ...

  3. FusionCharts 2D帕累托图

    1.了解帕累托图的特性以及和其他图的共性 2.设计帕累托图页面中引入图的类型以及怎么引入到页面 Pareto2D.html: <!DOCTYPE HTML PUBLIC "-//W3C ...

  4. javascript 学习笔记 三大特性

    <script type="text/javascript"> //封装 function Person (name,age,sal){ this.name=name; ...

  5. Eclipse部署Java Web项目到Tomcat出错

    1.今天,我打开Eclipse,准备将一个Java Web项目部署到Tomcat中, 结果弹出提示错误窗口,具体如下: (1)出错详情 Could not publish server configu ...

  6. SQL面试题收录

    1.用一条SQL语句 查询出每门课都大于80分的学生姓名 SELECT DISTINCT NAME FROM t_score_tab WHERE NAME NOT IN (SELECT DISTINC ...

  7. “玲珑杯”ACM比赛 Round #4 B Best couple

    一眼的KM,但是建图的时候记得不用的点设为0,点少的一边补齐,这个非常重要,因为KM追求完全匹配,如果无法完全匹配会非常慢 #include<bits/stdc++.h> using na ...

  8. 【原】storm组件（架构层面）

    Strom集群遵循从主模式,主与从之间通过Zookeeper协作.架构层面上包括三个组件: 1) Nimbus Node 2)Supervisor Nodes 3)Zookeeper 其中Nimbus ...

  9. springboot入门的一点基础

    什么是SpringBoot java问世20年由于,发展到现在从技术角度来说已经很成熟,开发过程中我们总是在想如何去提高团队开发规范性.减少重复配置.避免低效开发.部署发布时流程的复杂度以及第三方技术 ...

  10. Python Cookbook(第3版)中文版：15.21 诊断分段错误

    15.21 诊断分段错误¶ 问题¶ 解释器因为某个分段错误.总线错误.访问越界或其他致命错误而突然间奔溃. 你想获得Python堆栈信息,从而找出在发生错误的时候你的程序运行点. 解决方案¶ faul ...