perf(proton): remove g.Debug() calls on nil values in batch insert hot loop

yokofly · claude · yokofly · commit 60a5ddde2ad4 · 2026-03-30T02:14:43.000-07:00
Remove 37 g.Debug() calls that fired for every nil value in every row.
g.Debug() calls runtime.Caller() for stack walking + string formatting +
zerolog event creation on each invocation. With -d flag enabled, 10 nullable
columns, and 1.66M rows, this generated millions of expensive debug calls
that provided zero diagnostic value (nil is normal for nullable columns).

Benchmark (localhost, 1.66M rows, batch_limit=50K, cumulative):
  Baseline:     62s (41s user, 77% CPU)
  + LZ4:        61s
  + this:       28s (10s user, 40% CPU) ← 54% faster, biggest single win

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/core/dbio/database/database_proton.go b/core/dbio/database/database_proton.go
@@ -467,53 +467,41 @@ func (conn *ProtonConn) processBatch(tableFName string, table Table, batch *iop.
 						row[colI] = val
 					}
 					eG.Capture(err)
-				} else {
-					g.Debug("decimal if value == nil")
 				}
 			}
 
 			for _, colI := range booleanCols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToBoolE(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("boolean if value == nil")
 				}
 			}
 
 			for _, colI := range stringCols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToStringE(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("string if value == nil")
 				}
 			}
 
 			for _, colI := range int8Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToInt8E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("int8 if value == nil")
 				}
 			}
 
 			for _, colI := range int16Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToInt16E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("int16 if value == nil")
 				}
 			}
 
 			for _, colI := range int32Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToInt32E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("int32 if value == nil")
 				}
 			}
 
@@ -522,8 +510,6 @@ func (conn *ProtonConn) processBatch(tableFName string, table Table, batch *iop.
 				if row[colI] != nil {
 					row[colI], err = cast.ToIntE(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("int if value == nil")
 				}
 			}
 
@@ -532,26 +518,20 @@ func (conn *ProtonConn) processBatch(tableFName string, table Table, batch *iop.
 				if row[colI] != nil {
 					row[colI], err = cast.ToInt64E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("int64 if value == nil")
 				}
 			}
 
 			for _, colI := range uint8Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToUint8E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("uint8 if value == nil")
 				}
 			}
 
 			for _, colI := range uint16Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToUint16E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("uint16 if value == nil")
 				}
 			}
 
@@ -560,8 +540,6 @@ func (conn *ProtonConn) processBatch(tableFName string, table Table, batch *iop.
 				if row[colI] != nil {
 					row[colI], err = cast.ToUint32E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("uint32 if value == nil")
 				}
 			}
 
@@ -570,8 +548,6 @@ func (conn *ProtonConn) processBatch(tableFName string, table Table, batch *iop.
 				if row[colI] != nil {
 					row[colI], err = cast.ToUint64E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("uint64 if value == nil")
 				}
 			}
 
@@ -580,224 +556,174 @@ func (conn *ProtonConn) processBatch(tableFName string, table Table, batch *iop.
 				if row[colI] != nil {
 					row[colI], err = cast.ToFloat64E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("float64 if value == nil")
 				}
 			}
 
 			for _, colI := range float32Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToFloat32E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("float32 if value == nil")
 				}
 			}
 
 			for _, colI := range float64Cols {
 				if row[colI] != nil {
 					row[colI], err = cast.ToFloat64E(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("float64 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayStringCols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayString(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arraystring if value == nil")
 				}
 			}
 
 			for _, colI := range arrayBooleanCols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayBool(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayboolean if value == nil")
 				}
 			}
 
 			for _, colI := range arrayInt8Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayInt8(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayint8 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayInt16Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayInt16(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayint16 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayInt32Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayInt32(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayint32 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayInt64Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayInt64(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayint64 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayUint8Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayUint8(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayuint8 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayUint16Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayUint16(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayuint16 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayUint32Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayUint32(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayuint32 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayUint64Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayUint64(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayuint64 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayFloat32Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayFloat32(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayfloat32 if value == nil")
 				}
 			}
 
 			for _, colI := range arrayFloat64Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToArrayFloat64(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty arrayfloat64 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringStringCols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringString(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringstring if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringInt32Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringInt32(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringint32 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringInt64Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringInt64(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringint64 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringUint32Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringUint32(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringuint32 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringUint64Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringUint64(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringuint64 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringFloat64Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringFloat64(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringfloat64 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringFloat32Cols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringFloat32(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringfloat32 if value == nil")
 				}
 			}
 
 			for _, colI := range mapStringArrayStringCols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapStringArrayString(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapstringarraystring if value == nil")
 				}
 			}
 
 			for _, colI := range mapInt32StringCols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapInt32String(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapint32string if value == nil")
 				}
 			}
 
 			for _, colI := range mapInt64StringCols {
 				if row[colI] != nil {
 					row[colI], err = conn.convertToMapInt64String(row[colI])
 					eG.Capture(err)
-				} else {
-					g.Debug("empty mapint64string if value == nil")
 				}
 			}
 

Original file line number	Diff line number	Diff line change
`@@ -467,53 +467,41 @@ func (conn ProtonConn) processBatch(tableFName string, table Table, batch iop.`
`467`	`467`	`row[colI] = val`
`468`	`468`	`}`
`469`	`469`	`eG.Capture(err)`
`470`		`- } else {`
`471`		`- g.Debug("decimal if value == nil")`
`472`	`470`	`}`
`473`	`471`	`}`
`474`	`472`
`475`	`473`	`for _, colI := range booleanCols {`
`476`	`474`	`if row[colI] != nil {`
`477`	`475`	`row[colI], err = cast.ToBoolE(row[colI])`
`478`	`476`	`eG.Capture(err)`
`479`		`- } else {`
`480`		`- g.Debug("boolean if value == nil")`
`481`	`477`	`}`
`482`	`478`	`}`
`483`	`479`
`484`	`480`	`for _, colI := range stringCols {`
`485`	`481`	`if row[colI] != nil {`
`486`	`482`	`row[colI], err = cast.ToStringE(row[colI])`
`487`	`483`	`eG.Capture(err)`
`488`		`- } else {`
`489`		`- g.Debug("string if value == nil")`
`490`	`484`	`}`
`491`	`485`	`}`
`492`	`486`
`493`	`487`	`for _, colI := range int8Cols {`
`494`	`488`	`if row[colI] != nil {`
`495`	`489`	`row[colI], err = cast.ToInt8E(row[colI])`
`496`	`490`	`eG.Capture(err)`
`497`		`- } else {`
`498`		`- g.Debug("int8 if value == nil")`
`499`	`491`	`}`
`500`	`492`	`}`
`501`	`493`
`502`	`494`	`for _, colI := range int16Cols {`
`503`	`495`	`if row[colI] != nil {`
`504`	`496`	`row[colI], err = cast.ToInt16E(row[colI])`
`505`	`497`	`eG.Capture(err)`
`506`		`- } else {`
`507`		`- g.Debug("int16 if value == nil")`
`508`	`498`	`}`
`509`	`499`	`}`
`510`	`500`
`511`	`501`	`for _, colI := range int32Cols {`
`512`	`502`	`if row[colI] != nil {`
`513`	`503`	`row[colI], err = cast.ToInt32E(row[colI])`
`514`	`504`	`eG.Capture(err)`
`515`		`- } else {`
`516`		`- g.Debug("int32 if value == nil")`
`517`	`505`	`}`
`518`	`506`	`}`
`519`	`507`
`@@ -522,8 +510,6 @@ func (conn ProtonConn) processBatch(tableFName string, table Table, batch iop.`
`522`	`510`	`if row[colI] != nil {`
`523`	`511`	`row[colI], err = cast.ToIntE(row[colI])`
`524`	`512`	`eG.Capture(err)`
`525`		`- } else {`
`526`		`- g.Debug("int if value == nil")`
`527`	`513`	`}`
`528`	`514`	`}`
`529`	`515`
`@@ -532,26 +518,20 @@ func (conn ProtonConn) processBatch(tableFName string, table Table, batch iop.`
`532`	`518`	`if row[colI] != nil {`
`533`	`519`	`row[colI], err = cast.ToInt64E(row[colI])`
`534`	`520`	`eG.Capture(err)`
`535`		`- } else {`
`536`		`- g.Debug("int64 if value == nil")`
`537`	`521`	`}`
`538`	`522`	`}`
`539`	`523`
`540`	`524`	`for _, colI := range uint8Cols {`
`541`	`525`	`if row[colI] != nil {`
`542`	`526`	`row[colI], err = cast.ToUint8E(row[colI])`
`543`	`527`	`eG.Capture(err)`
`544`		`- } else {`
`545`		`- g.Debug("uint8 if value == nil")`
`546`	`528`	`}`
`547`	`529`	`}`
`548`	`530`
`549`	`531`	`for _, colI := range uint16Cols {`
`550`	`532`	`if row[colI] != nil {`
`551`	`533`	`row[colI], err = cast.ToUint16E(row[colI])`
`552`	`534`	`eG.Capture(err)`
`553`		`- } else {`
`554`		`- g.Debug("uint16 if value == nil")`
`555`	`535`	`}`
`556`	`536`	`}`
`557`	`537`
`@@ -560,8 +540,6 @@ func (conn ProtonConn) processBatch(tableFName string, table Table, batch iop.`
`560`	`540`	`if row[colI] != nil {`
`561`	`541`	`row[colI], err = cast.ToUint32E(row[colI])`
`562`	`542`	`eG.Capture(err)`
`563`		`- } else {`
`564`		`- g.Debug("uint32 if value == nil")`
`565`	`543`	`}`
`566`	`544`	`}`
`567`	`545`
`@@ -570,8 +548,6 @@ func (conn ProtonConn) processBatch(tableFName string, table Table, batch iop.`
`570`	`548`	`if row[colI] != nil {`
`571`	`549`	`row[colI], err = cast.ToUint64E(row[colI])`
`572`	`550`	`eG.Capture(err)`
`573`		`- } else {`
`574`		`- g.Debug("uint64 if value == nil")`
`575`	`551`	`}`
`576`	`552`	`}`
`577`	`553`
`@@ -580,224 +556,174 @@ func (conn ProtonConn) processBatch(tableFName string, table Table, batch iop.`
`580`	`556`	`if row[colI] != nil {`
`581`	`557`	`row[colI], err = cast.ToFloat64E(row[colI])`
`582`	`558`	`eG.Capture(err)`
`583`		`- } else {`
`584`		`- g.Debug("float64 if value == nil")`
`585`	`559`	`}`
`586`	`560`	`}`
`587`	`561`
`588`	`562`	`for _, colI := range float32Cols {`
`589`	`563`	`if row[colI] != nil {`
`590`	`564`	`row[colI], err = cast.ToFloat32E(row[colI])`
`591`	`565`	`eG.Capture(err)`
`592`		`- } else {`
`593`		`- g.Debug("float32 if value == nil")`
`594`	`566`	`}`
`595`	`567`	`}`
`596`	`568`
`597`	`569`	`for _, colI := range float64Cols {`
`598`	`570`	`if row[colI] != nil {`
`599`	`571`	`row[colI], err = cast.ToFloat64E(row[colI])`
`600`	`572`	`eG.Capture(err)`
`601`		`- } else {`
`602`		`- g.Debug("float64 if value == nil")`
`603`	`573`	`}`
`604`	`574`	`}`
`605`	`575`
`606`	`576`	`for _, colI := range arrayStringCols {`
`607`	`577`	`if row[colI] != nil {`
`608`	`578`	`row[colI], err = conn.convertToArrayString(row[colI])`
`609`	`579`	`eG.Capture(err)`
`610`		`- } else {`
`611`		`- g.Debug("empty arraystring if value == nil")`
`612`	`580`	`}`
`613`	`581`	`}`
`614`	`582`
`615`	`583`	`for _, colI := range arrayBooleanCols {`
`616`	`584`	`if row[colI] != nil {`
`617`	`585`	`row[colI], err = conn.convertToArrayBool(row[colI])`
`618`	`586`	`eG.Capture(err)`
`619`		`- } else {`
`620`		`- g.Debug("empty arrayboolean if value == nil")`
`621`	`587`	`}`
`622`	`588`	`}`
`623`	`589`
`624`	`590`	`for _, colI := range arrayInt8Cols {`
`625`	`591`	`if row[colI] != nil {`
`626`	`592`	`row[colI], err = conn.convertToArrayInt8(row[colI])`
`627`	`593`	`eG.Capture(err)`
`628`		`- } else {`
`629`		`- g.Debug("empty arrayint8 if value == nil")`
`630`	`594`	`}`
`631`	`595`	`}`
`632`	`596`
`633`	`597`	`for _, colI := range arrayInt16Cols {`
`634`	`598`	`if row[colI] != nil {`
`635`	`599`	`row[colI], err = conn.convertToArrayInt16(row[colI])`
`636`	`600`	`eG.Capture(err)`
`637`		`- } else {`
`638`		`- g.Debug("empty arrayint16 if value == nil")`
`639`	`601`	`}`
`640`	`602`	`}`
`641`	`603`
`642`	`604`	`for _, colI := range arrayInt32Cols {`
`643`	`605`	`if row[colI] != nil {`
`644`	`606`	`row[colI], err = conn.convertToArrayInt32(row[colI])`
`645`	`607`	`eG.Capture(err)`
`646`		`- } else {`
`647`		`- g.Debug("empty arrayint32 if value == nil")`
`648`	`608`	`}`
`649`	`609`	`}`
`650`	`610`
`651`	`611`	`for _, colI := range arrayInt64Cols {`
`652`	`612`	`if row[colI] != nil {`
`653`	`613`	`row[colI], err = conn.convertToArrayInt64(row[colI])`
`654`	`614`	`eG.Capture(err)`
`655`		`- } else {`
`656`		`- g.Debug("empty arrayint64 if value == nil")`
`657`	`615`	`}`
`658`	`616`	`}`
`659`	`617`
`660`	`618`	`for _, colI := range arrayUint8Cols {`
`661`	`619`	`if row[colI] != nil {`
`662`	`620`	`row[colI], err = conn.convertToArrayUint8(row[colI])`
`663`	`621`	`eG.Capture(err)`
`664`		`- } else {`
`665`		`- g.Debug("empty arrayuint8 if value == nil")`
`666`	`622`	`}`
`667`	`623`	`}`
`668`	`624`
`669`	`625`	`for _, colI := range arrayUint16Cols {`
`670`	`626`	`if row[colI] != nil {`
`671`	`627`	`row[colI], err = conn.convertToArrayUint16(row[colI])`
`672`	`628`	`eG.Capture(err)`
`673`		`- } else {`
`674`		`- g.Debug("empty arrayuint16 if value == nil")`
`675`	`629`	`}`
`676`	`630`	`}`
`677`	`631`
`678`	`632`	`for _, colI := range arrayUint32Cols {`
`679`	`633`	`if row[colI] != nil {`
`680`	`634`	`row[colI], err = conn.convertToArrayUint32(row[colI])`
`681`	`635`	`eG.Capture(err)`
`682`		`- } else {`
`683`		`- g.Debug("empty arrayuint32 if value == nil")`
`684`	`636`	`}`
`685`	`637`	`}`
`686`	`638`
`687`	`639`	`for _, colI := range arrayUint64Cols {`
`688`	`640`	`if row[colI] != nil {`
`689`	`641`	`row[colI], err = conn.convertToArrayUint64(row[colI])`
`690`	`642`	`eG.Capture(err)`
`691`		`- } else {`
`692`		`- g.Debug("empty arrayuint64 if value == nil")`
`693`	`643`	`}`
`694`	`644`	`}`
`695`	`645`
`696`	`646`	`for _, colI := range arrayFloat32Cols {`
`697`	`647`	`if row[colI] != nil {`
`698`	`648`	`row[colI], err = conn.convertToArrayFloat32(row[colI])`
`699`	`649`	`eG.Capture(err)`
`700`		`- } else {`
`701`		`- g.Debug("empty arrayfloat32 if value == nil")`
`702`	`650`	`}`
`703`	`651`	`}`
`704`	`652`
`705`	`653`	`for _, colI := range arrayFloat64Cols {`
`706`	`654`	`if row[colI] != nil {`
`707`	`655`	`row[colI], err = conn.convertToArrayFloat64(row[colI])`
`708`	`656`	`eG.Capture(err)`
`709`		`- } else {`
`710`		`- g.Debug("empty arrayfloat64 if value == nil")`
`711`	`657`	`}`
`712`	`658`	`}`
`713`	`659`
`714`	`660`	`for _, colI := range mapStringStringCols {`
`715`	`661`	`if row[colI] != nil {`
`716`	`662`	`row[colI], err = conn.convertToMapStringString(row[colI])`
`717`	`663`	`eG.Capture(err)`
`718`		`- } else {`
`719`		`- g.Debug("empty mapstringstring if value == nil")`
`720`	`664`	`}`
`721`	`665`	`}`
`722`	`666`
`723`	`667`	`for _, colI := range mapStringInt32Cols {`
`724`	`668`	`if row[colI] != nil {`
`725`	`669`	`row[colI], err = conn.convertToMapStringInt32(row[colI])`
`726`	`670`	`eG.Capture(err)`
`727`		`- } else {`
`728`		`- g.Debug("empty mapstringint32 if value == nil")`
`729`	`671`	`}`
`730`	`672`	`}`
`731`	`673`
`732`	`674`	`for _, colI := range mapStringInt64Cols {`
`733`	`675`	`if row[colI] != nil {`
`734`	`676`	`row[colI], err = conn.convertToMapStringInt64(row[colI])`
`735`	`677`	`eG.Capture(err)`
`736`		`- } else {`
`737`		`- g.Debug("empty mapstringint64 if value == nil")`
`738`	`678`	`}`
`739`	`679`	`}`
`740`	`680`
`741`	`681`	`for _, colI := range mapStringUint32Cols {`
`742`	`682`	`if row[colI] != nil {`
`743`	`683`	`row[colI], err = conn.convertToMapStringUint32(row[colI])`
`744`	`684`	`eG.Capture(err)`
`745`		`- } else {`
`746`		`- g.Debug("empty mapstringuint32 if value == nil")`
`747`	`685`	`}`
`748`	`686`	`}`
`749`	`687`
`750`	`688`	`for _, colI := range mapStringUint64Cols {`
`751`	`689`	`if row[colI] != nil {`
`752`	`690`	`row[colI], err = conn.convertToMapStringUint64(row[colI])`
`753`	`691`	`eG.Capture(err)`
`754`		`- } else {`
`755`		`- g.Debug("empty mapstringuint64 if value == nil")`
`756`	`692`	`}`
`757`	`693`	`}`
`758`	`694`
`759`	`695`	`for _, colI := range mapStringFloat64Cols {`
`760`	`696`	`if row[colI] != nil {`
`761`	`697`	`row[colI], err = conn.convertToMapStringFloat64(row[colI])`
`762`	`698`	`eG.Capture(err)`
`763`		`- } else {`
`764`		`- g.Debug("empty mapstringfloat64 if value == nil")`
`765`	`699`	`}`
`766`	`700`	`}`
`767`	`701`
`768`	`702`	`for _, colI := range mapStringFloat32Cols {`
`769`	`703`	`if row[colI] != nil {`
`770`	`704`	`row[colI], err = conn.convertToMapStringFloat32(row[colI])`
`771`	`705`	`eG.Capture(err)`
`772`		`- } else {`
`773`		`- g.Debug("empty mapstringfloat32 if value == nil")`
`774`	`706`	`}`
`775`	`707`	`}`
`776`	`708`
`777`	`709`	`for _, colI := range mapStringArrayStringCols {`
`778`	`710`	`if row[colI] != nil {`
`779`	`711`	`row[colI], err = conn.convertToMapStringArrayString(row[colI])`
`780`	`712`	`eG.Capture(err)`
`781`		`- } else {`
`782`		`- g.Debug("empty mapstringarraystring if value == nil")`
`783`	`713`	`}`
`784`	`714`	`}`
`785`	`715`
`786`	`716`	`for _, colI := range mapInt32StringCols {`
`787`	`717`	`if row[colI] != nil {`
`788`	`718`	`row[colI], err = conn.convertToMapInt32String(row[colI])`
`789`	`719`	`eG.Capture(err)`
`790`		`- } else {`
`791`		`- g.Debug("empty mapint32string if value == nil")`
`792`	`720`	`}`
`793`	`721`	`}`
`794`	`722`
`795`	`723`	`for _, colI := range mapInt64StringCols {`
`796`	`724`	`if row[colI] != nil {`
`797`	`725`	`row[colI], err = conn.convertToMapInt64String(row[colI])`
`798`	`726`	`eG.Capture(err)`
`799`		`- } else {`
`800`		`- g.Debug("empty mapint64string if value == nil")`
`801`	`727`	`}`
`802`	`728`	`}`
`803`	`729`