From 2a537f5b542055f3694b06c8ea84a8154e3f470f Mon Sep 17 00:00:00 2001
From: Drew Bednar <drew@runcible.io>
Date: Sun, 21 Jul 2024 18:55:06 -0400
Subject: [PATCH] Saving the work

---
 go-sql-database/try-sqlite/data/trysqlite.db  | Bin 20480 -> 20480 bytes
 .../try-sqlite/data/trysqlite.db-shm          | Bin 0 -> 32768 bytes
 .../try-sqlite/data/trysqlite.db-wal          | Bin 0 -> 61832 bytes
 go-sql-database/try-sqlite/main.go            | 146 +++++++++++++++++-
 4 files changed, 143 insertions(+), 3 deletions(-)
 create mode 100644 go-sql-database/try-sqlite/data/trysqlite.db-shm
 create mode 100644 go-sql-database/try-sqlite/data/trysqlite.db-wal

diff --git a/go-sql-database/try-sqlite/data/trysqlite.db b/go-sql-database/try-sqlite/data/trysqlite.db
index 51730b81f1e1b6a42c3507598b1eaea8dae00fc6..d1cb1d4707c98bbeca85bc90527d5c05b9dec555 100644
GIT binary patch
delta 696
zcmZozz}T>WaRZkDAAbUG00M3n6tLi}5945GQ1&!7<|ru2PcKT$&CSe9&q+-z%2P<s
z&q>TnS4c@LNlZ#CPE{x@O)bhyEmkx#Ff!3KFxNFQR4_EOGBvj{Fu)?jz`!Ixgt_&&
z4K}kfF-J2PB*ehLxPu6TahhvlW@TUkH@6<_39uN@-~>tyHi8=rH`fSgE(cC?>xl?r
z6Jsk=OEiN)LJSNH8*my-q`CEIK@76XJdBHyG+}OKXl!MK;$Wzd8zVb|syZ;Od1t1i
m<SP_pCTCARZEwx;m4W~3W<iBl{5%YtjLhPUCHX1&#asYMp~2Vy

delta 41
xcmZozz}T>WaRZmZW<h~<{F8Us`>}ju;QzK+P~jCn4+8@SBeOVXNq$OxF#sl(4ATGr

diff --git a/go-sql-database/try-sqlite/data/trysqlite.db-shm b/go-sql-database/try-sqlite/data/trysqlite.db-shm
new file mode 100644
index 0000000000000000000000000000000000000000..cbb88628a887a036bc4640d2aa242cba2f466be1
GIT binary patch
literal 32768
zcmeI)yNQB95CGuO^ZiZ^Y(lOB`>+5b16we#15*tJlglqsxbT_~Y{Z*iL`=;Tzky|j
zWtnBZ0%mv`MG>t$rHDa4b2U%pxcK_nt^N+<{dE01*{;54pY!FWF?{fSwz@>o_k0)E
z>szX1b@?~*qxG$cf&c*m1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!CuL3Y6j__iWXo
z9?jhS)roEt8@dF6cMvG&uDM3EqxTNOnvnnj0t5&UAV7cs0RjXF5FkK+009C72oNAZ
gfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5O{Hce>1NquK)l5

literal 0
HcmV?d00001

diff --git a/go-sql-database/try-sqlite/data/trysqlite.db-wal b/go-sql-database/try-sqlite/data/trysqlite.db-wal
new file mode 100644
index 0000000000000000000000000000000000000000..1da2d5de98a2917bbac88cbf93e9fb85d184fb5c
GIT binary patch
literal 61832
zcmeI*Pe>GD7{~EhGymkD5yKLKn8=8N#o5_e2M01VDEdn$D=OGYmu*R1TUWYBMOcxC
zIwVL`r%;RtJk_3xga|rx5W)_HU{C~k2ueD1=$%ztNA0r13OjyRJ^122%lnz}g?)H_
ztZ}92n&h9Zm82@ke!OgY5qU6vYS<iZo*4S_aidr&T)eKmJM-=7iDO!YSS*mklAMym
z6~{AQ_TTbA009ILKmY**5I_I{1Q7VYKx;{{wEbW(Skj${M-x_OXRIsQ5wQ|oN;KYK
zbw!nSD`}mxdLqij-bf-A>Di{Kn(kK(zZOse0W)Nns=C6Gc$Ze?s&0d+8%yfiOOoVE
zxv8r+n5yoqn_d!i!*1(p%j;^QZi%b9K{M32q^`XruIQNCx=Va@QP*fKb8|l!rYI70
z)SX}2?<<ye>=gIe;aGcnT<MOrUFhvT5Lcp+q;k|sMB~YYO$HhjO*M7R3<XzM68m0n
z|19(iTC|ZHkyoFu+kF9_{7VwwJP<$t0R#|0009ILKmY**5J1370;Rrnn|;Z6d%UMi
zY|EY(_}3RG`?00&-mdVWxxPS(c>yn7clLq+0tg_000IagfB*ukBEY<W$-Kba=tsWH
z3pjEFeOAq-H~VTfkt0}@<AN7K009ILKmY**5I_I{4+_v1pf4~V37P8)l)KCk=!@q6
z?S6yE5!g$)$`SbQ6#W^M>u!-F@ZjOZmJmPy0R#|0009ILKmY**5U>R@If8QWn<Gas
zF?ghD^7h%i<OsM`5I_I{1Q0*~0R#|00D<fTm=|DPAkXFn965s6<n%yg;%gf@g6#hP
zc@_c)Ab<b@2q1s}0tg^LUx2=Vqc2e5GDi?HRmbNth#Y~vl&c)Uv*OG5KW&(4AxFSj
zh5!NxAb<b@2q1s}0tg_0fJX%~IRg9bzavMm=TY_e_p$yD<On=^?b#Lr2q1s}0tg_0
z00Ic)T!482<^}R>Uciwf@CAlSt=XIDd4U2s%;yy5{KVh|5I_I{1Q0*~0R#|0z-t2Z
z1?USn`T~{ias;79GoWg!ru$VRUDq(vOS#Gs{2q8bGBsQMo*aSKPA2w)00IagfB*sr
zAb<b@2q1vKyg(*LP$^a%IfC6kANDn$JZ+I9;BG+x0R#|0009ILKmY**vJ+rlfO&yD
zn-_582wI;sY@K;s+i&*;$Pr|B2JkEd5I_I{1Q0*~0R#|O+XD0j=nFXd0<!BIfgW0x
zBhW*+$`K^P=bzVC4I1PK*7iBZ?h!x$0R#|0009ILKmY**JS>pO5y)bfjvPV#)v3a_
lcSlp?2t0iK*%|@}Ab<b@2q1s}0tn<(fO!Gt1@dWL;4j^kE2aPd

literal 0
HcmV?d00001

diff --git a/go-sql-database/try-sqlite/main.go b/go-sql-database/try-sqlite/main.go
index 934bd9f..ed781e9 100644
--- a/go-sql-database/try-sqlite/main.go
+++ b/go-sql-database/try-sqlite/main.go
@@ -8,6 +8,11 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 )
 
+func showTransactionStmtClose(p *sql.Stmt) {
+	log.Println("Closing statement!")
+	p.Close()
+}
+
 func main() {
 
 	log.Println("Hello, world!")
@@ -66,7 +71,8 @@ func main() {
 	// You don't wait for the garbage collector to do it.
 
 	// as long as there’s an open result set (represented by rows), the underlying connection is busy and can’t be used for
-	//any other query.
+	//any other query. It's busy because sql.Rows objects don't retrieve all results a query returns. It does it lazily to prevent over runing memory.
+	// it depends on the driver but there is usually and internal buffer that stores results.
 
 	// Also never defer in a loop. Defer only runs on function exit.
 	defer rows.Close()
@@ -114,11 +120,11 @@ func main() {
 
 	//Prepared Queries
 	// If you will be using the same query over and over you should just prepare the query.
-	// $N is the postgres query param which SQLite can use too ? is mysql's
+	// $N (e.g. $1, $2, etc...) is the postgres query param which SQLite can use too ? is mysql's
 
 	//Under the hood, db.Query() actually prepares, executes, and closes a prepared statement
 	// That’s three round-trips to the database.
-	stmt, err := db.Prepare("SELECT * FROM todos WHERE id = $N")
+	stmt, err := db.Prepare("SELECT todo as other_todo FROM todos WHERE id = $1")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -126,4 +132,138 @@ func main() {
 	//This prepared statement *sql.Stmt is tied to the database connection from which it was created, and it holds onto that connection until you call stmt.Close()
 	defer stmt.Close()
 
+	// You can also call with just params the .QueryRow method since the statement is already prepared
+	var other_todo string
+
+	err = stmt.QueryRow(1).Scan(&other_todo)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Printf("Other Todo: %s", other_todo)
+	stmt.Close()
+
+	// MODIFYING DATA
+	// Use db.Exec() with a prepared statement when INSERTING, UPDATING, or DELETING
+	// Or another statement that doesn't return rows.
+
+	stmt, err = db.Prepare("INSERT INTO todos (subject, todo) VALUES ($1, $2)")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer stmt.Close()
+
+	// stmt.Exec returns a sql.Result. That also has access to the statement metadata
+	// use _ if you don't care about the result and only want to check the err.
+
+	// Exec will NOT reserve a connection. unlike db.Query which returns a sql.Rows that
+	// will hold on to a connection until .Close() is called.
+	res, err := stmt.Exec("programming", "learn golang database queries!")
+	if err != nil {
+		log.Print("Dirp...")
+		log.Fatal(err)
+	}
+
+	lastId, err := res.LastInsertId()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Printf("Last inserted id: %d", lastId)
+
+	rowCnt, err := res.RowsAffected()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Printf("The number of rows affected: %d", rowCnt)
+	// close insert
+	stmt.Close()
+
+	stmt, err = db.Prepare("DELETE FROM todos WHERE subject = 'programming'")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	res, err = stmt.Exec()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	rowCnt, err = res.RowsAffected()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Printf("The number of rows affected: %d", rowCnt)
+
+	// TRANSACTIONS
+
+	//In Go, a transaction is essentially an object that reserves a connection to the datastore.
+	//It lets you do all of the operations we’ve seen thus far, but guarantees that they’ll be
+	//executed on the same connection.
+
+	// Starts with db.Begin() returning a sql.Tx and ends with a .Commit() or .Rollback() on the results sql.Tx
+
+	tx, err := db.Begin()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Prepared statement in a transaction are bound to that transaction exclusively.
+
+	// DO NOT use sql BEGIN or COMMIT in a sql.Tx object. It could leave the DB and client in different states.
+	// or mess havoc with the connection pool and connection lifetime
+	insert_stmt, err := tx.Prepare("INSERT INTO todos (subject, todo) VALUES ($1, $2)")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer insert_stmt.Close() // This closes at the end of the transaction, not the end of the function.
+
+	_, _ = insert_stmt.Exec("dirp", "just a place holder")
+
+	// There is no Close method on a transaction. It is closed by using .Commit or .Rollback
+	tx.Rollback()
+
+	// PREPARED STATEMENTS IN MORE DEPTH
+
+	//At the database level, a prepared statement is bound to a single database connection.
+	//The typical flow is that the client sends a SQL statement with placeholders to the server
+	//for preparation, the server responds with a statement ID, and then the client executes
+	//the statement by sending its ID and parameters.
+
+	// THE ABOVE DOES NOT HAPPEN IN database/sql. Instead the statement is managed at the driver level
+	// Go doesn't expose connections directly to users. The sql.Stmt object remembers which connection
+	// from the pool it is associated with.
+
+	//Know that if a connection is busy it may automatically get a new connection and re-prepare the
+	// statement on a new connection. It could cause more connections than you think, more statement
+	// recreation, or even hitting a server limit on prepared statements.
+
+	// NOTE db.Query(sql, param1, param2) will create a prepared statement under the hood.
+	// If you don’t want to use a prepared statement, you need to use fmt.Sprint() or similar to
+	//assemble the SQL, and pass this as the only argument to db.Query() or db.QueryRow() And your driver
+	//needs to support plaintext query execution,
+
+	// NOTE prepared statements on Tx are bound exclusively to the Tx. You cannot use a prepared statement
+	// created by db.Prepare nor can you use a Tx.Prepare statement with a db.Query. Tx.Stmt() can be used
+	// to copy a db.Prepared statement into a transaction, but don't do this.
+
+	// HANDLING ERRORS
+
+	// You should always explicitly close a sql.Rows result set. If rows.Close() returns an error, it’s
+	// unclear what you should do, so logging the error message and ignoring or panic-ing might be the only sensible
+	// thing to do.
+
+	// Use sql.ErrNoRows in the event that no data is returned.
+	// rememeber db.QueryRow defers errors till Scan is called.
+	err = db.QueryRow("select subject from todos where id = $1", 100_000).Scan(&subject)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			// there were no rows, but otherwise no error occurred
+			log.Println("No rows were returned! But that is okay. We expected that could happen")
+		} else {
+			log.Fatal(err)
+		}
+	}
 }