数据库 --> sqlite3之api使用

最新推荐文章于 2025-08-19 14:03:46 发布
最新推荐文章于 2025-08-19 14:03:46 发布
阅读量104 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 数据库
原文链接：http://www.cnblogs.com/jeakeven/p/4885402.html
本文详细介绍了如何创建和管理一个用于存储笔记、图片、录音等信息的memo数据库，包括数据库初始化、表创建、权限设置及核心操作方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

创建

if [ ! -d /opt/dbspace ]
then
    mkdir /opt/dbspace
fi

if [ -f /opt/dbspace/.memo.db ]
then
    rm /opt/dbspace/.memo.db;
fi

if [ -f /opt/dbspace/.memo.db-journal ]
then
    rm /opt/dbspace/.memo.db-journal
fi


sqlite3 /opt/dbspace/.memo.db 'PRAGMA journal_mode = PERSIST;
    create  table memo_list (
    memo_id INTEGER PRIMARY KEY AUTOINCREMENT,
    is_selected INTEGER default 0,
    time  INTEGER default 0,
    year  INTEGER default 0,
    month  INTEGER default 0,
    day  INTEGER default 0,
    hour  INTEGER default 0,
    minute  INTEGER default 0,
    wday  INTEGER default 0,
    thumb_path TEXT NOT NULL,
    memo_text TEXT,
    image_path TEXT,
    image_x INTEGER,
    image_y INTEGER,
    image_w INTEGER,
    image_h INTEGER,
    handwrite_path TEXT,
    record_path TEXT,
    record_length INTEGER,
    UNIQUE (memo_id)
    );
'

chown :5000 /opt/dbspace/.memo.db
chown :5000 /opt/dbspace/.memo.db-journal
chmod 660 /opt/dbspace/.memo.db
chmod 660 /opt/dbspace/.memo.db-journal
chsmack -a 'memo::db' /opt/dbspace/.memo.db*
View Code

 

cmake

CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
PROJECT(memo-database CXX)

INCLUDE(FindPkgConfig)
pkg_check_modules(pkgs REQUIRED
        sqlite3
        dlog
)

INCLUDE_DIRECTORIES(${pkgs_INCLUDE_DIRS})
LINK_DIRECTORIES(${pkgs_LIBRARY_DIRS})

FOREACH(flag ${pkgs_CFLAGS})
    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
ENDFOREACH(flag)

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")

SET(LIB_NAME "${PROJECT_NAME}")
SET(LIB_PREFIX ${CMAKE_INSTALL_PREFIX})
SET(LIB_DIR "${LIB_PREFIX}/lib")
SET(LIB_INCLUDE_DIR "${LIB_PREFIX}/include")
SET(LIB_PKGCONFIG_DIR "/usr/lib/pkgconfig")

SET(SRCS
    src/MemoDb.cpp
)

INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include)

ADD_LIBRARY( ${LIB_NAME} SHARED ${SRCS} )
TARGET_LINK_LIBRARIES(${LIB_NAME} ${pkgs_LDFLAGS})

CONFIGURE_FILE(${LIB_NAME}.pc.in ${LIB_NAME}.pc @ONLY)
INSTALL(TARGETS ${LIB_NAME} DESTINATION ${LIB_DIR})
INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${LIB_NAME}.pc DESTINATION ${LIB_PKGCONFIG_DIR})
INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/MemoDb.h DESTINATION ${LIB_INCLUDE_DIR} )
View Code

 

spec

Name: memo-database
Summary: app control api
Version: 0.1.1
Release: 1
License: Flora License
Source0: %{name}-%{version}.tar.gz

BuildRequires:    cmake
BuildRequires:  pkgconfig(sqlite3)
BuildRequires:  pkgconfig(dlog)
Provides: libmemo-database.so

%description
App Control API Library

%package devel
Summary: app control api (devel)
Requires: %{name} = %{version}

%description devel
App Control API devel package

%prep
%setup -q

%build
cmake . -DVERSION=%{version} \
    -DCMAKE_INSTALL_PREFIX=%{_prefix}

make %{?jobs:-j%jobs}

%install
%make_install


%files
%{_libdir}/*.so
%manifest memo-database.manifest

%files devel
%{_libdir}/pkgconfig/%{name}.pc
%{_includedir}/*

%post
/sbin/ldconfig

if [ ! -d /opt/dbspace ]
then
    mkdir /opt/dbspace
fi

if [ -f /opt/dbspace/.memo.db ]
then
    rm /opt/dbspace/.memo.db;
fi

if [ -f /opt/dbspace/.memo.db-journal ]
then
    rm /opt/dbspace/.memo.db-journal
fi


sqlite3 /opt/dbspace/.memo.db 'PRAGMA journal_mode = PERSIST;
    create  table memo_list (
    memo_id INTEGER PRIMARY KEY AUTOINCREMENT,
    is_selected INTEGER default 0,
    time  INTEGER default 0,
    year  INTEGER default 0,
    month  INTEGER default 0,
    day  INTEGER default 0,
    hour  INTEGER default 0,
    minute  INTEGER default 0,
    wday  INTEGER default 0,
    thumb_path TEXT NOT NULL,
    memo_text TEXT,
    image_path TEXT,
    image_x INTEGER,
    image_y INTEGER,
    image_w INTEGER,
    image_h INTEGER,
    handwrite_path TEXT,
    record_path TEXT,
    record_length INTEGER,
    UNIQUE (memo_id)
    );
'

chown :5000 /opt/dbspace/.memo.db
chown :5000 /opt/dbspace/.memo.db-journal
chmod 660 /opt/dbspace/.memo.db
chmod 660 /opt/dbspace/.memo.db-journal
chsmack -a 'memo::db' /opt/dbspace/.memo.db*
View Code

 

 

头文件

#ifndef __MEMO_DB_H__
#define __MEMO_DB_H__

#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <sqlite3.h>

using std::vector;

#define DBDIR "/opt/dbspace"
#define DBFILE ".memo.db"
#define DBPATH DBDIR"/"DBFILE
#define MEMO_EMPTY_STR ""
#define MEMO_CHECK_STR(p) ((p) ? (p) : MEMO_EMPTY_STR)

typedef enum _memo_db_error
{
    MEMO_ERROR_NONE = 0,/**< Success */
    MEMO_ERROR_INVALID_DATA = -1,/**< Invalid parameter */
    MEMO_ERROR_NO_MEMORY = -2,/**< No memory */
    MEMO_ERROR_FROM_DB = -3,/**< Error from DB query */
    MEMO_ERROR_ALREADY_EXIST_ID = -4,/**< Already exist private ID */
    MEMO_ERROR_FROM_DBUS = -5,/**< Error from DBus */
    MEMO_ERROR_NOT_EXIST_ID = -6,/**< Not exist private ID */
    MEMO_ERROR_IO = -7,/**< disk i/o error */
    MEMO_ERROR_SERVICE_NOT_READY = -8,/**< no reponse from master */
} memo_db_error_e;

typedef struct
{
    int nMemoId;
    bool bIsSelected;
    long int nTime;
    int nYear;
    int nMonth;
    int nDay;
    int nHour;
    int nMinute;
    int nWeekday;
    const char *strThumbPath;
    const char *strMemoText;
    char *strImagePath;
    int nImageX;
    int nImageY;
    int nImageW;
    int nImageH;
    const char *strHandwritePath;
    const char *strRecordPath;
    int nRecordLength;
}MemoDbData;


class CMemoDb
{
public:
    CMemoDb() {};
    virtual ~CMemoDb() {};

    int OpenMemoDb();
    int CloseMemoDb();

    int InsertMemoDb(MemoDbData *MemoData);
    int UpdateMemoDb(MemoDbData *MemoData);
    int DelMemoDb(int nMemoId);
    int GetDataFromDb(vector<MemoDbData> *MemoVector);
    int GetDataById(int nMemoId, MemoDbData *MemoData);
    static CMemoDb* GetInstance();
    int GetFirstData(MemoDbData *MemoData);
    int GetTop3Memo(vector<MemoDbData> *MemoVector);

private:
    int m_ExecMemoDb(const char *query);
    char *m_GetColumnText(sqlite3_stmt *stmt, int col);
    static CMemoDb* m_pMemoDbInstance;
    sqlite3 *db;
};

#endif/* __EPG_DB_H__ */
View Code

 

src文件

#include "MemoDb.h"
#include "dbg.h"

CMemoDb* CMemoDb::m_pMemoDbInstance = NULL;

CMemoDb* CMemoDb::GetInstance()
{
    if(m_pMemoDbInstance == NULL)
    {
        m_pMemoDbInstance = new CMemoDb();
    }

    return m_pMemoDbInstance;
}

int CMemoDb::OpenMemoDb()
{
    _DBG("OpenMemoDb------------------------------0");

    int ret = 0;

    ret = sqlite3_open(DBPATH, &db);
    if (ret != SQLITE_OK)
    {
        _ERR("DB open error(%d), %s", ret, DBPATH);
        return -1;
    }
    _DBG("OpenMemoDb------------------------------1");

    return 0;
}

int CMemoDb::CloseMemoDb()
{
    int ret = 0;

    if (!db)
    {
        return MEMO_ERROR_INVALID_DATA;
    }

    ret = sqlite3_close(db);
    if (ret != SQLITE_OK)
    {
        _ERR("DB close error(%d)", ret);
        return MEMO_ERROR_FROM_DB;
    }

    db = NULL;

    _DBG("CloseMemoDb################################");
    return MEMO_ERROR_NONE;
}

int CMemoDb::m_ExecMemoDb( const char *query)
{
    _DBG("m_ExecMemoDb,  query is %s", query);
    int ret = 0;
    char *err_msg = NULL;

    if (!db)
    {
        return MEMO_ERROR_INVALID_DATA;
    }

    ret = sqlite3_exec(db, query, NULL, NULL, &err_msg);

    if (ret != SQLITE_OK)
    {
        _ERR("SQL error(%d) : %s", ret, err_msg);
        sqlite3_free(err_msg);
        return MEMO_ERROR_FROM_DB;
    }
    _DBG("m_ExecMemoDb finish");
    return MEMO_ERROR_NONE;
}

char *CMemoDb::m_GetColumnText(sqlite3_stmt *stmt, int col)
{
    const unsigned char *col_text = NULL;

    col_text = sqlite3_column_text(stmt, col);
    if (!col_text || col_text[0] == '\0')
    {
        return NULL;
    }

    return strdup((char *)col_text);
}

int CMemoDb::InsertMemoDb(MemoDbData *MemoData)
{
    _DBG("InsertMemoDb");
    char *query = NULL;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("insert into memo_list("
            "memo_id, is_selected, "
            "time, year, month, day, hour, minute, wday, "
            "thumb_path, memo_text, image_path, "
            "image_x, image_y, image_w, image_h, "
            "handwrite_path, "
            "record_path,record_length) values ("
            "null, %d, "
            "%ld, %d, %d, %d, %d, %d, %d, "
            "'%s', '%s', '%s', "
            "%d, %d, %d, %d, "
            "'%s', "
            "'%s', %d)",
            MemoData->bIsSelected,
            MemoData->nTime,
            MemoData->nYear,
            MemoData->nMonth,
            MemoData->nDay,
            MemoData->nHour,
            MemoData->nMinute,
            MemoData->nWeekday,
            MemoData->strThumbPath,
            MemoData->strMemoText,
            MemoData->strImagePath,
            MemoData->nImageX,
            MemoData->nImageY,
            MemoData->nImageW,
            MemoData->nImageH,
            MemoData->strHandwritePath,
            MemoData->strRecordPath,
            MemoData->nRecordLength);

    if (m_ExecMemoDb((const char *)query) != MEMO_ERROR_NONE)
    {
            return MEMO_ERROR_FROM_DB;
    }

    return MEMO_ERROR_NONE;
}


int CMemoDb::UpdateMemoDb(MemoDbData *MemoData)
{
    _DBG("here should implement");
    char *query = NULL;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("update memo_list set "
            "is_selected = %d, "
            "time = %ld, year = %d, month = %d, day = %d, hour = %d, minute = %d, wday = %d, "
            "thumb_path = '%s', memo_text = '%s', image_path = '%s', "
            "image_x = %d, image_y = %d, image_w = %d, image_h = %d, "
            "handwrite_path = '%s', "
            "record_path = '%s', record_length = %d "
            "where memo_id = %d",
            MemoData->bIsSelected,
            MemoData->nTime,
            MemoData->nYear,
            MemoData->nMonth,
            MemoData->nDay,
            MemoData->nHour,
            MemoData->nMinute,
            MemoData->nWeekday,
            MemoData->strThumbPath,
            MemoData->strMemoText,
            MemoData->strImagePath,
            MemoData->nImageX,
            MemoData->nImageY,
            MemoData->nImageW,
            MemoData->nImageH,
            MemoData->strHandwritePath,
            MemoData->strRecordPath,
            MemoData->nRecordLength,
            MemoData->nMemoId);

    if (m_ExecMemoDb((const char *)query) != MEMO_ERROR_NONE)
    {
        return MEMO_ERROR_FROM_DB;
    }

    return MEMO_ERROR_NONE;
}
int CMemoDb::DelMemoDb(int nMemoId)
{
    char *query = NULL;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("delete from memo_list where memo_id = %d",
            nMemoId);

    if (m_ExecMemoDb( query) != MEMO_ERROR_NONE)
    {
        return MEMO_ERROR_FROM_DB;
    }

    return MEMO_ERROR_NONE;
}

int CMemoDb::GetDataById(int nMemoId, MemoDbData *MemoData)
{
    sqlite3_stmt *stmt;
    char *query = NULL;
    int ret;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("select memo_id, is_selected, "
            "time, year, month, day, hour, minute, wday, "
            "thumb_path, "
            "memo_text, "
            "image_path, "
            "image_x, "
            "image_y, "
            "image_w, "
            "image_h, "
            "handwrite_path, "
            "record_path, "
            "record_length "
            "from memo_list where memo_id = %d", nMemoId);

    ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
    if (ret != SQLITE_OK)
    {
        _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
        return MEMO_ERROR_FROM_DB;
    }

    if (sqlite3_step(stmt) == SQLITE_ROW)
    {
        MemoData->bIsSelected = sqlite3_column_int(stmt, 1);
        MemoData->nTime = sqlite3_column_int(stmt, 2);
        MemoData->nYear = sqlite3_column_int(stmt, 3);
        MemoData->nMonth = sqlite3_column_int(stmt, 4);
        MemoData->nDay = sqlite3_column_int(stmt, 5);
        MemoData->nHour = sqlite3_column_int(stmt, 6);
        MemoData->nMinute = sqlite3_column_int(stmt, 7);
        MemoData->nWeekday = sqlite3_column_int(stmt, 8);
        MemoData->strThumbPath = m_GetColumnText(stmt, 9);
        MemoData->strMemoText= m_GetColumnText(stmt, 10);
        MemoData->strImagePath = m_GetColumnText(stmt, 11);
        MemoData->nImageX = sqlite3_column_int(stmt, 12);
        MemoData->nImageY = sqlite3_column_int(stmt, 13);
        MemoData->nImageW = sqlite3_column_int(stmt, 14);
        MemoData->nImageH = sqlite3_column_int(stmt, 15);
        MemoData->strHandwritePath = m_GetColumnText(stmt, 16);
        MemoData->strRecordPath = m_GetColumnText(stmt, 17);
        MemoData->nRecordLength= sqlite3_column_int(stmt, 18);
    }

    sqlite3_finalize(stmt);

    return MEMO_ERROR_NONE;
}

int CMemoDb::GetDataFromDb(vector<MemoDbData> *MemoVector)
{
    sqlite3_stmt *stmt;
    char *query = NULL;
    MemoDbData MemoData;
    int ret;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("select memo_id, is_selected, "
            "time, year, month, day, hour, minute, wday, "
            "thumb_path, "
            "memo_text, "
            "image_path, "
            "image_x, "
            "image_y, "
            "image_w, "
            "image_h, "
            "handwrite_path, "
            "record_path, "
            "record_length "
            "from memo_list order by time desc");

    ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
    if (ret != SQLITE_OK)
    {
        _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
        return MEMO_ERROR_FROM_DB;
    }

    while(sqlite3_step(stmt) == SQLITE_ROW)
    {
        MemoData.nMemoId = sqlite3_column_int(stmt , 0);
        MemoData.bIsSelected = sqlite3_column_int(stmt, 1);
        MemoData.nTime = sqlite3_column_int(stmt, 2);
        MemoData.nYear = sqlite3_column_int(stmt, 3);
        MemoData.nMonth = sqlite3_column_int(stmt, 4);
        MemoData.nDay = sqlite3_column_int(stmt, 5);
        MemoData.nHour = sqlite3_column_int(stmt, 6);
        MemoData.nMinute = sqlite3_column_int(stmt, 7);
        MemoData.nWeekday = sqlite3_column_int(stmt, 8);
        MemoData.strThumbPath = m_GetColumnText(stmt, 9);
        MemoData.strMemoText= m_GetColumnText(stmt, 10);
        MemoData.strImagePath = m_GetColumnText(stmt, 11);
        MemoData.nImageX = sqlite3_column_int(stmt, 12);
        MemoData.nImageY = sqlite3_column_int(stmt, 13);
        MemoData.nImageW = sqlite3_column_int(stmt, 14);
        MemoData.nImageH = sqlite3_column_int(stmt, 15);
        MemoData.strHandwritePath = m_GetColumnText(stmt, 16);
        MemoData.strRecordPath = m_GetColumnText(stmt, 17);
        MemoData.nRecordLength= sqlite3_column_int(stmt, 18);

        MemoVector->push_back(MemoData);
    }

    sqlite3_finalize(stmt);

    return MEMO_ERROR_NONE;
}

int CMemoDb::GetFirstData(MemoDbData *MemoData)
{
    sqlite3_stmt *stmt;
    char *query = NULL;
    int ret;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("select memo_id, is_selected, "
            "time, year, month, day, hour, minute, wday, "
            "thumb_path, "
            "memo_text, "
            "image_path, "
            "image_x, "
            "image_y, "
            "image_w, "
            "image_h, "
            "handwrite_path, "
            "record_path, "
            "record_length "
            "from memo_list  order by time desc");

    ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
    if (ret != SQLITE_OK)
    {
        _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
        return MEMO_ERROR_FROM_DB;
    }

    if (sqlite3_step(stmt) == SQLITE_ROW)
    {
        MemoData->bIsSelected = sqlite3_column_int(stmt, 1);
        MemoData->nTime = sqlite3_column_int(stmt, 2);
        MemoData->nYear = sqlite3_column_int(stmt, 3);
        MemoData->nMonth = sqlite3_column_int(stmt, 4);
        MemoData->nDay = sqlite3_column_int(stmt, 5);
        MemoData->nHour = sqlite3_column_int(stmt, 6);
        MemoData->nMinute = sqlite3_column_int(stmt, 7);
        MemoData->nWeekday = sqlite3_column_int(stmt, 8);
        MemoData->strThumbPath = m_GetColumnText(stmt, 9);
        MemoData->strMemoText= m_GetColumnText(stmt, 10);
        MemoData->strImagePath = m_GetColumnText(stmt, 11);
        MemoData->nImageX = sqlite3_column_int(stmt, 12);
        MemoData->nImageY = sqlite3_column_int(stmt, 13);
        MemoData->nImageW = sqlite3_column_int(stmt, 14);
        MemoData->nImageH = sqlite3_column_int(stmt, 15);
        MemoData->strHandwritePath = m_GetColumnText(stmt, 16);
        MemoData->strRecordPath = m_GetColumnText(stmt, 17);
        MemoData->nRecordLength= sqlite3_column_int(stmt, 18);
    }

    sqlite3_finalize(stmt);


    return MEMO_ERROR_NONE;
}

int CMemoDb::GetTop3Memo(vector<MemoDbData> *MemoVector)
{
    sqlite3_stmt *stmt;
    char *query = NULL;
    MemoDbData MemoData;
    int ret;

    if (!db)
    {
        return MEMO_ERROR_FROM_DB;
    }

    query = sqlite3_mprintf("select memo_id, is_selected, "
            "time, year, month, day, hour, minute, wday, "
            "thumb_path, "
            "memo_text, "
            "image_path, "
            "image_x, "
            "image_y, "
            "image_w, "
            "image_h, "
            "handwrite_path, "
            "record_path, "
            "record_length "
            "from memo_list where is_selected = 1 order by time desc");

    ret = sqlite3_prepare(db, query, strlen(query), &stmt, NULL);
    if (ret != SQLITE_OK)
    {
        _ERR("Get count DB err(%d) : %s", ret, sqlite3_errmsg(db));
        return MEMO_ERROR_FROM_DB;
    }

    while(sqlite3_step(stmt) == SQLITE_ROW)
    {
        MemoData.nMemoId = sqlite3_column_int(stmt , 0);
        MemoData.bIsSelected = sqlite3_column_int(stmt, 1);
        MemoData.nTime = sqlite3_column_int(stmt, 2);
        MemoData.nYear = sqlite3_column_int(stmt, 3);
        MemoData.nMonth = sqlite3_column_int(stmt, 4);
        MemoData.nDay = sqlite3_column_int(stmt, 5);
        MemoData.nHour = sqlite3_column_int(stmt, 6);
        MemoData.nMinute = sqlite3_column_int(stmt, 7);
        MemoData.nWeekday = sqlite3_column_int(stmt, 8);
        MemoData.strThumbPath = m_GetColumnText(stmt, 9);
        MemoData.strMemoText= m_GetColumnText(stmt, 10);
        MemoData.strImagePath = m_GetColumnText(stmt, 11);
        MemoData.nImageX = sqlite3_column_int(stmt, 12);
        MemoData.nImageY = sqlite3_column_int(stmt, 13);
        MemoData.nImageW = sqlite3_column_int(stmt, 14);
        MemoData.nImageH = sqlite3_column_int(stmt, 15);
        MemoData.strHandwritePath = m_GetColumnText(stmt, 16);
        MemoData.strRecordPath = m_GetColumnText(stmt, 17);
        MemoData.nRecordLength= sqlite3_column_int(stmt, 18);

        MemoVector->push_back(MemoData);
    }

    sqlite3_finalize(stmt);

    return MEMO_ERROR_NONE;
}
View Code

 

转载于:https://www.cnblogs.com/jeakeven/p/4885402.html

sqlite3数据库简单使用demo
dancersky的博客
04-01 3182
demo：#include <stdio.h> #include <stdlib.h> #include <string.h> #include "evsql/sqlite3.h" struct test_t{ char * username; int password; };int print_record(void *params,int n_column,char **col
SQLite3_API使用大全
12-28
SQLite3_API使用大全
sqlite3 api学习笔记
SlimApp
08-07 753
sqlite3中有5种数据类型：int real text null blob 但sqlite3中的列的数据类型不是固定的，列的数据类型随着实际插入的数据的格式而定；   在sqlite3中使用sql时，有一个非常有趣而有强大的概念：相似类型。引入相似类型的概念，主要是为了兼容各种数据库（sqlserver oracle mysql等）的sql语法。     sqlite3中常用的
C/C++之SQLite常用函数
04-08 192
C/C++之SQLite常用函数 C/C++之SQLite常用函数 - 简单的日志 - 网易博客C/C++之SQLite常用函数2010-06-03 15:43:06|分类： C/C++之SQLite |标签： |字号大中小订阅1 、打...
【CMake】CMake链接SQLite库
半生瓜のblog
06-30 3110
原问题链接:——C/C++ undefined reference for sqlite3’s functions using CLion with CMAKE
Vscode + Cmake + vcpkg + sqlite3
jiegemena的博客
09-29 1409
使用vs community 2019 x86 编译 安装包 vcpkg install sqlite3:x86-windows CMakeLists.txt # CMake 最低版本号要求 cmake_minimum_required (VERSION 3.16) SET(DCMAKE_TOOLCHAIN_FILE "E:/usr/vcpkg-master_0107/vcpkg-master/scripts/buildsystems/vcpkg.cmake") # 没加这行折腾半天 include("E
数据库-sqlite客户端-sqlite-访问sqlite数据库
12-24
例如，C语言中可以使用sqlite3.h提供的API来操作SQLite数据库。客户端软件则是一个独立的应用程序，它封装了访问数据库的逻辑，并通过图形用户界面（GUI）或命令行界面（CLI）提供交互方式，方便用户管理数据库。 ...
在Node-RED中操作SQLite数据库
02-21
使用Node-RED操作SQLite数据库需要用户掌握Node-RED的操作原理、熟悉sqlite节点模块的使用方法以及对数据库操作有基本的理解。通过这种方式，即使是不具备深厚编程背景的用户也能够较为方便地在应用程序中集成SQLite...
go-sqlite3：使用数据库的sqlite3驱动程序
02-02
sqlite3驱动程序符合内置的数据库/ sql接口 支持的Golang版本：请参阅 总览 安装 可以使用go get命令安装此软件包： go get github.com/mattn/go-sqlite3 go-sqlite3是cgo软件包。 如果要使用go-sqlite3构建应用，...
electron-react-antd-antv-cli的sqlite3数据库集成版本.zip
01-04
5. **SQLite3**：SQLite3是一个嵌入式数据库，它无需单独的服务器进程，可以直接在应用中使用，适合于资源有限但需要持久化数据存储的场景。 6. **数据采集**：数据采集可能涉及到网络爬虫、API接口调用或实时数据...
SQLite3++ - C++ wrapper of SQLite3 API.zip
01-05
SQLite3++是一个C++库，它是对SQLite3数据库API的封装，目的是为了简化在C++项目中使用SQLite数据库的工作。SQLite3是一个轻量级、嵌入式的关系型数据库引擎，广泛应用于各种桌面应用、移动设备以及服务器环境中。...
CMakePackageConfigHelpers 用cmake建立自己的package
大漠孤尘的博客
12-28 4856
CMakePackageConfigHelpers 用cmake建立自己的package CONFIGURE_PACKAGE_CONFIG_FILE(&lt;input&gt; &lt;output&gt; INSTALL_DESTINATION &lt;path&gt; [PATH_VARS &lt;v...
linux下编译动态和静态链接库
weixin_34306593的博客
09-14 115
静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。查看当前工程目录的内容[root@root config-file]# tree.|-- Makefile|-- Makefile.a|-- Makefile.so|-- configfile.c|--...
使用SQLite中自带的API操作SQLite数据库
meishadevs的个人博客
04-12 3067
在上一篇博客中介绍了在android中使用SQLite数据库，上一篇博客中是直接使用SQL语句操作SQLite数据库，这样会带来一个非常大的问题，万一SQL语句书写错误，编译时程序并不会报错，在运行时发现错误时，又重新回来修改代码，这样会大大降低开发效率，为了解决这个问题Android中封装了一些可以直接操作SQLite的API，并不需要写SQL语句 接下来通过一个实例介绍使用Android中封
编译sqlite3为静态库遇到的问题
qq_36184671的博客
02-25 1018
1 编译.a本身 ar -cr sqlite3.a sqlite3.o ,不需要make install 这样会在/user/local/lib 产生静态库和动态库 2 遇到 问题，其实是libsqlite3.a还需要链接libdl.so，但是在cmake又没有找到，这里只需在cmakelist 里面的target_link_libraries（）的 libsqlite3.a 后面添加-...
在Linux下用C语言操作数据库sqlite3(插入）
#维多利亚的秘密#
01-09 3861
插入：insert 　刚刚我们知道了怎么调用 sqlite3 的C/C++的API函数接口，下面我们看看怎么在C语言中向数据库插入数据。 　　好的，我们现编辑一段c代码，取名为 insert.c // name： insert.c // This prog is used to test C/C++ API for sqlite3 .It is verysimple,ha ! // Au
Sqlite sqlite3_config 报错 21
Silver_sail的专栏
09-04 5245
要使用Sqlite进行开发，xue
sqlite3数据库c语言常用接口应用实例
fanchenxinok的专栏
06-01 7337
 #include #include #include /*************************** typedef int (*sqlite3_callback)( void*, // Data provided in the 4th argument of sqlite3_exec() int, // The number of columns i
缓存雪崩、缓存穿透、缓存击穿在实际中如何处理
最新发布
Rookie
08-19 2145
也有一个更为简单粗暴的方法（我们采用的就是这种），如果一个查询返回的数据为空（不管是数 据不存在，还是。缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中时被动写的，并且出于容错考虑，如果从存储层查不。到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到。系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。所以我们把过期时间存在。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值