数据库

主流开发语言如何在arm64平台上连接MariaDB数据库

作者: zhaorenhai

本文尝试探索下几种主流的开发语言如何在arm64平台上连接MariaDB数据库，并测试一下增删改查各项功能是否都正常。主要包括如下几种语言：C , Java, Node.js, Python, Go, Rust, PHP

测试平台采用华为云的鲲鹏虚拟机，OS采用Ubuntu18.04。 并提前已经在同内网内的另外一台虚拟机上已经部署好了一个MariaDB数据库，并建好了供远程连接的数据库用户名和密码, 这里假设我们新建的用户名为proxysql，密码为proxypassword，端口号就用默认的3306端口号。

C语言

首先安装连接器库

1
sudo apt install libmariadbclient-dev

然后新建一个C语言文件version.c，输入如下内容：

1
2
3
4
5
6
7
8
9
10
#include <mysql.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
  printf("MySQL client version: %s\n", mysql_get_client_info());

  exit(0);
}

编译并执行：

1
2
gcc version.c -o version  `mysql_config --cflags --libs`
./version

可以看到输出如下：

1
MySQL client version: 10.1.47-MariaDB

说明可以成功打印出客户端的版本。

接下来我们新建一个createdb.c文件，输入如下代码，测试下创建数据库的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <mysql.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
  MYSQL *con = mysql_init(NULL);

  if (con == NULL)
  {
      fprintf(stderr, "%s\n", mysql_error(con));
      exit(1);
  }

  if (mysql_real_connect(con, "192.168.0.204", "proxysql", "proxypassword",
    NULL, 0, NULL, 0) == NULL)
  {
      fprintf(stderr, "%s\n", mysql_error(con));
      mysql_close(con);
      exit(1);
  }

  if (mysql_query(con, "CREATE DATABASE testdb"))
  {
      fprintf(stderr, "%s\n", mysql_error(con));
      mysql_close(con);
      exit(1);
  }

  mysql_close(con);
  exit(0);
}

编译并执行

1
2
gcc createdb.c -o createdb  `mysql_config --cflags --libs`
./createdb

接下来我们新建一个testdb.c文件，输入如下代码，测试下新增表，插入记录，查询表，关联查询，更新，删除记录，删除表各项功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include <mysql.h>
#include <stdio.h>
#include <stdlib.h>

void finish_with_error(MYSQL *con)
{
  fprintf(stderr, "%s\n", mysql_error(con));
  mysql_close(con);
  exit(1);
}

int main(int argc, char **argv)
{
  MYSQL *con = mysql_init(NULL);

  if (con == NULL)
  {
      fprintf(stderr, "%s\n", mysql_error(con));
      exit(1);
  }

  if (mysql_real_connect(con, "192.168.0.204", "proxysql", "proxypassword",
    "testdb", 0, NULL, 0) == NULL)
  {
      finish_with_error(con);
  }
    
  if (mysql_query(con, "DROP TABLE IF EXISTS cars;")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "DROP TABLE IF EXISTS people;")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "CREATE TABLE cars(id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255), price INT)")) {
      finish_with_error(con);
  }    
  if (mysql_query(con, "CREATE TABLE people(id INT, name VARCHAR(255), car_id INT)")) {
      finish_with_error(con);
  }    
  if (mysql_query(con, "INSERT INTO cars VALUES(1,'Audi',52642)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(2,'Mercedes',57127)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(3,'Skoda',9000)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(4,'Volvo',29000)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(5,'Bentley',350000)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(6,'Citroen',21000)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(7,'Hummer',41400)")) {
      finish_with_error(con);
  }
  if (mysql_query(con, "INSERT INTO cars VALUES(8,'Volkswagen',21600)")) {
      finish_with_error(con);
  }    
  if (mysql_query(con, "INSERT INTO people VALUES(1,'Jim',7)")) {
      finish_with_error(con);
  }  
  if (mysql_query(con, "INSERT INTO people VALUES(1,'Jim',8)")) {
      finish_with_error(con);
  }    
  if (mysql_query(con, "INSERT INTO people VALUES(2,'Tom',6)")) {
      finish_with_error(con);
  }
  
  if (mysql_query(con, "SELECT * FROM cars"))
  {
      finish_with_error(con);
  }
  MYSQL_RES *result = mysql_store_result(con);
  if (result == NULL)
  {
      finish_with_error(con);
  }
  int num_fields = mysql_num_fields(result);
  MYSQL_ROW row;
  while ((row = mysql_fetch_row(result)))
  {
      for(int i = 0; i < num_fields; i++)
      {
    printf("%s ", row[i] ? row[i] : "NULL");
      }

      printf("\n");
  }
  mysql_free_result(result);
  
  if (mysql_query(con, "update cars set price = 42400 where name = 'Hummer'")) {
      finish_with_error(con);
  }   
  
  if (mysql_query(con, "SELECT people.name,cars.name,cars.price FROM cars,people where cars.id = people.car_id"))
  {
      finish_with_error(con);
  }
  result = mysql_store_result(con);
  if (result == NULL)
  {
      finish_with_error(con);
  }
  num_fields = mysql_num_fields(result);
  while ((row = mysql_fetch_row(result)))
  {
      for(int i = 0; i < num_fields; i++)
      {
    printf("%s ", row[i] ? row[i] : "NULL");
      }

      printf("\n");
  }  
  mysql_free_result(result);
  
  if (mysql_query(con, "delete from people where id = 1")) {
      finish_with_error(con);
  }
  
  if (mysql_query(con, "drop table people;")) {
      finish_with_error(con);
  }  
  if (mysql_query(con, "drop table cars;")) {
      finish_with_error(con);
  }  
    
  mysql_close(con);
  exit(0);
}

编译并执行：

1
2
gcc testdb.c -o testdb  `mysql_config --cflags --libs`
./testdb

输出如下：

1
2
3
4
5
6
7
8
9
10
11
1 Audi 52642
2 Mercedes 57127
3 Skoda 9000
4 Volvo 29000
5 Bentley 350000
6 Citroen 21000
7 Hummer 41400
8 Volkswagen 21600
Jim Hummer 42400
Jim Volkswagen 21600
Tom Citroen 21000

根据以上测试可以发现，C语言连接MariaDB数据库，增删改查，创建表，删除表，等各项功能在arm64平台上都正常。

以上测试只是演示了从OS的软件源安装MariaDB的Connector，你如果想用最新版本的Connector，也可以参考官方文档，编译一个最新版本的: https://mariadb.com/kb/en/mariadb-connector-c/

另外MariaDB的C连接器项目是LGPL的License发布的，以动态链接库的方式链接，可以放心使用。

Java

首先要确保在测试虚拟机上已经安装了最新版本的OpenJDK和Maven。

用Maven创建一个样例项目：

1
2
mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app 
-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

然后在生成的pom.xml中的dependencies模块，添加如下内容：

1
2
3
4
5
<dependency>
    <groupId>org.mariadb.jdbc</groupId>
    <artifactId>mariadb-java-client</artifactId>
    <version>2.7.0</version>
</dependency>

然后编辑src/main/java/com/mycompany/app目录下的App.java文件，内容如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.mycompany.app;

import java.sql.*;

public class App {

  public static void main( String[] args ) throws SQLException {
    try (Connection conn = DriverManager.getConnection("jdbc:mariadb://192.168.0.204/", "proxysql", "proxypassword")) {
      // create a Statement
      try (Statement stmt = conn.createStatement()) {
        //execute query
        try (ResultSet rs = stmt.executeQuery("SELECT 'Hello World!'")) {
          //position result to first
          rs.first();
          System.out.println(rs.getString(1)); //result is "Hello World!"
        }
      }
    }
  }
}

然后执行如下命令编译

1
mvn install

执行如下命令执行

1
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"

输出Hello Word!代表正常

上面仅仅是测试了比较简单的功能，下面我们测试下连接池功能，并执行下增删改查等功能。

修改App.java的内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.mycompany.app;

import java.sql.*;

public class App {

  public static void main( String[] args ) throws SQLException {
    //option "pool" must be set to indicate that pool has to be used
    String connectionString = "jdbc:mariadb://192.168.0.204/testdb?user=proxysql&password=proxypassword&maxPoolSize=10&pool";

    try (Connection connection = DriverManager.getConnection(connectionString)) {
      try (Statement stmt = connection.createStatement()) {
        ResultSet rs = stmt.executeQuery("DROP TABLE IF EXISTS cars;");
        stmt.executeQuery("CREATE TABLE cars(id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255), price INT)");
        stmt.executeQuery("INSERT INTO cars VALUES(1,'Audi',52642)");
        stmt.executeQuery("INSERT INTO cars VALUES(2,'Mercedes',57127)");
        rs = stmt.executeQuery("SELECT * FROM cars");
        rs.next();
        System.out.println(rs.getString(2));
      }
    }

    try (Connection connection = DriverManager.getConnection(connectionString)) {
      try (Statement stmt = connection.createStatement()) {
        stmt.executeQuery("update cars set name = 'VolksWagen' where id = 1");
        stmt.executeQuery("delete from cars where id = 2");
        ResultSet rs = stmt.executeQuery("SELECT * FROM cars");
        rs.next();
        System.out.println(rs.getString(2));
      }
    }
  }
}

编译并执行，成功输出

1
2
Audi
VolksWagen

经过以上测试，连接池功能和增删改查功能也都正常。

Java的连接器功能比较丰富，还实现了对集群或者主从数据库的负载均衡或者读写分离功能。接下来我们测试下读写分离功能。 在此之前请确保已经搭建好了MariaDB的主从数据库环境。

将App.java的代码改成如下所示，注意jdbc连接串里面增加了replication关键字，代表主从复制，如果是其他负载均衡环境，也支持loadbalance等关键字，具体参考MariaDB官方文档。另外也注意下连接串中，主数据库地址在前，从数据库地址在后。当connection的属性改成了ReadOnly之后，语句就会到备库去查询了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.mycompany.app;

import java.sql.*;

public class App {

    public static void main( String[] args ) throws SQLException {
        String connectionString = "jdbc:mysql:replication://192.168.0.204,192.168.0.64/testdb?user=proxysql&password=proxypassword&maxPoolSize=10&pool";
    
        try (Connection connection = DriverManager.getConnection(connectionString)) {
            try (Statement stmt = connection.createStatement()) {
                stmt.executeQuery("INSERT INTO cars VALUES(2,'Mercedes',57127)");
                connection.setReadOnly(true);
                ResultSet rs = stmt.executeQuery("SELECT * FROM cars");
                rs.next();
                System.out.println(rs.getString(2));
            }
        }
    }
}

编译并执行，输出如下

1
VolksWagen

执行成功。

以上都是以Maven为例演示的相关功能，如果没使用Maven，也可以参考MariaDB官方文档里面的其他工具的指导：https://mariadb.com/kb/en/mariadb-connector-j/

MariaDB Java连接器也是以LGPL协议发布的，可以放心使用。

Python

首先确保测试虚拟机上已经安装好了Python3和pip3。

在Python里面连接MariaDB需要先安装C语言的连接器，可以执行如下命令安装

1
apt install libmariadb-dev

不过当前Ubuntu18.04的版本自带的mariadb的包版本较老，不能满足python的版本要求，我们从源码编译一个。

执行如下命令下载连接器源码，并解压

1
2
wget https://downloads.mariadb.org/interstitial/connector-c-3.1.11/mariadb-connector-c-3.1.11-src.zip
unzip mariadb-connector-c-3.1.11-src.zip

开始编译

新建一个单独的编译目录，在这个目录下进行编译，并安装

1
2
3
4
5
6
7
mkdir build-mariadb-connector-c
cd build-mariadb-connector-c
cmake ../mariadb-connector-c-3.1.11-src -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local
make
make install
echo "/usr/local/lib/mariadb/" > /etc/ld.so.conf.d/mariadb.conf
ldconfig

然后执行如下命令安装Python的连接器：

1
pip3 install mariadb

接下来我们直接测试一下连接池功能，并简单测试下查询和新增的功能。

编辑如下代码，命名为testmariadb.py文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import mariadb

pool = mariadb.ConnectionPool(
        user="proxysql",
        password="proxypassword",
        host="192.168.0.204",
        port=3306,
        pool_name="web-app",
        pool_size=20
        )

try:
    pconn = pool.get_connection()
    cur = pconn.cursor()
    data = [(3, 'Skoda', 9000),(4, 'Volvo', 29000),(5, 'Bently', 350000)]
    cur.executemany("INSERT INTO testdb.cars(id, name, price) VALUES (?, ?, ?)", data)
    cur.execute("select * from testdb.cars")
    cars = []
    for (id,name,price) in cur:
        cars.append(f"{id} {name} {price}")
    print("\n".join(cars))
except mariadb.PoolError as e:
    # Report Error
    print(f"Error opening connection from pool: {e}")

执行

1
python3 testmariadb.py

输出如下

1
2
3
4
5
1 VolksWagen 52642
2 Mercedes 57127
3 Skoda 9000
4 Volvo 29000
5 Bently 350000

说明成功执行。

关于Python连接器的其他功能，可以参考如下链接：https://mariadb.com/docs/appdev/connector-python/

Python连接器也是LGPL协议，可以放心使用。

Node.js

我们首先要先安装nodejs和npm， mariadb连接器要求至少nodejs为10.13以上版本，所以我们从官网下载一个arm64的二进制包，手动安装下

1
2
3
4
5
6
wget https://nodejs.org/dist/v14.15.0/node-v14.15.0-linux-arm64.tar.xz
xz -d node-v14.15.0-linux-arm64.tar.xz
tar -xf node-v14.15.0-linux-arm64.tar
cd node-v14.15.0-linux-arm64/bin
sudo ln -s `pwd`/node /usr/local/bin/
sudo ln -s `pwd`/npm /usr/local/bin/

然后安装mariadb连接器

1
sudo npm install mariadb

然后编辑一个testmariadb.js文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const mariadb = require('mariadb');
const pool = mariadb.createPool({
     host:'192.168.0.204',
     user:'proxysql',
     password: 'proxypassword',
     connectionLimit: 5
});
async function asyncFunction() {
  let conn;
  try {
    conn = await pool.getConnection();
    const res = await conn.query("INSERT INTO testdb.cars value (?, ?, ?)", [6,'Citroen',21000]);
    console.log(res);
    const rows = await conn.query("SELECT * from testdb.cars");
    console.log(rows);

  } catch (err) {
    throw err;
  } finally {
    if (conn) return conn.end();
  }
}
asyncFunction();

然后执行

1
node testmariadb.js

输出如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
OkPacket { affectedRows: 1, insertId: 6, warningStatus: 0 }
[
  { id: 1, name: 'VolksWagen', price: 52642 },
  { id: 2, name: 'Mercedes', price: 57127 },
  { id: 3, name: 'Skoda', price: 9000 },
  { id: 4, name: 'Volvo', price: 29000 },
  { id: 5, name: 'Bently', price: 350000 },
  { id: 6, name: 'Citroen', price: 21000 },
  meta: [
    ColumnDef {
      _parse: [StringParser],
      collation: [Collation],
      columnLength: 11,
      columnType: 3,
      flags: 16899,
      scale: 0,
      type: 'LONG'
    },
    ColumnDef {
      _parse: [StringParser],
      collation: [Collation],
      columnLength: 1020,
      columnType: 253,
      flags: 0,
      scale: 0,
      type: 'VAR_STRING'
    },
    ColumnDef {
      _parse: [StringParser],
      collation: [Collation],
      columnLength: 11,
      columnType: 3,
      flags: 0,
      scale: 0,
      type: 'LONG'
    }
  ]
]

MariaDB Node.js的连接器也是用的LGPL协议，可以放心使用。

关于Node.js连接器的其他信息，请参考：https://mariadb.com/kb/en/nodejs-connector/

PHP

PHP连接MariaDB和连接Mysql的代码是一样的。

首先在测试机上安装php和mysql驱动：

1
2
sudo apt install php
sudo apt install php-mysql

然后编辑一个testmariadb.php文件

1
2
3
4
5
6
7
<?php
$mysqli = new mysqli("192.168.0.204", "proxysql", "proxypassword", "testdb");
$mysqli->query("insert into cars values(7,'Hummer',41400)");
$result = $mysqli->query("SELECT * FROM cars where id = 7");
$row = $result->fetch_assoc();
echo htmlentities($row['name']);
?>

执行：

1
php testmariadb.php

输出

1
Hummer

对于PHP，我们仅测试了插入和查询两个简单的场景，证明PHP在arm64平台上连接MariaDB数据库可行。关于PHP连接mysql和mariadb数据库的其他信息，可以参考如下链接：

https://www.php.net/manual/en/mysql.php

Go

Go语言连接MariaDB数据库和连接Mysql数据库也是一样的。

首先安装Go语言的Mysql驱动, （这个驱动的协议是MPL2.0，也是一个比较宽松的协议）

1
go get -u github.com/go-sql-driver/mysql

编辑testmariadb.go文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package main

import "fmt"
import "strings"
import "database/sql"
import _ "github.com/go-sql-driver/mysql"

func main() {
    const (
        userName = "proxysql"
        password = "proxypassword"
        ip = "192.168.0.204"
        port = "3306"
        dbName = "testdb"
    )
    //Db数据库连接池
    var DB *sql.DB
    path := strings.Join([]string{userName, ":", password, "@tcp(",ip, ":", port, ")/", dbName, "?charset=utf8"}, "")

    //打开数据库,前者是驱动名，所以要导入： _ "github.com/go-sql-driver/mysql"
    DB, _ = sql.Open("mysql", path)
    //设置数据库最大连接数
    DB.SetConnMaxLifetime(100)
    //设置上数据库最大闲置连接数
    DB.SetMaxIdleConns(10)
    //验证连接
    if err := DB.Ping(); err != nil{
        fmt.Println("open database fail")
        return
    }
    fmt.Println("connnect success")
    //开启事务
    tx, err := DB.Begin()
    if err != nil{
        fmt.Println("tx fail")
        return
    }
    //准备sql语句
    stmt, err := tx.Prepare("INSERT INTO cars VALUES (?,?,?)")
    if err != nil{
        fmt.Println("Prepare fail")
        return
    }
    //将参数传递到sql语句中并且执行
    res, err := stmt.Exec(8, "Mercedes", 57127)
    if err != nil{
        fmt.Println("Exec fail")
        return
    }
    //将事务提交
    tx.Commit()
    fmt.Println(res.LastInsertId())

    rows, err := DB.Query("SELECT * from cars")
    if err != nil{
        fmt.Println("query fail")
    }    
    //循环读取结果
    for rows.Next(){
        var id int
        var name string
        var price int
        err := rows.Scan(&id, &name, &price)
        if err != nil {
            fmt.Println("rows fail")
        }
        fmt.Printf("%v %q %v \n", id, name, price)
    }
}

然后执行

1
go run testmariadb.go

输出如下：

1
2
3
4
5
6
7
8
9
10
connnect success
8 <nil>
1 "VolksWagen" 52642
2 "Mercedes" 57127
3 "Skoda" 9000
4 "Volvo" 29000
5 "Bently" 350000
6 "Citroen" 21000
7 "Hummer" 41400
8 "Mercedes" 57127

上面我们测试了Go语言的MariaDB连接器的连接池，查询，事务，插入等功能，都是成功的。 关于其他功能，大家可以参考go语言的官网或者其他相关网站。

Rust

Rust连接MariaDB的方式和连接Mysql也是一样的。

首先安装最新版本的Rust：

1
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

安装完后，需要将$HOME/.cargo/bin添加到PATH环境变量里

对于当前环境，我们执行如下命令先临时生效：

1
source $HOME/.cargo/env

然后执行如下命令，创建一个新工程：

1
cargo new mariadb_test

然后

1
cd mariadb_test

编辑Cargo.toml配置文件，在[dependencies]下面添加如下内容, 设置驱动的版本：

1
mysql = "20.0.1"

然后编辑src/main.rs文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
use mysql::*;
use mysql::prelude::*;

#[derive(Debug, PartialEq, Eq)]
struct Car {
    id: i32,
    name: String,
    price: i32,
}

fn testmariadb() -> std::result::Result<std::string::String, mysql::Error> {
    let url = "mysql://proxysql:proxypassword@192.168.0.204:3306/testdb";

    let pool = Pool::new(url)?;
    
    let mut conn = pool.get_conn()?;
    
    conn.exec_drop(r"delete from cars",())?;
    
    let cars = vec![
        Car { id: 1, name: "Audi".into(), price: 52642 },
        Car { id: 2, name: "Volkswagen".into(), price: 21600 },
        Car { id: 3, name: "Skoda".into(), price: 9000 },
    ];
    conn.exec_batch(
        r"INSERT INTO cars (id, name, price)
      VALUES (:id, :name, :price)",
      cars.iter().map(|p| params! {
          "id" => p.id,
          "name" => &p.name,
          "price" => p.price,
      })
      )?;
    
    let selected_cars = conn
        .query_map(
            "SELECT id, name, price from cars",
            |(id, name, price)| {
                Car { id, name, price }
            },
            )?;
    assert_eq!(cars, selected_cars);
    println!("Yay!");
    Ok("Yay!".into())

}

fn main() {
    testmariadb();
}

我们测试了连接池功能，还测试了，删除，插入，查询等功能，在一个批量的查询之后，将查询出来的结果放到一个列表里面，和插入之前的数据列表进行对比，如果相等，则打印Yay!

在mariadb_test目录下，执行如下命令编译加运行

1
cargo run

如果执行因为update crates.io-index超时，需要更改一下下载地址，进行如下配置

编辑文件: vi $HOME/.cargo/config

输入如下内容，保存退出。

1
2
3
4
5
[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
replace-with = 'ustc'
[source.ustc]
registry = "git://mirrors.ustc.edu.cn/crates.io-index"

然后重新cargo run

输出Yay!，成功运行。

关于Rust Mysql连接器的其他功能，请参考：

https://docs.rs/mysql/20.0.1/mysql/

另外Rust还有一个比较新的异步连接器，具体可以参考下面这两个链接：

https://docs.rs/mysql_async/0.25.0/mysql_async/

https://github.com/blackbeam/mysql_async

Rust的连接器使用的都是MIT/Apache2.0协议，这两个都是比较宽松的协议。

总结

我们测试了C，Java，Node.js， Python，PHP，Go，Rust多种主流语言，都可以在arm64平台上成功的连接MariaDB数据库，而且用法和x86平台都是一样的。而且各个语言连接器的开源协议也都比较宽松。

参考链接：

http://zetcode.com/db/mysqlc/

https://mariadb.com/kb/en/mariadb-connector-c/

https://mariadb.com/kb/en/mariadb-connector-j/

https://mariadb.com/docs/appdev/connector-python/

https://mariadb.com/kb/en/nodejs-connector/

https://www.php.net/manual/en/mysql.php

https://www.jianshu.com/p/ee87e989f149

https://golang.org/pkg/database/sql

https://github.com/go-sql-driver/mysql

https://doc.rust-lang.org/book/title-page.html

https://docs.rs/mysql/20.0.1/mysql/

https://docs.rs/mysql_async/0.25.0/mysql_async/

https://github.com/blackbeam/mysql_async

#
在arm64平台上监控MariaDB数据库的性能和运行情况
Mysql Innodb cluster on ARM64概述

Comments

Follow

Links

Categories

Tags

Java 1
Packaging 1
Web 4
会议 1
基础库 6
大数据 2
数据库 42
虚拟化 3

Categories

Tags

Java 1
Packaging 1
Web 4
会议 1
基础库 6
大数据 2
数据库 42
虚拟化 3
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×