管理员
   
论坛积分
分
威望 点
贡献值 个
金币 枚
|
我们使用 DLang / Rust / Golang 在服务端开发的时候对数据库操作是家常便饭,而对于所谓的系统级编译型语言来说操作数据库可能没那么方便,不像 PHP 和 JAVA 那样,对于比较新的三个编译型语言我们来看看效果,刚好这三个语言的语法差异比较大。7 x* r2 K1 c/ p% }5 c
+ V9 Q% `+ U/ k% I
一、数据插入 - INSERT" K; r: X5 @+ U L. k
( V, Z% |) K: q, t2 h" S- X1.1 : DLang 插入数据( h1 g! `5 @! T" }7 y% U8 ~6 J6 q
2 w9 C, Z; P `import std.stdio;
) Z, [6 e! ?2 o! H
L5 ]# Y! ]* T0 p6 h3 `import hunt.database;
; M2 i" d! y4 e7 x7 B
S: u4 T$ q/ {, \void main()
2 H+ {, ^0 p( k0 n: u" @- @
$ r6 ?8 g% u: e% F: j) k! e' N{
# X8 @) J8 q5 d. X) q
/ J. h7 U3 x- B! B wauto db = new Database("mysql://root:123456@localhost:3306/test?charset=utf8mb4");- b0 z0 J1 J0 x/ s5 C- M j
# F2 }4 \' A2 B3 r, H3 ^8 L+ b1 Nint result = db.execute(`INSERT INTO user(username) VALUES("test")`); o& {- K3 w7 ]& u8 c( ]4 s
4 |. W! q; O* c' W( e// 打印插入数量
! m, J+ L2 C* s# w: D1 T* I1 A7 T. @3 Z5 p& L% d' P [
writeln(result);& Y2 A( z3 X) j
$ d5 l# e( M! N* ? }
db.close();
" P0 }$ [4 D5 Y7 U' @
# S: r d6 s; y" v2 f5 x8 S% L}
8 j8 K; A7 a7 Z8 K3 Z0 X1 }; X2 ^( J; S3 |3 @) x0 g
1.2 : Rust 插入数据6 m6 L. w; j8 C5 u5 }. _/ O" |
6 o0 B& R" F" B. e' i3 @
extern crate postgres;
0 \3 s+ B4 {6 B2 r6 Q
9 f" S" N( B ]0 P) |use postgres::{Connection, SslMode};5 h" w! @- ?9 R3 ]5 a8 X- p. y7 k k
* Y% J! A- x) ?' nfn main() {
5 @ Z! T, P) m5 Q" \2 Z+ `7 t; d$ I B! F& _
let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
! A7 V# K: t2 R8 J$ U4 ` m6 W/ b. X1 e/ N+ V1 J( |$ `
conn.execute("INSERT INTO user (username) VALUES (\"test\")", &[]).unwrap();2 R+ z4 I3 H4 _. e p7 [( j$ t
4 p, v- r& M$ v, H8 K9 u' C
}' A1 t) T/ J- [% T: y
6 \; M; Y& e o/ B) n8 n2 L1.3 : Golang 插入数据
, y: @& i- J& z. L
, Y w K) T+ }' a2 r/ fimport (. G) u' m- r1 {1 _# |0 z N9 q
, B4 \$ N9 m2 [1 T' E% F8 h
"database/sql"# A& E- w4 C# }( @) q4 D. b/ H$ B
4 n$ n% {3 B& u1 B$ i* P' {* O"fmt"
; d# b( V1 A: B% W$ Y. T4 z3 }8 y" K' @0 _8 ^
_ "github.com/lib/pq"
" P& D5 D% \( ?* \ P( d
% T( ^' H* [ a; R9 q+ z i"time"
+ E+ l( u) b# X# q0 ?
+ X8 J1 ]" [7 c, y8 _- d* ?"log"
9 j7 q# q& _6 I" k# u9 z6 u7 f! M
)+ _ e$ _8 ]/ v/ h4 `. V6 s8 J5 ?
) c" k4 q- t8 S0 F+ f- ^7 G
func main() {
7 A( C* A- a9 T2 }4 k$ _- v! e7 t! \ r6 [
db, err := sql.Open("postgres", "user=portgres password=123456 dbname=test sslmode=disable")5 F2 K8 s5 x+ i/ H) G
8 C, t9 U1 r; g4 M2 Y9 J' w- U! t9 Kif err != nil {9 x6 x+ |, X; J% r5 r. Q% A* U+ R
$ @: H' o2 v* r
log.Fatal(err)
8 T% U/ _& Y% h9 y4 D* k: H( t) p3 m- |- p* m9 F3 N
return nil
3 c, P9 G' Q% Z* z& f/ c" N$ J3 |' ^& r( q1 }: R" ]: E
}# c" s. [( c- K
2 Z9 M, T* E. \& b# t* i- Rstmt := db.Prepare("INSERT INTO user (username) VALUES (\"test\")")
- W0 s2 d1 j% T [) M
$ _3 ]: [, U, Xstmt.Exec() n- W2 ~8 k, a
+ v5 f6 e2 I& m$ E: q/ U6 S1 t
stmt.Close()% X0 ?% y% U1 F; G/ T" `
" x% U5 i$ M" m! H X4 [' E0 W
}* o6 S9 b1 U2 W* r8 d
/ h; J, M- X9 I3 `+ x4 F二、数据查询 - SELECT* T. O2 | V: [" {: P" V
9 a+ p P3 x: D9 d4 y2.1 : DLang 查询数据! T% G. Y3 F# t. s, v+ M0 \
. X8 {9 c9 `1 _: \. q
import std.stdio;* J- T" H; _4 U% E' y' e9 y1 z
; M1 @; b; V8 D$ e' K
import hunt.database;
# c* B% s5 T; J
$ b D6 o/ t2 B1 @0 l* u3 f! Mvoid main()8 P8 l! x A* M. ]* w) v
8 m! T6 {; m7 y9 Z2 Q
{+ O' n: }$ [! R+ F$ [: {
" c8 \" ]0 l$ T" Nauto db = new Database("mysql://root:123456@localhost:3306/test?charset=utf8mb4");6 P' ^" Q+ e$ ?* E* J) m" M- p$ t
" m( ?$ d2 g% F+ B+ F3 B" `foreach(row; db.query("SELECT * FROM user LIMIT 10"))4 L2 K% h3 J9 U+ `: c: w% a2 W
/ X ] M% W* Y& a9 h) [& `+ D, o& ?{' f. L. d0 ?. o; k" l" v+ f$ R/ q
* M* n1 H- `4 T$ nwriteln(row["username"]);
9 O1 d" E( V- U: c6 h ~
; O: k; d" f2 H$ Z ^' F5 Y}/ z. C# @2 Z/ ^/ O2 M" @7 m
0 J$ q9 [, u) [/ {5 _
db.close();
+ c* n1 P; T( r' m
# y- c9 C3 L7 l' T) K( ~ z- B}
+ i U, d9 W* L; L4 n2 w' U7 x
$ z4 M, Y& k. R) Z2.2 : Rust 查询数据
6 B. v3 ^6 G" E$ H3 s H
: K) C& S! f. x, s3 Qextern crate postgres;
/ o3 K* K: \- R8 A% n9 z3 Q
! v7 _/ i; O" q0 b& w. e' Zuse postgres::{Connection, SslMode};
! M3 \& _4 M9 q4 Y8 A' ~0 Y& @ e' y" p" X
fn main() {
" F6 b* g6 w$ b# q1 z
% e4 k& K( }6 Ilet conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
! j- f- ?% s2 K% r- J6 n0 h8 P# I5 ^. ?: ~3 d
for row in &conn.query("SELECT * FROM user", &[]).unwrap();
6 P, N* w! r& _3 P& G: G1 j9 H' ~3 E( M+ V+ x* F4 Z; {4 i% G
println!("Found person {}", row.get(0));
1 S5 X* u, \) d- z* G+ [3 s1 U, _; S9 s
) S7 U& L) L- G2 G# t; x8 \}, W l* p! c/ X' l2 g4 u5 Y
, b5 a+ i* c7 n* }9 `1 _
}0 G, B# F7 e1 ~, j- A Y3 e
# ~+ l% G1 g2 Y- ~9 w, ~0 O
2.3 : Golang 查询数据
# m- _! M4 t+ Y$ n' h. ]" ?& F U2 Y, v9 W
import (
# g3 j6 ]+ d, Y! d8 N7 P4 u% j
"database/sql"9 Z2 [/ ]" l; N1 J
& a; P+ p6 ^: ]+ N"fmt"
$ j6 R" V- U$ E( q
$ {8 F# w ~0 t2 v' } ?_ "github.com/lib/pq". q% `4 G& C& i* \+ p. @
* [$ p1 ?" p5 X- O4 [8 q4 P0 g"time". e+ q) h$ _; C e4 S
4 A7 s. i: C0 r2 H$ h"log"
1 Y( Z( K8 E* S0 h& G$ [& b+ m' Y# s% w% c+ C
)
& g9 K9 X$ f7 ^* \/ J/ X) O) G3 Z/ q. `! N
type User struct {4 _& i5 M! S! h8 Q' Q: o9 E
. {, c* g, _. t4 L- b
UserName string. {7 k& S- A& f+ s) Q
: x1 o3 F: C y R# W
}! j Y: q& u+ M7 ?' G6 {% n/ [. x
; E# f. p9 ~4 T
func main() { }1 m' X- x P4 m
8 V; [$ H8 ~8 ~7 _( E, T. u
db, err := sql.Open("postgres", "user=portgres password=123456 dbname=test sslmode=disable")' O7 I' Q( `0 T+ J& t: d' C
" P& i7 }2 O5 G t0 }if err != nil {
5 _" u/ J$ G; X8 @# T, y% f$ `0 [5 {8 b5 o+ M
log.Fatal(err); j6 N0 y: J5 B7 u6 {+ g
, i8 U& H9 Z$ X; ]9 X3 sreturn nil! v! r# k# Q6 h7 W0 v
6 i- ?% E0 W% X% Q4 D/ ]5 M# s8 [
}
o4 ]! `* p! e; R5 S! N: x) s% J! Y# z! q: [2 @
user := User{}
) v/ G7 N, G8 F/ l' Y" l2 o
& G4 \& v# [$ D9 A( a0 b0 Dstmt := db.Query("SELECT * FROM user")( h. n: n" Y$ w( W7 g' j
& ?' y9 m4 b# }# o% P/ g( `
for rows.Next() {
! ]) R; Q% e* h [+ t I
9 O: J- a" U; R# ]& l% w6 ]! krows.Scan(&user.UserName)
! V: t- u" c: z5 Z: H g
$ ?1 c! H) m. n7 S) \) _ ~$ [fmt.Println(user.UserName)! w# D# x0 F5 ^! R7 A
6 V6 o$ S% D1 e2 B' y" z
}
4 C3 d# O* w* D9 F" e1 R% ^2 C: W0 |7 f9 Y: }, C
stmt.Close(): x) @2 I% a4 q
& [# [7 c/ X& p# T$ c% r! W2 ]4 t, @}
, ~0 @7 \3 b0 m; b4 F# G( q7 R
8 g" ^+ f9 _2 S# o7 _# L/ y三、总结+ V5 h4 _6 g' R7 N0 G
- m! T' Z6 i1 I对于操作数据库来说静态类型语言的确不是很容易操作,类似 C++ 这么多年还没有相对容易使用的数据库操作的 library,但无论 Dlang / Rust 和 Golang 都能比较全面的操作数据库。
" ?4 @4 ]0 H* a7 B$ G! F$ s5 ?4 {# h4 W0 V! @2 @+ O9 k4 n- m
这三个语言的语法还有比较大的差异,DLang 语法可读性比较好(的确简单的像PHP一样方便了),Rust 相对来说操作符会多一些,而 golang 在执行 SELECT 之后需要创建对象绑定,不支持字段作为 key 的操作形式?(可能是我功课没做好)
' D. u: ~4 Q' _9 ~+ r, |$ {/ E) R- Y
在包引入方面 Dlang 最简单,Rust 相对来说颗粒度控制的更细,而 Golang 相对繁琐一些,需要几个包同时引入才可以操作数据库;相对 Rust 和 Golang 来说 Dlang 可以更方便的切换不同数据库而不需要修改业务逻辑代码。5 o2 A* d" z! A( A' c/ f
( ~: d5 f2 J4 _4 |7 ?总而言之系统级语言在服务端的应用日益增多,更多有意思的对比还需要大家一起来挖掘,不要沉浸在单一的脚本语言如 PHP、虚拟机语言 JAVA 和 C#,多多学习,现在语言的学习成本已经非常低,我们应该在不同的应用场景使用更适合的开发语言。+ }& o$ e$ C3 ] ~, ^3 s' O
————————————————/ \4 {* x' i! C) T: j2 }- M, u
版权声明:本文为CSDN博主「游戏葡萄」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
( | v h2 x( Y5 ` \) c1 e) q原文链接:https://blog.csdn.net/weixin_30713705/article/details/113633961
; J& O% Z, Y0 B- t% |& v
( k1 T) Z& ?2 P1 \ |
|