C++ 什么是裸骨C++；将jpeg放入MySQL表所需的代码？

我创建了一个MySQL表，其中一列存储BLOB类型。（互联网告诉我BLOB是图像的正确数据类型。）

我几乎都是C++和MySQL的初学者。我想做的是用main（）编写一个小程序，将jpeg放入该表中。为了进行此练习，我不想存储对包含图像的目录的引用

我认为填写下面第2栏的部分就这么简单，这是不是错了

#include <iostream>
#include <string>
#include <mysql.h>

using namespace std;

int main(int argc, char **argv)
{

    //BLOCK 1: INIT
    MYSQL *connection, mysql;
    MYSQL_RES *result;
    MYSQL_ROW row;

    int query_state;

    mysql_init(&mysql);
    connection = mysql_real_connect(&mysql, "localhost", "root", "secret", "beginner_db",0,0,0);

    //BLOCK 2: SEND QUERY
    /* do something to insert image to table */

    //BLOCK 3: DISPLAY QUERY RESULTS
    result = mysql_store_result(connection);
    /* do something with result */

    //BLOCK 4: FREE
    mysql_free_result(result);
    mysql_close(connection);

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
int main（int argc，字符**argv）
{
//块1:INIT
MYSQL*连接，MYSQL；
MYSQL_RES*结果；
MYSQL_行；
int查询_状态；
mysql_init（&mysql）；
connection=mysql\u real\u connect（&mysql，“localhost”，“root”，“secret”，“初学者\u db”，0,0,0）；
//块2：发送查询
/*执行一些操作以将图像插入到表中*/
//块3：显示查询结果
结果=mysql\u存储\u结果（连接）；
/*做一些有结果的事情*/
//第四区：免费
mysql_免费_结果（result）；
mysql_关闭（连接）；
返回0；
}

类似这样的内容：

CString SaveFile( CMemoryFile& File )
{
    *pFileKey = -1;

        SQLRETURN       retcode;
        SQLHSTMT        hstmt;
        CLoggEntryList  LoggEntryList( this ); // logg entries cannot be made while busy inside the hstmt, use this class to add them later
        SQLINTEGER      cbDocumentBlock;        // For binding the main image

        long            lDocumentBufferSize = 0;
        unsigned char*  pDocumentBuffer;        // Will be set to point to the buffer that should be written into the document blob field
        unsigned char   pDummyChar[] = {'0'};   // Dummy buffer to write in the image/thumbnail blob fields when using external storage

                lDocumentBufferSize = File.m_lBufferSize;
                pDocumentBuffer = File.m_pFileBuffer;


        // Allocate statement handle
        retcode = SQLAllocHandle(SQL_HANDLE_STMT, m_Database.m_hdbc, &hstmt); 

        if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) 
        {   // Create a result set

            CString szSQL;

            szSQL = ( "INSERT INTO ObjectTable (ObjectData) VALUES (  ? )");

            retcode = SQLPrepare(hstmt, (SQLCHAR*)szSQL.GetBuffer(), SQL_NTS);

            if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) 
            {
                // Bind the parameters. For parameter 1, pass the parameter number in ParameterValuePtr instead of a buffer address.

                SQLINTEGER cbNULL = 0;
                SQLINTEGER cbTEXT = SQL_NTS;
                int nColumn = 1;

                // Bind ObjectData
                cbDocumentBlock = SQL_LEN_DATA_AT_EXEC(0); //SQL_LEN_DATA_AT_EXEC(lImageBufferSize);                    
                retcode = SQLBindParameter(hstmt, nColumn++, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY,
                    0, 0, (SQLPOINTER) DOCUMENT, 0, &cbDocumentBlock);

                if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) 
                {
                    // Set values so data for parameter 1 will be passed at execution. Note that the length parameter in
                    // the macro SQL_LEN_DATA_AT_EXEC is 0. This assumes that the driver returns "N" for the 
                    // SQL_NEED_LONG_DATA_LEN information type in SQLGetInfo.

                    retcode = SQLExecute(hstmt);
                    const long      nMaxChunkSize = 400000;
                    // For data-at-execution parameters, call SQLParamData to get the parameter number set by SQLBindParameter.
                    // Call InitUserData. Call GetUserData and SQLPutData repeatedly to get and put all data for the parameter.
                    // Call SQLParamData to finish processing this parameter.

                    while (retcode == SQL_NEED_DATA) 
                    {
                        SQLPOINTER      pToken;
                        retcode = SQLParamData(hstmt, &pToken);

                        switch( (int)pToken )
                        {
                        case DOCUMENT:
                            {
                                if (retcode == SQL_NEED_DATA)
                                {
                                    for( int nPos = 0; nPos < lDocumentBufferSize; nPos += nMaxChunkSize )
                                    {
                                        int nBufferSize = min( lDocumentBufferSize - nPos, nMaxChunkSize );
                                        SQLRETURN retcode2  = SQLPutData(hstmt, pDocumentBuffer+nPos, nBufferSize );
                                        if (retcode2 != SQL_SUCCESS && retcode2 != SQL_SUCCESS_WITH_INFO) 
                                        {
                                            SQLCHAR         Sqlstate[6];
                                            SQLINTEGER      NativeError;
                                            SQLCHAR         MessageText[201];
                                            SQLSMALLINT      TextLengthPtr;

                                            retcode2 = SQLGetDiagRec( SQL_HANDLE_STMT, hstmt, 1, Sqlstate, &NativeError, MessageText, 200, &TextLengthPtr );
                                            if (retcode2 == SQL_SUCCESS || retcode2 == SQL_SUCCESS_WITH_INFO) 
                                            {
                                                MessageText[TextLengthPtr] = 0;
                                                Sqlstate[5] = 0;

                                                CString szSQLState( Sqlstate );
                                                CString szMessageText( MessageText );

                                                CString szMessage;
                                                szMessage.Format("Error in SaveFile(). SQL State %s. Native %ld. Source: %s", szSQLState, NativeError, szMessageText );
                                                SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
                                                return szMessage;
                                            }                                   
                                        }
                                    }
                                }
                                break;
                            }
                        default:
                            {
                                CString szMessage;
                                szMessage.Format("Error in SaveBuffer(). Unknown parameter buffer.");
                                SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
                                return szMessage;
                            }
                            break;
                        }
                    }
                }
                SQLRETURN retcode3;
                retcode3 = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
                ASSERT(retcode3 == SQL_SUCCESS);
            }
        }
}

CString保存文件（CMemoryFile&File）
{
*pFileKey=-1；
SQLRETURN-retcode；
SQLHSTMT-hstmt；
BloggentRylist LoggEntryList（this）；//在hstmt内部繁忙时无法创建logg条目，请稍后使用此类添加它们
SQLINTEGER cbDocumentBlock；//用于绑定主映像
长lDocumentBufferSize=0；
unsigned char*pDocumentBuffer；//将设置为指向应写入文档blob字段的缓冲区
unsigned char pDummyChar[]={'0'}；//使用外部存储器时要写入图像/缩略图blob字段的虚拟缓冲区
lDocumentBufferSize=File.m\u lBufferSize；
pDocumentBuffer=File.mpfilebuffer；
//分配语句句柄
retcode=SQLAllocHandle（SQL\u HANDLE\u STMT、m\u Database.m\u hdbc和hstmt）；
if（retcode==SQL_SUCCESS | | retcode==SQL_SUCCESS_WITH_INFO）
{//创建一个结果集
CString-szSQL；
szSQL=（“插入到ObjectTable（ObjectData）值（？）；
retcode=SQLPrepare（hstmt，（SQLCHAR*）szSQL.GetBuffer（），SQL\n）；
if（retcode==SQL_SUCCESS | | retcode==SQL_SUCCESS_WITH_INFO）
{
//绑定参数。对于参数1，在ParameterValuePtr中传递参数编号，而不是传递缓冲区地址。
SQLINTEGER cbNULL=0；
SQLINTEGER cbTEXT=SQL\n；
int nColumn=1；
//绑定对象数据
cbDocumentBlock=SQL_LEN_DATA_AT_EXEC（0）；//SQL_LEN_DATA_AT_EXEC（lImageBufferSize）；
retcode=SQLBindParameter（hstmt、nColumn++、SQL参数输入、SQL参数二进制、SQL参数二进制、，
0,0，（SQLPOINTER）文档、0和cbDocumentBlock）；
if（retcode==SQL_SUCCESS | | retcode==SQL_SUCCESS_WITH_INFO）
{
//设置值，以便在执行时传递参数1的数据
//_EXEC上的宏SQL_LEN_DATA_为0。这假设驱动程序为
//SQLGetInfo中的SQL\u需要\u LONG\u数据\u LEN信息类型。
retcode=SQLExecute（hstmt）；
const long nMaxChunkSize=400000；
//对于执行参数处的数据，调用SQLParamData以获取SQLBindParameter设置的参数编号。
//反复调用GetUserData和SQLPutData以获取和放置参数的所有数据。
//调用SQLParamData以完成此参数的处理。
while（retcode==SQL\u需要\u数据）
{
sqlptoken；
retcode=SQLParamData（hstmt和pToken）；
开关（（int）pToken）
{
案例文件：
{
if（retcode==SQL\u需要\u数据）
{
对于（int nPos=0；nPos//http://zetcode.com/tutorials/mysqlcapitutorial/
//g++ -o output source.cpp $(mysql_config --cflags) $(mysql_config --libs)
#include <stdio.h>
#include <iostream>
#include <mysql.h>

int main(int argc, char **argv)
{
  MYSQL *conn;

  int len, size;
  char data[1000*1024];
  char chunk[2*1000*1024+1];
  char query[1024*5000];

  FILE *fp;

  conn = mysql_init(NULL);
  mysql_real_connect(conn, "localhost", "root", "secret", "beginner_db", 0, NULL, 0);

  fp = fopen("filename.png", "rb");
  size = fread(data, 1, 1024*1000, fp);

  mysql_real_escape_string(conn, chunk, data, size);

  char *stat = "INSERT INTO pic_tbl(name, pic) VALUES('cexample', '%s')";
  len = snprintf(query, sizeof(stat)+sizeof(chunk) , stat, chunk);

  mysql_real_query(conn, query, len);

  fclose(fp);
  mysql_close(conn);
}

#ifdef _WIN32
#include <windows.h>
#endif

#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

#include <boost/scope_exit.hpp>

#include <mysql.h>

#define ARR_LEN(arr_id) ((sizeof (arr_id))/(sizeof (arr_id)[0]))

int main()
{
    using namespace std;

    MYSQL *pconn = mysql_init(NULL);
    BOOST_SCOPE_EXIT( (pconn) ) {
        mysql_close(pconn);
    } BOOST_SCOPE_EXIT_END

    const char *db_name = "test";
    if (!mysql_real_connect(pconn, "localhost", "test", "********", db_name, 0, NULL, CLIENT_COMPRESS)) {
        cerr << "Error: mysql_real_connect() failed to connect to `" << db_name << "`." << endl;
        return EXIT_FAILURE;
    }

    MYSQL_STMT *pinsert_into_images_stmt = mysql_stmt_init(pconn);
    BOOST_SCOPE_EXIT( (pinsert_into_images_stmt) ) {
        mysql_stmt_close(pinsert_into_images_stmt);
    } BOOST_SCOPE_EXIT_END

    const char sql1[] = "INSERT INTO images(data) VALUES (?)";
    if (mysql_stmt_prepare(pinsert_into_images_stmt, sql1, strlen(sql1)) != 0) {
        cerr << "Error: mysql_stmt_prepare() failed to prepare `" << sql1 << "`." << endl;
        return EXIT_FAILURE;
    }

    MYSQL_BIND bind_structs[] = {
        { 0 } // One for each ?-placeholder
    };

    unsigned long length0;
    bind_structs[0].length = &length0;
    bind_structs[0].buffer_type = MYSQL_TYPE_BLOB;
    bind_structs[0].is_null_value = 0;

    if (mysql_stmt_bind_param(pinsert_into_images_stmt, bind_structs) != 0) {
        cerr << "Error: mysql_stmt_bind_param() failed." << endl;
        return EXIT_FAILURE;
    }

    const char *file_name = "image.jpg";
    FILE *fp = fopen(file_name, "rb");
    BOOST_SCOPE_EXIT( (fp) ) {
        fclose(fp);
    } BOOST_SCOPE_EXIT_END

    // Use mysql_stmt_send_long_data() to send the file data in chunks.
    char buf[10*1024];
    while (!ferror(fp) && !feof(fp)) {
        size_t res = fread(buf, 1, ARR_LEN(buf), fp);
        if (mysql_stmt_send_long_data(pinsert_into_images_stmt, 0, buf, res) != 0) {
            cerr << "Error: mysql_stmt_send_long_data() failed." << endl;
            return EXIT_FAILURE;
        }
    }

    if (!feof(fp)) {
        cerr << "Error: Failed to read `" << file_name << "` in its entirety." << endl;
        return EXIT_FAILURE;
    }

    if (mysql_stmt_execute(pinsert_into_images_stmt) != 0) {
        cerr << "Error: mysql_stmt_execute() failed." << endl;
        return EXIT_FAILURE;
    }

    cout << "Inserted record #" << mysql_insert_id(pconn) << endl;
    return EXIT_SUCCESS;
}

CREATE TABLE images (
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    data MEDIUMBLOB NOT NULL,

    PRIMARY KEY (id)
);

mysql> SELECT octet_length(data) FROM images WHERE id=1; +--------------------+ | octet_length(data) | +--------------------+ | 38339 | +--------------------+ 1 row in set (0.00 sec)