Search This Blog

Wednesday, August 1, 2018

Using MySQL Database with C++ on Various Platforms Including ARM Single Board Computers

Database server တွေကို ဆက်သွယ် အသုံးပြု တဲ့ C++ application တွေ ရေးသား တဲ့ အကြောင်း ဆွေးနွေး ပါမယ်။ MySQL (မိုင် အက်စ် ကျူ အယ်) က Oracle ရဲ့ open source ဖြစ်တဲ့ database management system တစ်ခု ဖြစ် ပါတယ်။ သူက free ရနိုင်ပြီး၊ robust ဖြစ်ရုံ မက ပဲ platforms တော်တော် များများ ပေါ်မှာ အလုပ်လုပ် ပါတယ်။ Odroid လို 32 bit armv7 achitecture SBC လေးတွေ ပေါ်မှာ တောင် source ကနေ build လုပ်ပြီး run နိုင်ပြီး၊ functionality တွေ စုံသလို၊ user interface မျိုးစုံ ရှိတာ မို့ နမူနာ အနေနဲ့ MySQL database serser ကို ဆက်သွယ် အသုံးပြု ပါမယ်။

MySQL server ကို traditional အတိုင်း relational database ပုံစံ နဲ့ သုံးလို့ ရသလို၊ schema ကို အသေ သတ်မှတ် စရာ မလိုတဲ့၊ NoSQL လို့လည်း ခေါ်ကြတဲ့ document store အနေနဲ့ လည်း သုံးလို့ ရပါတယ်။ Relational database မှာ သိမ်းမယ့် table ရဲ့ column အားလုံး ကြိုသိ ပြီး schema ကြိုသတ်မှတ် ဖို့ လိုပေမယ့်၊ document store ကတော့ schema flexible ဖြစ်ပြီး JSON object နဲ့ ကိုယ်စားပြု ဖော်ပြ ပါတယ်။ ဒီ နေရာမှာ relational model ရဲ့ power နဲ့ document store ရဲ့ flexibility ကို ပေါင်းစပ် အသုံးပြု လို့ ရအောင် X DevAPI ကို သုံးပြီး application တွေ ပြုလုပ် တဲ့ အကြောင်း ဆွေးနွေး ပါမယ်။

  1. တပ်ဆင်ခြင်း
  2. Source မှ တပ်ဆင်ခြင်း
  3. Root Password ကို reset လုပ်ခြင်း
  4. Configuration
  5. MySQL server ကို စမ်းသပ်ခြင်း
  6. Installing MySQL Connector/C++ from source
  7. အကိုးအကားများ
Linux Virtual Machine တစ်ခု လုပ်ပြီး MySQL server ကို အဲဒီ ပေါ်မှာ run ခိုင်းထား လို့ ရပါတယ်။ နမူနာ အနေနဲ့ Ubuntu Linux ကို MySQL server အတွက် သုံးပြီး၊ Single board computer (SBC) ဘက် မှာတော့ အဲဒီ server ကို ဆက်သွယ် အသုံးပြုမယ့် client C++ application ကိုပဲ ဖန်တီး ပြီး၊ database ကို ကိုင်တွယ်အသုံးပြု နိုင် ပါတယ်။ Odroid လို ပိုပြီး powerful ဖြစ်တဲ့ 32 bit ARM SBC လေးတွေ ပေါ်မှာ ဆိုရင် MySQL server ကိုပါ source ကနေ build လုပ်ပြီး တပ်ဆင် အသုံးပြု နိုင် ပါတယ်။

တပ်ဆင်ခြင်း



X protocol နဲ့ ဆက်သွယ် အသုံးပြု မှု ကို အထောက် အပံ့ ပေးတဲ့ X Plugin ပါတဲ့ MySQL server 8.0 ကို Ubuntu Linux ပေါ်မှာ တပ်ဆင် ဖို့ အတွက် သူ့ရဲ့ Download MySQL APT Repository (https://dev.mysql.com/downloads/repo/apt/) စာမျက်နှာ ကို သွားပြီး Ubuntu / Debian (Architecture Independent), DEB Package ဆိုတဲ့ apt config package ကို download လုပ်လိုက် ပါမယ် [Ora18c, Bou17]။ ဒီ နမူနာ မှာတော့ အောက်က ပုံမှာ ပြထား သလို လက်ရှိ နောက်ဆုံး ထွက် mysql-apt-config_0.8.10-1_all.deb ကို သုံးပါမယ်။ Oracle Web account ဖန်တီး ချင်ရင် ဖန်တီး နိုင် ပြီး၊ နောက် တစ်ပုံ မှာ ပြထား သလို No ကို နှိပ်ပြီး ကျော်သွား ရင်လည်း ရပါတယ်။


Figure. နောက်ဆုံးထွက် MySQL apt config package ကို ရယူခြင်း။





Figure. Oracle Web account မဖန်တီး ရန် ရွေးချယ်ခြင်း နှင့် download ကို စတင်ခြင်း။


ပြီးတဲ့ အခါ အဲဒီ directory မှာ ပုံမှာ ပြထား သလို dpkg command ကို သုံးပြီး သူ့ရဲ့ apt configure package ကို တပ်ဆင် ပါမယ်။
$ sudo dpkg -i mysql-apt-config_0.8.10-1_all.deb



Figure. Apt config package ကို တပ်ဆင်ခြင်း။


စိတ်ကြိုက် configure လုပ်ပြီး၊ OK ကို နှိပ်လိုက် တဲ့ အခါ တပ်ဆင်မှု လုပ်ဆောင်ပြီး၊ command prompt ကို ပြန်ရောက် သွား ပါလိမ့် မယ်။ ဒီ နမူနာ မှာ တော့ mysql ရဲ့ API အသစ် ဖြစ်တဲ့ X DevAPI ကို သုံးဖို့ ရည်ရွယ် တာမို့ ပုံ မှာ ပြထား သလို mysql-8.0 ကို ရွေးချယ် လိုက် ပါတယ်။ Tools နဲ့ preview packages တွေကို လည်း enabled လုပ် လိုက် ပါတယ်။


Figure. mysql-8.0 ကို ရွေးချယ်ခြင်း။


MySQL server ကို တပ်ဆင် ဖို့ အတွက် အောက်က command ကို သုံးနိုင် ပါတယ်။ တပ်ဆင် နေချိန် မှာ root password ကို သတ်မှတ် ဖို့ တောင်းရင် ထည့် ပေးနိုင် ပါတယ်။
$ sudo apt update
$ sudo apt install mysql-server
MySQL client နဲ့ စီမံ ခန့်ခွဲမှု အတွက် MySQL workbench တို့ကို တပ်ဆင် ဖို့ အတွက် လည်း အောက်က command ကို သုံးလိုက် ပါမယ်။
$ sudo apt install mysql-client mysql-workbench


Major Release Version ကို ရွေးချယ်ခြင်း



MySQL ကို တပ်ဆင်ပြီး တဲ့ အခါ တခြား major release version ကို ပြန် ပြောင်း ချင်ရင် ပြောင်းလို့ ရပြီး၊ အဲဒီ အတွက် အောက်ပါ အတိုင်း လုပ်ဆောင် နိုင် ပါတယ်။
$ sudo dpkg-reconfigure mysql-apt-config
$ sudo apt-get update


Source မှ တပ်ဆင်ခြင်း



လိုအပ်သည့်အရာများ



တစ်ချို့ platform ဥပမာ armhf တွေ အတွက် MySQL Server 8.0 က install လုပ်စရာ မရှိပဲ support မလုပ် ပါဘူး။ အဲဒါ ဆိုရင် ကိုယ့်ဟာ ကိုယ် MySQL ကို source ကနေ build လုပ်ပြီး၊ install လုပ်ဖို့ လို ပါတယ်။ Source ကနေ build လုပ်မယ် ဆိုရင် အောက်ပါ development tools တွေ စက်ထဲ မှာ ရှိနေဖို့ လိုအပ် ပါတယ်။
  • CMAKE
  • GCC 4.8 or higher
  • Boost C++ libraries
  • ncurses library
  • Git and bison (အကယ်၍ MySQL on GitHub source tree ကနေ build လုပ်မယ် ဆိုရင် )
GCC, CMAKE, Git, ncurses နဲ့ bison တို့ ကို အောက်ပါ အတိုင်း တပ်ဆင် ပါမယ်။
$ sudo apt update
$ sudo apt install build-essential
$ sudo apt install cmake
$ sudo apt install git
$ sudo apt install libncurses5-dev
$ sudo apt install bison
Boost ကို တပ်ဆင် ဖို့ အတွက် အောက်ပါ link ကို သွားပြီး၊ Version 1.66.0 ဖြစ်တဲ့ boost_1_66_0.tar.bz2 ကို ဒေါင်းလုပ် လုပ်လိုက် ပါမယ်။

https://dl.bintray.com/boostorg/release/1.66.0/source/

ပြီးတဲ့ အခါ /usr/local/ မှာ တပ်ဆင် ဖို့ အောက်ပါ command တွေကို သုံးနိုင် ပါတယ်။
$ cd /usr/local
$ sudo tar --bzip2 -xf ~/Downloads/boost_1_66_0.tar.bz2
အဲဒီ လို Boost header တွေ ရရှိပြီး တဲ့နောက် MySQL ကို build လုပ်တဲ့ အချိန် CMAKE မှာ
 -DWITH_BOOST=/usr/local/boost_1_66_0
ဆိုတဲ့ option ထည့် ပေးနိုင် ပါတယ်။ CMAKE မှာ SSL libraries တွေ မတွေ့ တဲ့ ပြဿနာ တက်နိုင် တာမို့ အောက်က အတိုင်း SSL ကို တပ်ဆင် ထားနိုင် ပါတယ်။
$ sudo apt install libssl-dev


Preconfiguration setup



MySQL ကို build မလုပ် ခင် preconfiguration setup အနေ နဲ့ အောက်ပါ တို့ကို လုပ်ဆောင် ဖို့ လိုပါတယ် [Ora18d]။ အကယ်၍ mysqld လို့ လည်း ခေါ်တဲ့ MySQL Server ကို run ဖို့ အတွက် စနစ် ထဲမှာ user နဲ့ group မရှိ သေးရင်၊ သူတို့ ကို ဖန်တီး ဖို့လို ပါတယ်။ mysql ဆိုတဲ့ user နဲ့ group ကို အောက်ပါ အတိုင်း ဖန်တီး နိုင် ပါတယ်။ mysql ဆိုတဲ့ နာမည် တွေကို မသုံးချင် ရင် တစ်ခြား နာမည် တွေကို သုံးလို့ လည်း ရ ပါတယ်။ တစ်ချို့ စနစ် တွေရဲ့ syntax က groupadd နဲ့ useradd အစား addgroup နဲ့ adduser လည်း ဖြစ်နိုင် ပါတယ်။
$ sudo groupadd mysql
$ sudo useradd -r -g mysql -s /bin/false mysql
User က ownership အတွက် ပဲ လိုတာ ဖြစ်ပြီး၊ login အတွက် မလို အပ် တာမို့၊ useradd command မှာ -r နဲ့ -s /bin/false ဆိုတဲ့ option တွေကို သုံးပြီး login permissions တွေ မရှိတဲ့ user ကို ဖန်တီး ထား ပါတယ်။ အဲဒီ options တွေကို အထောက် အပံ့ မပေး တဲ့ စနစ် တွေပေါ် မှာ ဆိုရင် တော့ ချန်လှပ် ခဲ့လို့ ရပါတယ်။ အဲဒီ နောက် dev.mysql.com/downloads/mysql/ကို သွားပြီး Select Operating System ဆိုတဲ့ drop down box မှာ Source Code ကို ရွေး၊ Select OS Version ဆိုတဲ့ နေရာ မှာ Generic Linux (Architecture Independent) ကို ရွေးပြီး တဲ့နောက် Compressed TAR Archive ကို ပုံမှာ ပြထား သလို download လုပ်လိုက် ပါမယ်။ Oracle Account လုပ်ဖို့ မေးလာ တဲ့ အခါ account sign up လုပ် ချင်ရင်၊ လုပ် လို့ ရပြီး၊ No thanks, just start my download. ကို နှိပ်ပြီး ရှေ့ဆက် သွားလို့ လည်းရ ပါတယ်။


Figure. MySQL Source ကို ရယူခြင်း။


Installation



ရလာ တဲ့ source ဖိုင် mysql-8.0.11.tar.gz ကို extract လုပ်၊ ပြီးတဲ့ အခါ build လုပ်ပြီး၊ install လုပ် ပါမယ်။
$ tar zxvf ~/Downloads/mysql-8.0.11.tar.gz
$ cd mysql-8.0.11
$ mkdir bld
$ cd bld
$ cmake .. -DWITH_BOOST=/usr/local/boost_1_66_0
$ make
$ sudo make install


Postinstallation setup



MySQL ကို တပ်ဆင် ပြီးတဲ့ အခါ postinstallation setup အနေနဲ့ mysql system database ထဲက tables တွေ ပါ ပါတဲ့ data directory ကို initialize လုပ်ဖို့ လို ပါတယ်။ အဲဒီ အတွက် MySQL ကို တပ်ဆင် ထားတဲ့ directory ကို သွားပါ မယ်။ အဲဒီ မှာ ဖိုင်တွေ၊ အခန်းခွဲ တွေ အများကြီး တွေ့နိုင် ပြီး၊ bin ဆိုတဲ့ အခန်း ထဲမှာ server နဲ့ client utility တွေ ရှိပါ တယ်။
$ cd /usr/local/mysql
Import/export operations တွေ ကို directory တစ်ခု မှာ ကန့်သတ် ပေးတဲ့ secure_file_priv ဆိုတဲ့ system variable အတွက် directory တစ်ခု ကို ဖန်တီး ပါမယ်။ ပြီးတဲ့ အခါ ownership, group နဲ့ permissions တွေကို သတ်မှတ် မှာ ဖြစ်ပါ တယ်။
$ sudo mkdir mysql-files
$ sudo chown mysql:mysql mysql-files
$ sudo chmod 750 mysql-files
User တွေ MySQL server ကို ဆက်သွယ် အသုံးပြု ဖို့ ခွင့်ပြုချက် တွေကို သတ်မှတ် ပေးတဲ့ initial MySQL grant tables တွေ ပါတဲ့ mysql database အတွက် data directory ကို initialize လုပ် ပါမယ်။
$ sudo bin/mysqld --initialize --user=mysql
ဒီ အဆင့် ပြီးတဲ့ အခါ root user အတွက် temporary password ထုတ်ပေး တာကို ပုံမှာ ပြထား သလို တွေ့ရ မှာ ဖြစ်ပြီး၊ ရေးမှတ် ထားနိုင် ပါတယ်။


Figure. MySQL root user အတွက် ယာယီ password ထုတ်ပေးခြင်း။


အကယ်၍ secure connections တွေ အတွက် အလို အလျောက် အထောက် အပံ့ ကို သုံးချင် ရင် mysql_ssl_rsa_setup ဆိုတဲ့ utility ကို သုံးပြီး default SSL နဲ့ RSA ဖိုင် တွေကို ဖန်တီး နိုင် ပါတယ်။
$ sudo bin/mysql_ssl_rsa_setup
ပြီးတဲ့ အခါ MySQL server ကို start လုပ် ဖို့ အတွက် mysqld_safe ကို အောက်ပါ အတိုင်း သုံးနိုင် ပါတယ်။
$ sudo bin/mysqld_safe --user=mysql &
# Next command is optional
$ sudo cp support-files/mysql.server /etc/init.d/mysql.server
MySQL server ကို run တဲ့ အခါ root မဟုတ် တဲ့ account ဖြစ်ဖို့ အရေးကြီး ပါတယ်။ အဲဒီ အတွက် mysqld_safe ကို root နဲ့ run ပြီး၊ --user ဆိုတဲ့ option ကို သုံးနိုင် ပါတယ်။ အဲလို မဟုတ်ရင် mysql အနေနဲ့ logged in လုပ်ပြီး မှ run ရမှာ ပါ။ MySQL server ရဲ့ temporary root password က expired ဖြစ်နေ မှာမို့ ရှေ့ အပိုင်း မှာ ဆွေးနွေး ထား သလို mysql_secure_installation ကို သုံးပြီး configure ပြန်လုပ် နိုင် ပါတယ်။
$ sudo bin/mysql_secure_installation


Startup



Linux စနစ် တွေ အတွက် binary ဒါမှ မဟုတ် source ကနေ build လုပ်ရ တဲ့ MySQL distributions တွေမှာ server ကို mysqld_safe သုံးပြီး စတင် ပေးတဲ့ mysql.server ဆိုတဲ့ script ပါ ပါတယ်။ အဲဒီ mysql.server ကိုသုံးပြီး server ကို manual စဖို့၊ ရပ်ဖို့ အတွက် အောက်က command တွေကို သုံးနိုင် ပါတယ်။
$ cd /usr/local/mysql
$ sudo support-files/mysql.server start
$ sudo support-files/mysql.server stop
MySQL ကို အလို အလျောက် စဖို့ နဲ့ ရပ်ဖို့ အတွက် ဆိုရင် တော့ mysql.server ကို mysql ဆိုတဲ့ နာမည် နဲ့ /etc/init.d directory ထဲကို ကူးထည့် ပြီး၊ executable ဖြစ်အောင် လုပ်ဖို့ လိုပါ တယ်။
$ cd /usr/local/mysql
$ sudo cp support-files/mysql.server /etc/init.d/mysql
$ sudo chmod +x /etc/init.d/mysql
ပြီးတဲ့ အခါ update-rc.d ကို သုံးပြီး system startup မှာ run ဖို့ အတွက် activate လုပ်ပါ မယ်။
$ sudo update-rc.d mysql defaults
တချို့ Linux တွေ အတွက် ဆိုရင် တော့ update-rc.d ကို မသုံးရင် /etc/rc.local ထဲမှာ အောက်က command ကို ဖြည့်ပေး နိုင် ပါတယ်။
/bin/sh -c 'cd /usr/local/mysql; ./bin/mysqld_safe --user=mysql &'
mysql.server က သူ့အတွက် options တွေကို option ဖိုင် ထဲက [mysql.server] နဲ့ [mysqld] ဆိုတဲ့ section တွေက နေ ဖတ် ပါတယ်။ Option တွေကို ထပ်ဖြည့် ချင်ရင် /etc/my.cnf ဆိုတဲ့ ဖိုင် ထဲမှာ ထပ် ဖြည့်နိုင်၊ ပြင်နိုင် ပါတယ်။ အဲဒီ ဖိုင် ရဲ့ ပုံစံ နမူနာ ကို အောက်မှာ တွေ့နိုင် ပါတယ်။
[mysqld]
datadir=/usr/local/mysql/var
socket=/var/tmp/mysql.sock
port=3306
user=mysql

[mysql.server]
basedir=/usr/local/mysql
ပုံမှာ ပြထား သလို MySQL workbench ကို ဖွင့်ပြီး၊ root ကို တစ်ခြား စက်တွေ ကပါ ဆက်သွယ် အသုံးပြု လို့ ရအောင် Limit to Hosts Matching ကို နောက်တစ်ပုံ အတိုင်း % ဖြစ်အောင် ပြုပြင် နိုင်ပါတယ်။


Figure. MySQL Workbench ကိုသုံးခြင်း။





Figure. Host ကန့်သတ်မှုကို ပြုပြင်ခြင်း။


Root Password ကို reset လုပ်ခြင်း



တပ်ဆင် ပြီးတဲ့ အခါ အကြောင်း အမျိုးမျိုး ကြောင့် root password ကို reset လုပ်ချင်ရင် mysql service ကို အရင် ရပ်လိုက် ဖို့လို ပါမယ်။
$ sudo service mysql status
$ sudo service mysql stop
ပြီးရင် သူ့ရဲ့ root password ကို reset လုပ်ဖို့ mysql safe daemon ကို --skip-grant-tables option နဲ့ စလိုက် ပါ မယ်။ အဲဒါ က ဘယ်သူ့ ကို မဆို password မလိုပဲ ဝင့်ခွင့် ပေးပြီး၊ ခွင့်ပြုချက် အပြည့် ပေးပါတယ်။ အဲဒီ လို server ကို --skip-grant-tables option နဲ့ စတာ ဟာ လုံခြုံမှု မရှိ တာကြောင့် remote connection တွေကို တားဆီးဖို့ --skip-networking က အလို အလျောက် enable ဖြစ်သွား ပါလိမ့်မယ်။
$ sudo mysqld_safe --skip-grant-tables &
အကယ်၍ mysqld_safe Directory '/var/run/mysqld' for UNIX socket file don't exists ဆိုတဲ့ error တက်နေရင် တော့ အောက်က အတိုင်း လုပ်ဆောင် နိုင် ပါတယ်။
$ sudo mkdir -p /var/run/mysqld
$ sudo chown mysql:mysql /var/run/mysqld
ပြီးတဲ့အခါ ခုနက command
$ sudo mysqld_safe --skip-grant-tables &
ကို ပြန် run လိုက်တဲ့ အခါ starting mysqld daemon လို့ ပြပြီး cursor လေး ပေါ်လာ တဲ့ အခါ mysql ကို root user အနေနဲ့ password မလိုပဲ ဝင်နိုင် ပါမယ်။
mysql -u root
အဲဒီ နောက် ပေါ်လာ တဲ့ mysql prompt မှာ semicolon တွေနဲ့ အမြဲ အဆုံးသတ် တဲ့ sql command တွေကို ထပ်ထည့် ပါမယ်။ အဲဒီက my-new-password နေရာ မှာ ကိုယ်သုံးချင်တဲ့ password ကို သုံးနိုင် ပါတယ်။
> use mysql;
> update user set authentication_string=PASSWORD("my-new-password") where User="root";
> flush privileges;
> quit
ပြီးတဲ့ အခါ စက်ကို reboot လုပ်နိုင် ပါတယ်။

Configuration



တပ်ဆင် ပြီးတာ နဲ့ mysql server က လုပ်ဆောင် နေမှာ ဖြစ်ပြီး သူ့ရဲ့ status ကို အောက်ပါ အတိုင်း ကြည့်နိုင် ပါတယ်။
$ sudo service mysql status



Figure. MySQL Service status ကို စစ်ကြည့်ခြင်း။


Server ရဲ့ နားထောင် နေတဲ့ port တွေကို ကြည့်ဖို့ အောက်က command ကို သုံးနိုင် ပါတယ်။ အဲဒီ အခါ ပုံ မှာ ပြထား သလို mysqld က 3306 နဲ့ xdevapi အတွက် 33060 မှာ listen လုပ်နေ တာကို တွေ့ရ မှာ ဖြစ် ပါတယ်။
$ sudo netstat -npl



Figure. Network port များကို စစ်ကြည့်ခြင်း။


အဲဒီ နောက်မှာ အောက်ပါ အတိုင်း server ရဲ့ security နဲ့ ပတ်သတ် တဲ့ update တစ်ချို့ ကို သတ်မှတ် နိုင် ပါတယ်။
$ mysql_secure_installation
Source ကနေ build လုပ်ထား တာ ဆိုရင်တော့ binary တွေ ရှိတဲ့ directory ကို သွားဖို့ လိုနိုင် ပြီး၊ အောက်ပါ command တွေ အတိုင်း သုံးနိုင် ပါတယ်။
$ cd /usr/local/mysql
$ sudo bin/mysql_secure_installation
အဲဒါ ကို run လိုက်တဲ့ အခါ root password ကို တောင်းရင် ထည့်ပေး လိုက်ပြီး၊ configuration တွေကို သတ်မှတ် ပါမယ်။ VALIDATE PASSWORD PLUGIN က password တွေရဲ့ strength ကို စစ်ပေးပြီး security ပိုကောင်း အောင် လုပ်ဆောင် ပေးနိုင် ပါတယ်။ ထည့်မယ် ဆိုရင် y ကို နှိပ်ပေး နိုင်ပြီး၊ မထည့်ချင် ရင်တော့ enter ပဲ ဖြစ်ဖြစ် key တစ်ခုခု ကို နှိပ် နိုင် ပါတယ်။ အဲဒီ နောက် root password ကို ပြန်ပြင် ချင်ရင် ပြင်နိုင် ပါတယ်။ နောက် တစ်ခု က MySQL ကို user account မရှိလည်း ဝင်လို့ ရအောင် စီမံ ထားတဲ့ anonymous user ပါ။ Root ကို remotely ဝင်လို့ မရအောင် ပိတ် ချင်လည်း ပိတ်နိုင် ပါတယ်။ စမ်းသပ် ဖို့ အတွက် test database ကို ဖယ်မယ် ဆိုရင် လည်း ဖယ်နိုင် ပါတယ်။ ပြီးတဲ့ အခါ အပြောင်း အလည်း တွေ သက်ရောက်မှု ရှိအောင် privilege tables တွေကို reload လုပ်နိုင် ပါတယ်။

MySQL server ကို စမ်းသပ်ခြင်း



MySQL အတွက် utilities တွေကို /usr/local/mysql ရဲ့ bin ထဲမှာ တွေ့နိုင် ပါတယ်။ အဲဒီ directory ကို သွားပြီး ls ဆိုတဲ့ command နဲ့ list လုပ်ကြည့်နိုင် ပါတယ်။

mysqladmin



mysqladmin က MySQL server ကို administer လုပ်ဖို့ အတွက် client တစ်ခု ပါ။ သူ့ကို သုံးပြီး server version ကို စစ်မယ် ဆိုရင် အောက်ပါ အတိုင်း စစ်ကြည့် နိုင် ပါတယ်။
$ sudo mysqladmin -u root -p version
Source ကနေ build လုပ်ထား တာ ဆိုရင်တော့ အောက်ပါ command တွေ အတိုင်း utilities directory ကို သွားပြီး သုံးနိုင် ပါတယ်။
$ cd /usr/local/mysql
$ sudo bin/mysqladmin -u root -p version
Databases တွေကို ကြည့်ချင် ရင် တော့ mysqlshow နဲ့ ကြည့်လို့ ရပါတယ်။
$ sudo bin/mysqlshow -u root -p version


mysql



mysql command line tool က ရိုးရှင်း တဲ့ SQL shell တစ်ခု ဖြစ်ပါ တယ်။ mysql ကို သုံးဖို့ အတွက် အောက်ပါ command နဲ့ ဝင်နိုင် ပြီး ပေါ်လာ တဲ့ prompt မှာ mysql command တွေကို semicolon တွေနဲ့ အဆုံး သတ်ပြီး ထည့်နိုင် ပါတယ်။ MySQL server ကို apt နဲ့ install လုပ်ခဲ့တာ ဆိုရင် တော့ binary ဖိုင်တွေ ရှိတဲ့ path ကို သွား စရာ မလိုပဲ mysql command ကို တန်းသုံး နိုင် ပါတယ်။
$ cd /usr/local/mysql
$ sudo bin/mysql -u root -p
Database တွေကို အောက်ပါ အတိုင်း ကြည့်နိုင် ပါတယ်။
> SHOW DATABASES;
နမူနာ အနေနဲ့ database တစ်ခု ကို ဖန်တီး ကြည့်ဖို့ အတွက် CREATE DATABASE ကို သုံးကြည့် ပါမယ်။
> CREATE DATABASE mytest;
ပြီးတဲ့ အခါ database တွေကို ပြန် ပြခိုင်း ကြည့် တဲ့ အခါ ခုနက ဖန်တီး လိုက် တဲ့ database ပါ ပေါ်လာ တာကို တွေ့နိုင် ပါတယ်။ နောက်ထပ် ထည့် မယ့် command တွေ အတွက် default database ကို mytest လို့ သတ်မှတ်ဖို့ USE ကို သုံးနိုင် ပါတယ်။
> USE mytest;
အဲဒီ နောက် table တစ်ခု ကို ဖန်တီး ကြည့်ဖို့ CREATE TABLE ကို သုံးလိုက် ပါမယ်။
> CREATE TABLE tbl1
(
id INT unsigned NOT NULL AUTO_INCREMENT, # unique id for the record
name   VARCHAR(150) NOT NULL, # name
birthday DATE NOT NULL, # birthday
PRIMARY KEY (id) # make the id the primary key
);
ဖန်တီး လိုက် တဲ့ table ကို SHOW TABLES နဲ့ ကြည့်နိုင် ပါတယ်။
> SHOW TABLES;
Table ရဲ့ column တွေကို ကြည့်ဖို့ DESCRIBE နဲ့ကြည့်နိုင် ပါတယ်။
> DESCRIBE tbl1;
MySQL ကနေ ထွက်ပြီး ပုံမှန် bash prompt ကို ပြန်သွား ဖို့ အတွက် exit ကို သုံး လို့လည်း ရ ပါတယ်။
$ exit
MySQL ရဲ့ လက်ရှိ plugins တွေကို အောက်ပါ အတိုင်း ကြည့်လို့ လည်း ရပါတယ်။
$ mysql -u root -p -e "show plugins"


Installing MySQL Connector/C++ from source



MySQL server ကို C++ application ကနေ သုံးဖို့ အတွက် MySQL Connector/C++ ကို အသုံးပြု နိုင် ပါတယ် [Ora18a]။ Connector C++ 8.0 ကို သုံးတဲ့ အတွက် C++ application တွေမှာ X DevAPI ကို သုံးလို့ ရပြီး၊ plain SQL queries တွေ လုပ်ဆောင် လို့ ရသလို၊ document store ကို သုံးထား တဲ့ MySQL server တွေကို လည်း X Plugin သုံးပြီး ဆက်သွယ် လို့ ရပါတယ်။

Build Tools



Connector C++ ကို build လုပ်ဖို့ အတွက် C++11 ကို အထောက် အပံ့ ပေးနိုင် တဲ့ C++ compiler လိုပါတယ်။ Cross platform build tool တစ်ခု ဖြစ်တဲ့ CMake လည်း ရှိဖို့ လိုပါတယ်။ Git repository ကနေ ရယူဖို့ အတွက် git ကို လည်း တပ်ဆင် ထားဖို့ လိုမှာ ပါ။ အဲဒါ တွေ မရှိ သေးရင် အောက်ပါ အတိုင်း တပ်ဆင် နိုင် ပါတယ်။
$ sudo apt update
$ sudo apt install build-essential
$ sudo apt install cmake git
Legacy JDBC connector တွေကို ပါ သုံးဖို့ ရည်ရွယ် ရင်တော့ Boost C++ libraries တွေ ပါ ထည့်ပေးဖို့ လိုတာ မို့ ရှေ့ အပိုင်း မှာ ဆွေးနွေး ခဲ့ သလို boost_1_66_0 ကို တပ်ဆင် နိုင်ပါတယ်။

ရယူခြင်း



အဲဒီ အတွက် Download Connector/C++ Web Page ကိုသွား၊ dropdown box မှာ source ကို ရွေးပြီး download လုပ်၊ extract လုပ်လို့ ရသလို၊ git clone ကို သုံး ရင်လည်း ရပါတယ်။ Extract လုပ်ဖို့ အောက်ပါ command လိုမျိုး သုံးနိုင် ပါတယ်။ ပြီးတဲ့ အခါ ရလာ တဲ့ directory ကို သွားပါမယ်။
$  tar zxvf mysql-connector-c++-8.0.11-src.tar.gz
$ cd mysql-connector-c++-8.0.11-src
Git repository ကနေ clone လုပ်ဖို့ အတွက် တော့
$ git clone https://github.com/mysql/mysql-connector-cpp.git
ကို သုံးနိုင် ပါတယ်။ ပြီးတဲ့ အခါ ရလာ တဲ့ directory ကို သွားပြီး၊ 8.0 branch ကို checkout လုပ်လိုက် ပါမယ်။
$ cd mysql-connector-cpp
$ git checkout 8.0
ပုံမှန်အား ဖြင့် legacy JDBC connector ကို build မလုပ် ပါဘူး။ အကယ်၍ သူ့ကို ပါ သုံးဖို့ ရည်ရွယ် တယ် ဆိုရင် submodule initialization ကို အောက်ပါ အတိုင်း လုပ်နိုင် ပါတယ်။
$ git submodule update --init


Configuring



Connector C++ 8.0 ကို configure လုပ်၊ build လုပ် ဖို့ အတွက် CMake ကို သုံးပါ မယ်။ Build လုပ်ဖို့ directory တစ်ခု ဖန်တီး ပြီး အဲဒီ directory ကို သွားပါ မယ်။
$ mkdir build
$ cd build
Default install လုပ်မယ့် နေရာ က /usr/local/mysql/connector-c++-8.0 ဖြစ်ပြီး၊ CMAKE_INSTALL_PREFIX ကို သုံးပြီး စိတ်ကြိုက် သတ်မှတ် လို့လည်း ရပါတယ်။ ဘာမှ မပြောရင် dynamic (shared) libraries ကို build လုပ်မှာ ဖြစ် ပြီး၊ static libraries ကို build လုပ်ချင်ရင် -DBUILD_STATIC=ON ကို သတ်မှတ် နိုင် ပါတယ်။ Default ဆိုရင် legacy JDBC connector ကို ထည့်ပြီး build မလုပ် တဲ့ အတွက် သူ့ကို ပါစေချင် ရင်
-DWITH_JDBC=ON
ဆိုတဲ့ option ကို ထည့်ပေးဖို့ လိုပါ တယ်။ အဲဒါ ဆိုရင် Boost C++ libraries တွေ ပါ ထည့်ပေးဖို့ လိုတာ မို့ ရှေ့ အပိုင်း မှာ ဆွေးနွေး ခဲ့ သလို boost_1_66_0 ကို တပ်ဆင် ပြီး
-DWITH_BOOST=/usr/local/boost_1_66_0
ဆိုတဲ့ option ထည့် ပေးနိုင် ပါတယ်။ အဲဒီ အတွက် အောက်က အတိုင်း cmake နဲ့ build လုပ်မယ့် configuration ကို သတ်မှတ် နိုင် ပါတယ်။
$ cmake -DCMAKE_INSTALL_PREFIX=/usr/local/mysql/connector-c++-8.0 \
-DWITH_BOOST=/usr/local/boost_1_66_0  -DWITH_JDBC=ON ..


Building



အဲဒီ လို Configure လုပ်ပြီး တဲ့ အခါ build လုပ်ဖို့ အတွက် အောက်ပါ command ကို သုံးနိုင် ပါတယ်။ Release သို့မဟုတ် Debug သတ်မှတ်ဖို့ --config option ကို သုံးနိုင် ပြီး၊ အဲဒီ option မထည့် ရင် Release ကို build လုပ်မှာ ဖြစ် ပါတယ်။
$ cmake --build . --config Release
Build လုပ်လိုက် တဲ့ အခါ
libmysqlcppconn8.so.1
ဆိုတဲ့ connector library ကို build directory ထဲမှာ ရလာ ပါမယ်။

Installing



Build လုပ်ပြီး တဲ့ အခါ ရလာတဲ့ Connector C++ 8.0 libraries တွေကို install လုပ်ဖို့ အောက်က command ကို သုံး ပါမယ်။
$ sudo cmake --build . --target install --config Release
အဲဒီ နောက် /usr/local/mysql/connector-c++-8.0/ မှာ lib64 ဆိုတဲ့ directory မရှိ သေးရင် ဖန်တီး လိုက် ပါမယ်။ 32 bit architecture တွေပေါ် မှာတော့ lib64 အစား lib လို့ပဲ ခေါ်ပါမယ်။
$ sudo mkdir /usr/local/mysql/connector-c++-8.0/lib64
Legacy JDBC connector ကို ပါထည့်ပြီး build လုပ်ခဲ့ ရင် lib64 directory က ဖန်တီး ထားပြီး သား တွေ့ရ မှာ ဖြစ်ပြီး နောက်ထပ်
libmysqlcppconn.so.7
ဆိုတဲ့ library ကို ပါ /usr/local/mysql/connector-c++-8.0/lib64 ထဲမှာ တွေ့ရ မှာပါ။ ပြီးတဲ့ အခါ အောက်က command ကို သုံးပြီး၊ library ကို ကူးပါမယ်။
$ sudo cp libmysqlcppconn8.so /usr/local/mysql/connector-c++-8.0/lib64/
$ sudo cp libmysqlcppconn8.so.1.8.0.11 /usr/local/mysql/connector-c++-8.0/lib64/
ပြီးတဲ့ အခါ /etc/ld.so.conf.d/ ဆိုတဲ့ directory ထဲမှာ mysqlcppconn8.conf ဆိုတဲ့ ဖိုင် တစ်ခု ဖန်တီး ပြီး edit လုပ် ပါမယ်။
$ sudo nano /etc/ld.so.conf.d/mysqlcppconn8.conf
ပွင့်လာ တဲ့ nano editor မှာ အောက်ပါ အတိုင်း ဖြည့်ပြီး၊ ctrl+o နှိပ်၊ enter ခလုတ် ကို နှိပ်ပြီး ဖိုင် ကို save လုပ်၊ ctrl+x နဲ့ ထွက်လိုက် ပါမယ်။
/usr/local/mysql/connector-c++-8.0/lib64/
အဲဒီ နောက် အောက်ပါ အတိုင်း ldconfig လုပ်ပါမယ်။
$ sudo ldconfig


Connector C++ Application များ build လုပ်ခြင်း



MySQL Connector C++ 8.0 က MySQL Server 8.0 ရဲ့ စိတ်လှုပ်ရှား စရာ feature အသစ် တွေကို အသုံးပြု နိုင် ပါတယ်။ ဥပမာdatabase လုပ်ငန်း ဆောင်တာ တွေကို ရိုးရှင်း ပြီး၊ ထိထိ ရောက်ရောက် သုံးလို့ ရတဲ့ MySQL Document Store လိုမျိုး အသစ် တွေကို C++ ရဲ့ အားသာ ချက်တွေနဲ့ ပေါင်းပြီး သုံးလို့ ရသွား ပါတယ်။ X Protocol ကို အထောက် အပံ့ ပေးတာ မို့၊ သူ့ကို အသုံးပြု ပြီး X DevAPI ကို သုံးတဲ့ နမူနာ C++ ပရိုဂရမ် တစ်ခု ရေးကြည့် ပါမယ် [Ora18b]။ Connector C++ ကို သုံးဖို့ ပရိုဂရမ် အစမှာ အောက်ပါ ကုဒ်တွေကို ထည့်ပါမယ်။
#include < mysqlx/xdevapi.h >
using namespace mysqlx;
Database connection အတွက် X Plugin လုပ်ဆောင် မှု ရှိတဲ့ MySQL server တွေကို logical session တွေ တည်ဆောက် နိုင် ပါတယ်။ Session object တွေကို သုံးထား တဲ့ application တွေက single server ပေါ်မှာ ပဲ ဖြစ်ဖြစ်၊ database cluster ပေါ်မှာ ပဲ ဖြစ်ဖြစ် ကုဒ် ကို ပြန်ပြောင်း စရာ မလိုပဲ သုံးနိုင် ပါတယ်။ Database ကို connection တည်ဆောက် ဖို့ URI type string ကို သုံးပြီး
Session my_session("user:password@host:port");
လို့ ချိတ်ဆက် လို့ ရသလို
Session my_session("host",port,"user","password");
လို့ လည်း ဆက်လို့ ရပါတယ်။ Session ချိတ်ဆက် လို့ ရပြီးတဲ့ အခါ server မှာရှိတဲ့ database တွေကို list လုပ်ကြည့် ပါမယ်။ အဲဒီ အတွက် database list ကို getSchemas() method နဲ့ ရယူ နိုင် ပါတယ်။
std::list schemaList = my_session.getSchemas();
နမူနာ mysqltest.cpp ပရိုဂရမ် ကို အောက်က စာရင်း မှာ ပြထား ပါတယ်။
#include < iostream >
#include < mysqlx/xdevapi.h >
using namespace std;
using namespace mysqlx;

int main()
try {
  cout <<"Getting session..." < schemaList = sess.getSchemas();
  cout<<"Available schemas in this session:"<< endl;

  //loop over all available schemas and print their name
  for(Schema schema : schemaList) {
    cout << schema.getName() << endl;
  }
}
catch (const mysqlx::Error &err)
{
  cout << "ERROR: " << err << endl;
}
C++ application တွေကို build လုပ်တဲ့ အခါ MySQL Connector C++ 8.0 ကို build လုပ်တုန်း က သုံးခဲ့ တဲ့ tools တွေကို ပဲ သုံးရ ပါမယ်။ Compiler version, runtime library, runtime linker configuration settings စတာ တွေ တူညီ ဖို့ လိုပါ တယ်။ C++11 ကို အထောက် အပံ့ ပေးဖို့ -std=c++11 ဆိုတဲ့ option ကို လည်း ထည့်ပေး ဖို့ လို ပါတယ်။ Build configuration ကိုလည်း Release ဒါမှ မဟုတ် Debug option က Connector C++ အတိုင်း ဖြစ်ဖို့ လိုပါ တယ်။ အဲဒီ နောက် အောက်က အတိုင်း build လုပ်ပြီး၊ run နိုင် ပါတယ်။ Library path မှာ 64 bit စက်အတွက် ဆိုရင် lib64 ဖြစ် ပါမယ်။
$ g++ -std=c++11 -I /usr/local/mysql/connector-c++-8.0/include -L /usr/local/mysql/connector-c++-8.0/lib mysqltest.cpp -lmysqlcppconn8 -o mysqltest
$ ./mysqltest
Build လုပ်ဖို့ အတွက် make ဖိုင်၊ ဒါမှ မဟုတ် ရိုးရှင်း တဲ့ scrpit ဖိုင် တစ်ခုခု ရေးထား ပြီး သုံးတာက ပို အဆင်ပြေ ပါတယ်။ ပရိုဂရမ် ရဲ့ ရလဒ် ကို ပုံမှာ ပြထား ပါတယ်။


Figure. mysqltest.cpp ၏ ရလဒ်။


Legacy Connector C++ 1.1 အသုံးပြုပုံနမူနာ



Legacy connector C++ 1.1 အသုံးပြု တဲ့ အကြောင်း ထပ် ဆွေးနွေး ပါမယ်။ အဲဒါ ဆိုရင် သူ့နဲ့ ဆက်သွယ် မယ့် MySQL server မှာ X Plugin လုပ်ဆောင် မှု မလိုပဲ၊ ပုံမှန် MySQL port number 3306 ကို ပဲ ဆက်သွယ် အသုံးပြု မှာ ဖြစ်ပါတယ်။ သ ူ့ကို သုံးမယ့် C++ ပရိုဂရမ် မှာ လိုအပ် တဲ့ header ဖိုင် တွေကို အောက်ပါ အတိုင်း ထည့်ပေး နိုင် ပါတယ်။
#include "jdbc/mysql_connection.h"
#include < jdbc/cppconn/driver.h >
#include < jdbc/cppconn/exception.h >
#include < jdbc/cppconn/resultset.h >
#include < jdbc/cppconn/statement.h >
MySQL server ကို ဆက်သွယ် အသုံး ပြု မယ့် connection တစ်ခု ရဖို့ အတွက် sql::mysql::MySQL_Driver ဆိုတဲ့ object ကနေ sql::Connection ဆိုတဲ့ instance တစ်ခု ကို ရယူဖို့ လို ပါတယ်။
sql::Driver *driver;
sql::Connection *con;

driver = get_driver_instance();
con = driver->connect("tcp://127.0.0.1:3306", "username", "password");
Connection က alive ဖြစ်နေ မနေ ကို sql::Connection::isValid() နဲ့ စစ်နိုင် ပြီး၊ connection ကျသွား ရင် sql::Connection::reconnect() နဲ့ ပြန်ဆက် နိုင် ပါတယ်။
ရိုးရှင်း တဲ့ queries တွေ လုပ်ဆောင် ဖို့ အတွက် sql::Statement::execute() ကို သုံးနိုင် ပြီး၊ ရလာ မယ့် ရလဒ် မရှိ ရင်ပဲ ဖြစ်ဖြစ်၊ ရလဒ် က တစ်ခု မက ရှိရင် ပဲ ဖြစ်ဖြစ် သုံးဖို့ သင့်တော် ပါတယ်။ တကယ်လို့ ရလဒ် တစ်ခု ပဲ ရှိမယ့် queries ဆိုရင် တော့ sql::Statement::executeQuery() ကို သုံးနိုင် ပါတယ်။
sql::mysql::MySQL_Driver *driver;
sql::Connection *con;
sql::Statement *stmt;
driver = sql::mysql::get_mysql_driver_instance();
con = driver-> connect("tcp://127.0.0.1:3306", "user", "password");
stmt = con-> createStatement();
stmt-> execute("USE " EXAMPLE_DB);
stmt-> execute("DROP TABLE IF EXISTS test");
stmt-> execute("CREATE TABLE test(id INT, label CHAR(1))");
stmt-> execute("INSERT INTO test(id, label) VALUES (1, 'a')");
Run လိုက်တဲ့ queries မှာ result set တစ်ခု ပဲ ရှိရင် sql::ResultSet ဆိုတဲ့ objects တွေိကို return လုပ်ပေး ပါတယ်။
// ...
sql::Connection *con;
sql::Statement *stmt;
sql::ResultSet *res;
// ...
stmt = con->createStatement();
// ...
res = stmt-> executeQuery("SELECT id, label FROM test ORDER BY id ASC");
while (res-> next()) {
// You can use either numeric offsets...
cout << "id = " << res->getInt(1); // getInt(1) returns the first column
// ... or column names for accessing results.
// The latter is recommended.
cout << ", label = '" << res->getString("label") << "'" << endl;
}
ရှေ့မှာ သုံးခဲ့ တဲ့ sql::Connection, sql::Statement, sql::ResultSet စတဲ့ object တွေကို delete သုံးပြီး explicitly free လုပ်ဖို့ လို ပါတယ်။ mysql::MySQL_Driver object ကို တော့ explicitly free လုပ်ဖို့ မလိုပဲ Connecter C++ သူ့ဟာ သူ free လုပ် ပေး ပါလိမ့် မယ်။
delete res;
delete stmt;
delete con;
Connector C++ 1.1 အသုံးပြု ပုံ နမူနာ အနေ နဲ့ con11test.cpp ပရိုဂရမ် ကို အောက်က စာရင်း မှာ ပြထား ပါတယ်။
//Source: https://dev.mysql.com/doc/connector-cpp/1.1/en/connector-cpp-examples-complete-example-1.html
#include < stdlib.h >
#include < iostream >

#include " jdbc/mysql_connection.h "
#include < jdbc/cppconn/driver.h >
#include < jdbc/cppconn/exception.h >
#include < jdbc/cppconn/resultset.h >
#include < jdbc/cppconn/statement.h >

using namespace std;

int main(void)
{
cout << endl;
cout << "Running ELECT Hello World! AS _message ..." << endl;

try {
  sql::Driver *driver;
  sql::Connection *con;
  sql::Statement *stmt;
  sql::ResultSet *res;

  /* Create a connection */
  driver = get_driver_instance();
  con = driver-> connect("tcp://127.0.0.1:3306", "root", "password");
  /* Connect to the MySQL test database */
  con-> setSchema("mytest");

  stmt = con->createStatement();
  res = stmt->executeQuery("SELECT 'Hello World!' AS _message");
  while (res->next()) {
    cout << "\t... MySQL replies: ";
    /* Access column data by alias or column name */
    cout << res-> getString("_message") << endl;
    cout << "\t... MySQL says it again: ";
    /* Access column data by numeric offset, 1 is the first column */
    cout << res-> getString(1) << endl;
  }
  delete res;
  delete stmt;
  delete con;

} catch (sql::SQLException &e) {
  cout << "# ERR: SQLException in " << __FILE__;
  cout << "(" << __FUNCTION__ << ") on line "<< __LINE__ << endl;
  cout << "# ERR: " << e.what();
  cout << " (MySQL error code: " << e.getErrorCode();
  cout << ", SQLState: " << e.getSQLState() << " )" << endl;
}

cout << endl;

return EXIT_SUCCESS;
}
Connector C++ 1.1 ပရိုဂရမ် တွေကို build လုပ်မယ် ဆိုရင် include path မှာ Boost ရဲ့ header ဖိုင်တွေ ရှိတဲ့ path ကို ပါ ထပ်ထည့် ပေးဖို့ လိုပါတယ်။ ပြီးရင် connector library ကိုလည်း အဟောင်း ဖြစ်တဲ့ mysqlcppconn ကို link လုပ်ပေး ရ ပါမယ်။ Build လုပ်ပြီး run ဖို့ အတွက် scrpit ဖိုင် con11test-bar.sh ကို အောက်က စာရင်း မှာ ပြထား ပါတယ်။
g++ -std=c++11 -I /usr/local/mysql/connector-c++-8.0/include \
  -I /usr/local/boost_1_66_0 -L /usr/local/mysql/connector-c++-8.0/lib \
    con11test.cpp -lmysqlcppconn -o con11test
./con11test
ပရိုဂရမ် ရဲ့ ရလဒ် ကို ပုံမှာ ပြထား ပါတယ်။


Figure. con11test.cpp ၏ ရလဒ်။


Legacy JDBC API အသုံးပြုပုံနမူနာ



Legacy JDBC-based API ကို Connector C++ 1.1 နဲ့ သုံးတဲ့ C++ application နမူနာ တစ်ခု ကို လည်း ဖော်ပြ ပြီး၊ bulid လုပ်၊ run လုပ် တဲ့ အကြောင်း ဆွေးနွေး ချင် ပါတယ်။ နမူနာ ပရိုပရမ် jdbc_test.cpp ကို Connector C++ 8 ရဲ့ source directory (mysql-connector-c++-8.0.11-src) ထဲက testapp ဆိုတဲ့ အခန်း ထဲမှာ တွေ့နိုင် ပြီး၊ သူ့ကို အောက်က စာရင်း မှာ ပြန် ဖော်ပြ ထား ပါတယ်။
#include < stdlib.h >
#include < iostream >
#include < sstream >
#include < stdexcept >

#include < boost/scoped_ptr.hpp >
#include < jdbc/mysql_connection.h >
#include < jdbc/mysql_driver.h >
#include < jdbc/cppconn/resultset.h >
#include < jdbc/cppconn/statement.h >

#define DEFAULT_URI "tcp://127.0.0.1"
#define EXAMPLE_USER "root"
#define EXAMPLE_PASS "password"
#define EXAMPLE_DB "mytest"

using namespace std;

int main(int argc, const char **argv)
{
  const char   *url = (argc > 1 ? argv[1] : DEFAULT_URI);
  const string user(argc >= 3 ? argv[2] : EXAMPLE_USER);
  const string pass(argc >= 4 ? argv[3] : EXAMPLE_PASS);
  const string database(argc >= 5 ? argv[4] : EXAMPLE_DB);

  cout << endl;
  cout << "Connector/C++ standalone program example..." << endl;
  cout << endl;

  try {

    sql::Driver * driver = sql::mysql::get_driver_instance();

    /* Using the Driver to create a connection */

    cout << "Creating session on " << url << " ..."
         << endl << endl;

    boost::scoped_ptr< sql::Connection >
      con(driver-> connect(url, user, pass));
    con-> setSchema(database);

    boost::scoped_ptr < sql::Statement > stmt(con-> createStatement());
    boost::scoped_ptr < sql::ResultSet >
      res(stmt-> executeQuery("SELECT 'Welcome to Connector/C++' AS _message"));
    cout << "\t... running 'SELECT 'Welcome to Connector/C++' AS _message'"
         << endl;

    while (res-> next())
    {
      cout << "\t... MySQL replies: " << res-> getString("_message") << endl;
      cout << "\t... say it again, MySQL" << endl;
      cout << "\t....MySQL replies: " << res-> getString(1) << endl;
    }

  }
  catch (sql::SQLException &e)
  {
    /*
      The JDBC API throws three different exceptions:

    - sql::MethodNotImplementedException (derived from sql::SQLException)
    - sql::InvalidArgumentException (derived from sql::SQLException)
    - sql::SQLException (derived from std::runtime_error)
    */

    cout << "# ERR: SQLException in " << __FILE__;
    cout << "(" << "EXAMPLE_FUNCTION" << ") on line " << __LINE__ << endl;

    /* Use what() (derived from std::runtime_error) to fetch the error message */

    cout << "# ERR: " << e.what();
    cout << " (MySQL error code: " << e.getErrorCode();
    cout << ", SQLState: " << e.getSQLState() << " )" << endl;

    return EXIT_FAILURE;
  }

  cout << endl;
  cout << "... find more at http://www.mysql.com" << endl;
  cout << endl;
  return EXIT_SUCCESS;
}
သူ့ကို build လုပ်ဖို့ အတွက် Connector C++ 1.1 နမူနာ အတိုင်း include path မှာ Boost ရဲ့ header ဖိုင်တွေ ရှိတဲ့ path ကို ပါ ထပ်ထည့် ပေးဖို့ လိုပြီး၊ connector library ကိုလည်း အဟောင်း ဖြစ်တဲ့ mysqlcppconn ကို link လုပ်ပေး ရ ပါမယ်။ အဲဒီ အတွက် scrpit ဖိုင် jdbc_test-bar.sh ကို အောက်က စာရင်း မှာ ပြထား ပါတယ်။
g++ -std=c++11 -I /usr/local/mysql/connector-c++-8.0/include \
  -I /usr/local/boost_1_66_0 -L /usr/local/mysql/connector-c++-8.0/lib \
  jdbc_test.cpp -lmysqlcppconn -o jdbc_test
./jdbc_test
ပရိုဂရမ် ရဲ့ ရလဒ် ကို ပုံမှာ ပြထား ပါတယ်။


Figure. jdbc_test.cpp ၏ ရလဒ်။




အကိုးအကားများ



[Bou17] Brian Boucheron. How To Install the Latest MySQL on Ubuntu 16.04. 2017.
url: https://www.digitalocean.com/community/tutorials/how-to-install-the-latest-mysql-on-ubuntu-16-04.

[Ora18a] Oracle. MySQL Connector/C++ 8.0 Developer Guide. 2018.
url: https://dev.mysql.com/doc/connector-cpp/8.0/en/.

[Ora18b] Oracle. X DevAPI User Guide. 2018.
url: https://dev.mysql.com/doc/x-devapi-userguide/en/.

[Ora18c] Oracle. A Quick Guide to Using the MySQL APT Repository. 2018.
url: https://dev.mysql.com/doc/mysql-apt-repo-quick-guide/en/.

[Ora18d] Oracle. Installing MySQL Using a Standard Source Distribution. 2018.
url: https://dev.mysql.com/doc/refman/8.0/en/installing-source-distribution.html.



Related Posts:



1. Cool Emerald. MySQL Connector C++ 8.0 with wxWidgets. 2018.
url: http://coolemerald.blogspot.com/2018/10/mysql-connector-c-80-with-wxwidgets.html.