cncml手绘网
标题:
rust连接mysql数据库_DLang、Rust 以及 Golang 对比数据库操作方式
[打印本页]
作者:
admin
时间:
2022-10-26 00:48
标题:
rust连接mysql数据库_DLang、Rust 以及 Golang 对比数据库操作方式
我们使用 DLang / Rust / Golang 在服务端开发的时候对数据库操作是家常便饭,而对于所谓的系统级编译型语言来说操作数据库可能没那么方便,不像 PHP 和 JAVA 那样,对于比较新的三个编译型语言我们来看看效果,刚好这三个语言的语法差异比较大。
' y1 \" _- P3 d+ x
8 {5 |6 ~- s7 W) |+ e) A5 ?5 p# _
一、数据插入 - INSERT
" S5 B r o/ d8 y2 k. S3 j) `; T
: u Y H# ~3 {/ z& y7 u1 h
1.1 : DLang 插入数据
; D. a b: E- ^" V7 [3 i4 \- ]
) I! V( d5 p6 E9 ]2 }' y1 J
import std.stdio;
4 n, t& s4 O7 S m
t4 z! i5 R: E" R& k7 g n
import hunt.database;
& A( T7 G5 b2 l6 g# |
- v5 K; f- I& E5 y* `' ]5 y
void main()
4 }$ p+ _1 r- N6 b/ m0 Y
7 v& G$ p. ^: z# F8 R* _7 ^& w! C [
{
6 H% m- P2 Q4 L+ g( R7 b
. V; h4 T8 s7 F3 T* `/ g
auto db = new Database("mysql://root:123456@localhost:3306/test?charset=utf8mb4");
5 _1 L. u; l% n5 z( ? k
( K* y7 j+ d1 g
int result = db.execute(`INSERT INTO user(username) VALUES("test")`);
) c9 ^( ]( E3 B7 \/ G
! R4 Y" C) B' E4 E- v
// 打印插入数量
9 j6 d* j& V/ g
R* \3 c) Q. V& @: D" `. Z: r' a" e
writeln(result);
( l) U; G6 Z/ D/ I
! G- i/ |; |! C1 W9 Y& N9 B/ X7 c. g
db.close();
5 D( M( ]. v) D) K% m3 F
+ T7 D2 c" f+ r5 R5 _# d9 [' G( y
}
! j% |' k9 ?& G2 o# g- J
: I! ], v" E y S
1.2 : Rust 插入数据
6 ^' R" @* @2 E
* v9 ]- T% @) g/ h* z7 A. h
extern crate postgres;
( J: Q' e% b" u# d1 d& L; P. t8 |% Q
$ @; @( j" }# ~0 L
use postgres::{Connection, SslMode};
3 Y1 j5 m/ [) o
) A* P7 k7 f3 l) B
fn main() {
% L2 r5 W+ F% \5 }
7 F9 \- b% B) J' v; \1 x1 y! d
let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
; `7 ]9 Z9 H( z
# U. u( v8 V* _6 s
conn.execute("INSERT INTO user (username) VALUES (\"test\")", &[]).unwrap();
% x- {- w' c* ~0 G
y- `3 h+ d6 D3 H d. i
}
! K" N9 l7 m+ `- M0 u
* K0 }. f: c: t8 v4 }* c
1.3 : Golang 插入数据
7 x# J* q2 A4 F4 m; [. s, q2 y8 v0 p) C [
; k+ g" h0 K8 M& X. A
import (
+ f- H! W, B5 y A$ x' @8 v
9 y$ `9 g4 I7 W- r
"database/sql"
n8 N, x( B2 _, g; H: Y" H4 j
4 j' ?" h/ h) r# _, }* [/ ]9 |
"fmt"
$ T$ w& p. K3 P; R6 |* c+ \0 _
, e% O( o, R: }" H; X+ V7 K
_ "github.com/lib/pq"
, @8 J: w* r. |6 M
' c% T$ {+ E% m! ]* C g3 D
"time"
& V$ ]: j6 u2 e* r- y
7 L9 W7 P! D6 `
"log"
; M: c T7 @* Z. p
7 E R- m2 o$ O6 L( E! ^3 l9 W
)
# v9 q+ u6 P; M; X, r9 L: H
" P$ B5 {$ A: P
func main() {
6 ]. V& F3 m% _' H
: p, k) u6 u; w8 I+ b1 H: w. o
db, err := sql.Open("postgres", "user=portgres password=123456 dbname=test sslmode=disable")
' H/ R _/ J. m) G+ O" }
$ e: k, B' n+ V8 q' z' T6 D
if err != nil {
% k) P0 E% u( z: D
# `6 k, A. V; L; L1 X
log.Fatal(err)
2 k( A7 f8 i- Y
% s2 C- \ }/ Q% V6 [1 g1 S' H$ G
return nil
' M J, ?2 w5 u, f0 F6 y
* Q5 f. o0 M7 P; X M
}
5 D4 c7 z; s% [' {2 v
; o* t, g$ d' _' [
stmt := db.Prepare("INSERT INTO user (username) VALUES (\"test\")")
- h4 j% F0 _/ ^# p1 j4 |. u
" F+ A( d7 R5 _0 n
stmt.Exec()
" z0 M) n1 V9 H- A( r1 S
O1 E$ i: J! O! ^2 A
stmt.Close()
5 j8 N$ {9 I" r5 D8 {* v
7 g2 R- @- M: S# f
}
6 K# K9 L% w# J! _- h' x
$ h- B1 j: s( W# g$ J7 r
二、数据查询 - SELECT
2 ^9 n' V1 \# Y) [- m
. a2 T0 g- d" e( {5 @
2.1 : DLang 查询数据
+ C% ^! T* I r' J- I( B* x
" I8 u9 p. K( A/ ?
import std.stdio;
5 E: l& Q; W; ~" x! [
- ]9 }3 j& n* A, ]1 M3 q
import hunt.database;
5 ^+ ?, L; Z- H
' R" D8 ?) b( e
void main()
! v) H: n& |) C
5 ^; @. S+ D6 ]0 R$ @6 |" ~
{
- q# n6 b" u& |, [0 U
# }% e! ? g$ L' K. u
auto db = new Database("mysql://root:123456@localhost:3306/test?charset=utf8mb4");
' a/ t! F2 S- i- W
- K- N! z+ i2 k9 A* M5 J
foreach(row; db.query("SELECT * FROM user LIMIT 10"))
% j$ ?# I2 D. _2 V
/ G' C$ v+ X e
{
]0 t K" g* r
1 Q- c+ {0 w- y7 M7 t' B' J. r2 P
writeln(row["username"]);
8 {1 m. a9 R/ R. s
& T; M4 ~/ Z+ L) I% E; ]/ L
}
6 C6 h8 M% l; l2 K9 C1 x* G
" L. M' k' v, K9 \2 j0 H+ x
db.close();
' `( H$ N" u2 Q+ U4 _- d5 c
8 L, _) m/ }' ]1 R4 g. Q+ Z" Z
}
8 Y' p4 n) P2 m' g* l. k
+ ]5 Y8 Z$ p" p/ A( l
2.2 : Rust 查询数据
# [5 F+ j. [ |& t% g0 o b& W7 g
9 B- B/ f0 Y2 c: X0 V. ~! W
extern crate postgres;
4 O5 M- i8 k$ j9 P% m" d
! S5 l& M l3 [
use postgres::{Connection, SslMode};
! r! O- Z2 S" d- T+ d
1 k' ~' j" U: ?3 d5 p6 r
fn main() {
: I0 @5 |6 s2 @. f
9 K* y3 Y2 n" W) u' ]" c
let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
" a. ^2 t7 p) V$ s
7 f$ T) ]& r* O. }7 ~$ O
for row in &conn.query("SELECT * FROM user", &[]).unwrap();
: b0 W r0 D# L$ R
% h, d- h6 I0 Y8 X1 O4 r; K
println!("Found person {}", row.get(0));
3 }5 F6 S8 T% O: R( y$ Y
b2 X. Y+ o+ F( G8 w! Q
}
. J) u2 [/ q/ V# \
" C/ F8 ^8 o- |& R, D- A
}
& R1 X$ V/ c9 Y2 N1 Z5 W$ Q
' q% ~/ ?5 _- n! t5 p( v
2.3 : Golang 查询数据
1 q; R! b. Z3 v9 T! k7 Q O @& K/ ?
' `8 O) G. R6 {3 A4 @; [6 V, {
import (
: L; ~1 M$ D( ?0 f
, o7 h: _- l1 e1 u
"database/sql"
% \/ U0 B9 a, I! N" x
; h5 x$ `" k6 @
"fmt"
2 O$ f- \0 M& Y9 k
/ t: h k' r) N0 o4 `
_ "github.com/lib/pq"
% ~% h, ]1 f8 E+ @) N
6 E* }3 l8 y: b+ H9 i( h
"time"
N: Y Y# q4 \( P, A- }
* c7 W w# X0 W( i9 L
"log"
! }; S6 @- ~+ h& y% M
4 N2 \6 S8 O+ ?
)
/ M1 `- I' {5 S! P. z
G/ N3 Z9 r' }* K+ `
type User struct {
% S8 T0 R6 z* o* c/ K7 s! s
, D4 ]( q3 E' G! p
UserName string
) x& D- {' a% q F0 c- U
# P5 d4 i ], R6 S( R; _& p, @8 N
}
. F5 p2 Z j. f/ g5 D
8 n2 f7 \- `+ B& i- n
func main() {
( x0 j0 H9 o$ p# _
1 G) t5 c. C6 V& V# r6 j
db, err := sql.Open("postgres", "user=portgres password=123456 dbname=test sslmode=disable")
" ~& ^1 q+ ^, M1 @9 v
! _2 ~; J$ H5 c& g
if err != nil {
, E c/ {: Y5 z w ^8 h
# f% v: ~& P; h9 f
log.Fatal(err)
o7 u4 V$ n% `% |
, I! _- H: X1 }5 Z9 {( H; z- |: h
return nil
F" }4 B* B( e1 {# E, U8 p0 R
- P, `( S+ V( {
}
; m2 d+ R) E$ o. V
3 d- {" t: P; Q9 F
user := User{}
7 O6 j% g) }5 I/ R
. f! `; D6 s2 D& G+ @
stmt := db.Query("SELECT * FROM user")
" N7 `! m0 G. W8 s
* o- M8 x1 x7 ?3 i
for rows.Next() {
! P9 E! y* K2 x! S }0 @' ~
5 K) s# ?3 Q( j6 S" P! P$ O
rows.Scan(&user.UserName)
8 }1 d( t0 V6 ^- v: j
7 [$ Q& z' v$ e
fmt.Println(user.UserName)
0 o4 x+ E8 j. K9 r& g
6 w, b, k* X+ e# K. Z! Z
}
5 Y1 N: N2 {5 C- q k
! a7 @, J! T- q: I
stmt.Close()
: ]* i- t5 G5 M5 J* E
# [' h: e. @+ u5 W! {; R
}
, K0 h1 Z! I$ `& e& G4 |3 K
/ h4 i& f0 e& B
三、总结
+ E' W7 ?+ `, `7 r: U$ o
K% d1 F6 X% k" [2 j' |. O
对于操作数据库来说静态类型语言的确不是很容易操作,类似 C++ 这么多年还没有相对容易使用的数据库操作的 library,但无论 Dlang / Rust 和 Golang 都能比较全面的操作数据库。
1 s0 j* o! O1 K: w8 c4 b; w2 \" _
7 q( V, a" _2 ^# r8 d8 u
这三个语言的语法还有比较大的差异,DLang 语法可读性比较好(的确简单的像PHP一样方便了),Rust 相对来说操作符会多一些,而 golang 在执行 SELECT 之后需要创建对象绑定,不支持字段作为 key 的操作形式?(可能是我功课没做好)
& M, N; e9 ?$ n0 b( X4 i2 k
3 b$ K3 s) J9 e) ?+ J: f6 i
在包引入方面 Dlang 最简单,Rust 相对来说颗粒度控制的更细,而 Golang 相对繁琐一些,需要几个包同时引入才可以操作数据库;相对 Rust 和 Golang 来说 Dlang 可以更方便的切换不同数据库而不需要修改业务逻辑代码。
+ W$ S* K( c/ ]: _/ j0 Y( e9 F9 T
" |# g2 a; z. K5 H/ n
总而言之系统级语言在服务端的应用日益增多,更多有意思的对比还需要大家一起来挖掘,不要沉浸在单一的脚本语言如 PHP、虚拟机语言 JAVA 和 C#,多多学习,现在语言的学习成本已经非常低,我们应该在不同的应用场景使用更适合的开发语言。
3 T4 D I2 K. }2 I/ K5 K" I
————————————————
7 y- y+ i# t. [% C, _# Z" p
版权声明:本文为CSDN博主「游戏葡萄」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
' t& X7 ` d3 ~
原文链接:
https://blog.csdn.net/weixin_30713705/article/details/113633961
: z0 C$ n) A) n
4 t5 k T' \" Q4 g/ F
欢迎光临 cncml手绘网 (http://bbs.cncml.com/)
Powered by Discuz! X3.2