管理员
   
论坛积分
分
威望 点
贡献值 个
金币 枚
|
我们使用 DLang / Rust / Golang 在服务端开发的时候对数据库操作是家常便饭,而对于所谓的系统级编译型语言来说操作数据库可能没那么方便,不像 PHP 和 JAVA 那样,对于比较新的三个编译型语言我们来看看效果,刚好这三个语言的语法差异比较大。6 |$ J. b! Z7 }
) g |. D' l: e: N2 x一、数据插入 - INSERT2 S. T% B+ [/ ]6 I" {
5 [1 d, U1 T" |
1.1 : DLang 插入数据
6 _, {% L' }6 d
- T& D5 k- e; o! L J5 kimport std.stdio;
! E; I4 d8 j4 J3 ?
- k R6 o% Q( V: p8 _import hunt.database;
7 v* `3 u# s% k" @) T- M0 T8 {$ E" N0 V6 O6 h. b6 v. N2 l# Y+ o$ v, O
void main()# s$ O0 S( y2 ]2 M7 Z1 b
- {: t2 p9 o. l" |2 ?{
8 g8 E% A6 E3 w
' ^! C! G" _* j, b/ Jauto db = new Database("mysql://root:123456@localhost:3306/test?charset=utf8mb4");% i. x3 f( O5 l' e. M* L4 f c# s4 c
2 m0 g7 w, ?. a4 w/ n9 O5 ~int result = db.execute(`INSERT INTO user(username) VALUES("test")`);0 W5 o2 n, e! `- F" w
* N# U4 f% ]; F$ g+ ~5 [. Z; M
// 打印插入数量7 T, G7 ?1 s0 |
& m$ _- H$ O5 g; g( S+ ^0 l6 F& t
writeln(result);6 }7 V% x. ]& Y1 U5 C
7 Z, L- {) y" x" C4 {
db.close();
8 ?' v! ?/ D6 p5 y1 X: N2 D2 p0 @2 x" ~7 B) s/ _
}$ {8 l$ V6 }& `# M$ R6 J
- |/ x0 D4 ~4 | I1.2 : Rust 插入数据2 H x+ X3 ]- Q9 P) l3 f9 G8 Q% B" g
4 [" O( @; J, y3 H( G) ?2 F
extern crate postgres;2 ]- E7 v1 v& D+ v5 J1 ~2 S
* O2 ^: W% j: w) j" l% }; tuse postgres::{Connection, SslMode};
3 t/ ?* k* {1 ?" {$ m, x+ R3 V" M6 |9 C7 h" }
fn main() {
5 W; w$ ~' U4 a. m/ y! P; l
: h, @3 H% K. Q" llet conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();% y+ }: l) i" a. y' x3 r* ~
4 K& x- N% v' S+ M# M- ~conn.execute("INSERT INTO user (username) VALUES (\"test\")", &[]).unwrap();
H0 Y+ ~1 b- d
0 B1 k) O) \; T}) ^% k: e5 E2 h# m3 ]+ k3 t/ r+ }
2 u" c* e6 @% c, [) p1.3 : Golang 插入数据
4 v g' ~' P5 ~1 I. y& U6 {
0 j8 O5 [' E: `. S% b# @4 t: }import (
; r/ j* L- X' e- I
* W" ?7 F( E9 ], f"database/sql"1 c8 w& u9 \/ B* G2 e, I
4 v) H1 |9 n. z2 q7 U3 U( |"fmt"
z# q# f8 s9 {, \- b$ j& i m/ ?% J' w3 i j
_ "github.com/lib/pq"
* V+ l% U9 v {. J8 O. `7 x/ y& h/ U0 K' k5 G1 n
"time"
: b8 G! `( e" c; a0 E
. k) O$ v0 e$ e% I& t' z6 u! L"log"4 \# W1 h& I& J
3 P- _; l' y6 s) K: Y0 O)3 t0 b, r+ l: g) i
$ e7 P: T" d2 S+ Cfunc main() {
* F6 L1 ]# k+ k4 y+ e) m; ?" O6 w/ h$ ?/ E: z; _
db, err := sql.Open("postgres", "user=portgres password=123456 dbname=test sslmode=disable")6 q u9 N* M1 R, |4 s( S' B+ R9 f- \& Q
: H( W! {8 o4 m$ w
if err != nil {$ K9 M$ u! P! L2 f- y! X
. m9 T# B! V) C9 a
log.Fatal(err)8 D4 ]" P5 p6 |; ^
& W0 x7 D/ H. ^& creturn nil
% R7 X+ r l% ]" D6 @
9 [; k1 y( q/ @1 V}
$ r; p/ l6 e1 }% @4 g- U. [
! e2 O. H, y+ O4 y( p3 v" Y! Gstmt := db.Prepare("INSERT INTO user (username) VALUES (\"test\")")
- L4 U9 d% s7 S) [4 Z1 R
' }' I$ ^( K+ v5 Hstmt.Exec(), P& c V [! ?; T
0 x5 s- j. C) W- c7 Y8 }; x$ _stmt.Close()' _0 N3 b2 n3 _
! H4 A4 T1 a! `3 n$ R& J; f& P}: q; \4 l5 ]8 Q" p+ {
6 H; N6 K1 d8 i6 i- j二、数据查询 - SELECT
- C8 a: \: x: A6 \9 o& r9 L
* `8 j$ i# i; Q; T+ L% N2.1 : DLang 查询数据+ `% C7 w! U6 h0 r7 J( S E
" Q" g0 s9 a* k+ J$ |import std.stdio;; F/ f. D% R: A( j/ O! w
. x, F9 z7 O! a, \
import hunt.database;
' Z# z8 m) f. {& C% e* L# }" Y2 U4 S! ^+ I
void main(); p' ~/ s% L z/ f3 i
9 D! Z. V, E# @7 |9 O{
! i$ E. G' `3 n7 r/ G7 e3 u! v9 B7 R# ?; I
auto db = new Database("mysql://root:123456@localhost:3306/test?charset=utf8mb4");
0 ^: j5 M) k' C0 G: h5 q; ?1 y, q3 i2 u! t1 l! o x7 P
foreach(row; db.query("SELECT * FROM user LIMIT 10"))
{. K/ _. u! W5 Y2 v4 B" L; W
; A8 r6 n8 J& `{* m# N% d7 |6 ^1 q
5 i7 t* R7 t+ _: m7 q4 F' k, Z; Gwriteln(row["username"]);4 Y# i1 d* W$ Q% X: `9 _0 y
x# m ~' K* ~# k0 p+ t: r}( W5 K% T0 m/ b: N8 `/ e
1 r! F! S1 p5 D4 [db.close();8 N( E; a6 Z$ F- k1 F: {
$ E! n. W& @" g1 d: w' Y' t. _
}, F- y/ k" x, G4 m/ U9 }. l" X1 D* _
v, `/ A& }. w4 y5 K' Z
2.2 : Rust 查询数据
, N- ~# D) S! E) D, T k
8 O- O, S" B' Hextern crate postgres;$ Q7 ?# ?$ N& L3 }# q- Q
) e# r* F# L% h3 w1 H( E) R+ a7 Suse postgres::{Connection, SslMode}; i* v' X, X+ O5 b6 b# d/ ?
! j0 ]4 Q- W0 f
fn main() {
) N$ T# b7 g! k; N) q9 ]9 P- i* e+ J8 \1 H; J
let conn = Connection::connect("postgres://postgres@localhost", SslMode::None).unwrap();
7 l e! e5 W7 b1 S k
2 Y b2 J3 O* qfor row in &conn.query("SELECT * FROM user", &[]).unwrap();
' t$ t: S5 y) X; J, D* ~, m
4 n/ ~5 ~! a0 {* @println!("Found person {}", row.get(0));) J+ G4 q* _7 Q `; ?
5 X5 A* A4 p- ^, |! l( p}
8 j, e: A( w1 s! r( ?; B7 G6 z" x! c+ D
}
; o( ^0 }5 k: b' T. D" J, q/ [
7 [1 [& y# B5 z+ ^! u( W2.3 : Golang 查询数据5 C4 D/ r' H" i4 P. I
6 {' ?: h$ G% \/ p7 e
import (6 n8 N, i- O7 O/ V+ g
5 H. k5 _' W9 \; B. ?7 a"database/sql"" D- {8 K; h9 K8 c1 G
" f' f- d6 o! Z! ~2 H( }+ F"fmt"
. b2 H& ?& u* H2 G8 b/ Z3 M! J& `6 M; W
_ "github.com/lib/pq"3 c" ]5 j1 {" x" B+ t2 l
4 O$ ]" W. i: \% q2 v
"time"
+ `. d+ d; x( t
2 s) c% b4 ?# k"log"6 I/ O8 F5 w" {" ~1 h* T; O) ?
( \ K) e6 o$ l# F0 a* i)
" b% U/ N5 x' y/ X B7 x; u4 w- g! ~9 O; z: I
type User struct {8 b V6 b+ l% C/ |
7 e5 g; U, {8 b5 eUserName string
; a- v0 z% d! ~, I7 }( M: F+ v+ b/ V. \: S
}
8 s; G Y1 N x7 ~9 m! k8 E% W% M; }
func main() {
. |* a8 f- }1 Q% S. v0 L( @
i1 x2 J7 _6 S! C9 `db, err := sql.Open("postgres", "user=portgres password=123456 dbname=test sslmode=disable")3 O- z" ?8 ?4 |4 ]$ A
! x8 E3 g) D6 Y/ v( j# Gif err != nil {! \0 R1 ?% @- l9 M R
4 @- f! ]* I2 F' t9 U
log.Fatal(err)2 r, O; X3 @* Q& ?+ x
+ r+ @* M4 _& p, A: creturn nil
& ^0 O3 Z# U, B: w* S) W" \
+ Z; m$ L% q* w% w+ \$ e% p! e; p}, `( d1 D6 f" J; V
4 d+ m9 t% D \user := User{}
5 `7 @: s; K1 m( M+ [2 i" c- ?7 G B4 H! r; Q
stmt := db.Query("SELECT * FROM user")
5 j9 C% Q$ n6 E6 [ I5 M/ t: ?' n7 s! g6 {1 e1 U' e5 }8 H
for rows.Next() {
$ [) Y# Q& k9 X1 z. n2 s+ F6 n& J: I" Y
rows.Scan(&user.UserName)
" Z" P/ ~* n7 r) |. H1 m$ o& E
d# t2 q; S% M% pfmt.Println(user.UserName) F9 k) d+ f+ f- W
1 r9 F/ V9 f, ~4 C& ^" A
}$ H; _- E% e3 G* _2 S/ a- I5 _
- m, F: u8 q2 p1 E# x; v) e
stmt.Close(): B9 G: ~: W- `7 R2 d' F$ c
5 R$ t( C8 n; Y* l3 b8 [9 r2 e9 e
}; d7 r) y8 y, T+ n3 j
7 @4 x6 [; x; F8 d' ]
三、总结% A" o) Z$ p y0 f9 S+ y
+ x9 h' |2 A: |" T F对于操作数据库来说静态类型语言的确不是很容易操作,类似 C++ 这么多年还没有相对容易使用的数据库操作的 library,但无论 Dlang / Rust 和 Golang 都能比较全面的操作数据库。. D# ~& f0 }: A+ Q: b# \4 B
/ X) X& s8 D& v$ T- }2 g% s* W0 W这三个语言的语法还有比较大的差异,DLang 语法可读性比较好(的确简单的像PHP一样方便了),Rust 相对来说操作符会多一些,而 golang 在执行 SELECT 之后需要创建对象绑定,不支持字段作为 key 的操作形式?(可能是我功课没做好) d1 N3 X, n% D
( Z {0 J! b& m1 U% ^
在包引入方面 Dlang 最简单,Rust 相对来说颗粒度控制的更细,而 Golang 相对繁琐一些,需要几个包同时引入才可以操作数据库;相对 Rust 和 Golang 来说 Dlang 可以更方便的切换不同数据库而不需要修改业务逻辑代码。5 Y- e _' H; T: P% G- e
" x8 Q v! w8 O/ d总而言之系统级语言在服务端的应用日益增多,更多有意思的对比还需要大家一起来挖掘,不要沉浸在单一的脚本语言如 PHP、虚拟机语言 JAVA 和 C#,多多学习,现在语言的学习成本已经非常低,我们应该在不同的应用场景使用更适合的开发语言。# P9 V6 `' f3 f- W: @7 c) {! c+ p! R
————————————————8 J) q; Y' q/ P1 M) R2 K
版权声明:本文为CSDN博主「游戏葡萄」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
: g& @1 d# E8 |/ H: X原文链接:https://blog.csdn.net/weixin_30713705/article/details/113633961
( m) o4 b d+ \6 {5 J7 _
6 b& c1 a" f- a" F |
|