install mysqlcppconn library and retrieve from mysql database table,insert

sudo apt install libmysqlcppconn-dev

#include <algorithm>
#include <atomic>
#include <barrier>
#include <bitset>
#include <chrono>
#include <ctime>
#include <fstream>
#include <functional>
#include <hashtable.h>
#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>
#include <thread>
#include <uuid/uuid.h>
#include <mysql/my_command.h>
#include <cppconn/connection.h>
#include <mysql/mysql.h>
#include <mysql/my_command.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/metadata.h>
#include <cppconn/parameter_metadata.h>
#include <cppconn/prepared_statement.h>
#include <cppconn/resultset.h>
#include <cppconn/sqlstring.h>
#include <cppconn/statement.h>

std::string get_time_now()
{
    auto now = std::chrono::high_resolution_clock::now();

    time_t raw_time = std::chrono::high_resolution_clock::to_time_t(now);
    struct tm tm_info = *localtime(&raw_time);
    std::stringstream ss;
    ss << std::put_time(&tm_info, "%Y%m%d%H%M%S");
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch());
    auto mills = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
    auto micros = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch());
    auto nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch());
    ss << "_"
       << std::setw(3) << std::setfill('0') << (mills.count() - seconds.count() * 1000)
       << std::setw(3) << std::setfill('0') << (micros.count() - mills.count() * 1000)
       << std::setw(3) << std::setfill('0') << (nanos.count() - micros.count() * 1000);
    return ss.str();
}

char *uuid_value = (char *)malloc(40);
char *get_uuid_value()
{
    uuid_t new_uuid;
    uuid_generate(new_uuid);
    uuid_unparse(new_uuid, uuid_value);
    return uuid_value;
}
 
void select_mysql()
{
    sql::Driver *driver;
    sql::Connection *conn;
    sql::ResultSet *reset;
    sql::Statement *stmt;
    sql::ResultSetMetaData *metaData;

    driver=get_driver_instance();    
    conn=driver->connect("127.0.0.1:3306","Fred","password");    
    conn->setSchema("db");
    std::string select_sql="select * from t1 order by id desc limit 100;";
    stmt=conn->createStatement(); 
    reset=stmt->executeQuery(select_sql);
    metaData=reset->getMetaData();
    int rows_count=reset->rowsCount();
    int columns=metaData->getColumnCount();
    int rowIndex=0;
    while(reset->next())
    { 
        for(int j=1;j<columns;j++)
        { 
            std::cout<<reset->getString(j)<<"\t";
        }
        std::cout<<std::endl;
    } 
    
    conn->close();
    std::cout<<std::boolalpha<<conn->isClosed()<<std::endl;
    std::cout<<get_time_now()<<","<<__FUNCTION__<<std::endl;
}

int main(int args, char **argv)
{
    select_mysql();
    std::cout << "Finished in " << __FUNCTION__ << std::endl;
}

#include <mysql/my_command.h>
#include <cppconn/connection.h>
#include <mysql/mysql.h>
#include <mysql/my_command.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/metadata.h>
#include <cppconn/parameter_metadata.h>
#include <cppconn/prepared_statement.h>
#include <cppconn/resultset.h>
#include <cppconn/sqlstring.h>
#include <cppconn/statement.h>

void select_mysql()
{
    sql::Driver *driver;
    sql::Connection *conn;
    sql::ResultSet *reset;
    sql::Statement *stmt;
    sql::ResultSetMetaData *metaData;

    driver=get_driver_instance();    
    conn=driver->connect("127.0.0.1:3306","Fred","password");    
    conn->setSchema("db");
    std::string select_sql="select * from t1 order by id desc limit 100;";
    stmt=conn->createStatement(); 
    reset=stmt->executeQuery(select_sql);
    metaData=reset->getMetaData();
    int rows_count=reset->rowsCount();
    int columns=metaData->getColumnCount();
    int rowIndex=0;
    while(reset->next())
    { 
        for(int j=1;j<columns;j++)
        { 
            std::cout<<reset->getString(j)<<"\t";
        }
        std::cout<<std::endl;
    } 
    
    conn->close();
    std::cout<<std::boolalpha<<conn->isClosed()<<std::endl;
    std::cout<<get_time_now()<<","<<__FUNCTION__<<std::endl;
}

g++-12 -std=c++23 -I. *.cpp -o h1 -luuid -lmysqlcppconn;

 

#include <mysql/mysql.h>
#include <mysql/my_command.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/metadata.h>
#include <cppconn/parameter_metadata.h>
#include <cppconn/prepared_statement.h>
#include <cppconn/resultset.h>
#include <cppconn/sqlstring.h>
#include <cppconn/statement.h>

void insert_sql(const int &len)
{
    sql::Driver *driver;
    sql::Connection *conn;
    sql::Statement *stmt;

    driver=get_driver_instance();
    conn=driver->connect("127.0.0.1:3306", "Fred", "password");
    conn->setSchema("db");
    std::stringstream ss;
    ss << "insert into t1 (name,author,content,isbn,topic,summary) values ";
    for (int i = 0; i < len; i++)
    {
        ss <<"('"<< get_uuid_value()<< "','" << get_uuid_value() << "','" << get_uuid_value() << "','"
           << get_uuid_value() << "','" << get_uuid_value() << "','" << get_uuid_value() << "'),";
    }

    std::string insertsql=ss.str();
    
    int index=insertsql.find_last_of(",");
    insertsql=insertsql.substr(0,index);
    // std::cout<<insertsql<<" at "<<__LINE__<<std::endl;
    std::cout<<len<<",at "<<__LINE__<<std::endl;
    stmt=conn->createStatement();
    int result=stmt->execute(insertsql);
    std::cout<<"inserted result:"<<result<<std::endl;
    conn->close();
    std::cout<<get_time_now()<<",finished in "<<__FUNCTION__<<std::endl;
}

int main(int args, char **argv)
{
    insert_sql(atoi(argv[1]));
    std::cout << "Finished in " << __FUNCTION__ << std::endl;
}

g++-12 -std=c++23 -I. *.cpp -o h1 -luuid -lmysqlcppconn;

fred@fred:~/C$ g++-12 -std=c++23 -I. *.cpp -o h1 -luuid -lmysqlcppconn;
fred@fred:~/C$ ./h1 1000000;
1000000,at 111
inserted result:0
20230911014951_189573294,finished in insert_sql
Finished in main
fred@fred:~/C$ 

 

#include <algorithm>
#include <chrono>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream> 
#include <sstream>
#include <thread>
#include <uuid/uuid.h>
#include <vector>
#include <cppconn/connection.h>
#include <cppconn/driver.h>
#include <cppconn/exception.h>
#include <cppconn/metadata.h>
#include <cppconn/parameter_metadata.h>
#include <cppconn/prepared_statement.h>
#include <cppconn/resultset.h>
#include <cppconn/resultset_metadata.h>
#include <cppconn/statement.h>

char *uuid_value = (char *)malloc(40);
char *get_uuid_value()
{
    uuid_t new_uuid;
    uuid_generate(new_uuid);
    uuid_unparse(new_uuid, uuid_value);
    return uuid_value;
}

void connect_db(const int &loops)
{ 
    sql::Driver *driver;
    sql::Connection *conn;
    sql::Statement *stmt;
    
    driver = get_driver_instance();
    conn = driver->connect("tcp://127.0.0.1:3306", "username", "password");
    std::cout << std::boolalpha << conn->isValid() << std::endl;
    conn->setSchema("db");
    stmt=conn->createStatement();
    std::stringstream ss;
    std::chrono::time_point<std::chrono::high_resolution_clock> _start_time,_end_time;
    std::uint64_t num=0;

    for (int i = 0; i < loops; i++)
    {
        _start_time=std::chrono::high_resolution_clock::now();
        ss = std::stringstream();
        ss << "insert into t1 (name, abstract,author,content,summary) values ";
        for(int j=0;j<1000000;j++)
        {
            ss<<"('"<<get_uuid_value()<<"','"<<get_uuid_value()<<"','"<<get_uuid_value()<<"','"
            <<get_uuid_value()<<"','"<<get_uuid_value()<<"'),";
        }

        std::string insert_sql=ss.str();
        int last_comma_index=insert_sql.find_last_of(",");
        insert_sql=insert_sql.substr(0,last_comma_index);
        bool is_inserted=stmt->execute(insert_sql);
        _end_time=std::chrono::high_resolution_clock::now();
        num+=1000000;
        std::cout<<std::boolalpha<<is_inserted<<",loops:"<<i+1
        <<",time cost:"
        <<std::chrono::duration_cast<std::chrono::seconds>(_end_time-_start_time).count()<<" seconds,"
        <<std::chrono::duration_cast<std::chrono::milliseconds>(_end_time-_start_time).count()<<" mills,"
        <<std::chrono::duration_cast<std::chrono::microseconds>(_end_time-_start_time).count()<<" micros,"
        <<std::chrono::duration_cast<std::chrono::nanoseconds>(_end_time-_start_time).count()<<" nanos!!!"
        <<std::endl;
    }
    conn->close();
    std::cout << "Finished in " << __FUNCTION__ << "," << __LINE__ << std::endl;
}

int main(int args, char **argv)
{
    connect_db(atoi(argv[1]));
    std::cout << "Finished in " << __FUNCTION__ << "," << __LINE__ << std::endl;
}

show create table t1;


CREATE TABLE `t1` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(40) NOT NULL DEFAULT '',
  `abstract` varchar(40) NOT NULL DEFAULT '',
  `author` varchar(40) NOT NULL DEFAULT '',
  `content` varchar(40) NOT NULL DEFAULT '',
  `summary` varchar(40) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11000001 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci 

g++-12 -std=c++23 -I. *.cpp -o h1 -luuid -lmysqlcppconn;

./h1 1000;