From 9f67243d19469f74118d464988457ef8370ab0eb Mon Sep 17 00:00:00 2001
From: prajwalp <prajwalp@mkcl.org>
Date: Wed, 26 Mar 2025 14:22:10 +0530
Subject: [PATCH] improved logs of db packages
---
dalmdl/coremongo/coremongo.go | 188 +++++++++++++++++-----------------
dalmdl/mysql/mysql.go | 85 +++++++--------
dalmdl/sqlserver/sqlserver.go | 82 +++++++--------
3 files changed, 179 insertions(+), 176 deletions(-)
diff --git a/dalmdl/coremongo/coremongo.go b/dalmdl/coremongo/coremongo.go
index 20817f2..69346f9 100644
--- a/dalmdl/coremongo/coremongo.go
+++ b/dalmdl/coremongo/coremongo.go
@@ -3,6 +3,7 @@ package coremongo
import (
"context"
"encoding/json"
+ "fmt"
"strconv"
"strings"
"sync"
@@ -61,6 +62,7 @@ func InitUsingJSON(configs []MongoHost) error {
instances = make(map[string]*mongo.Client)
for _, hostDetails := range configs {
if hostDetails.IsDisabled {
+ loggermdl.LogError(fmt.Sprintf("Skipping disabled host while initializing: %s", hostDetails.HostName))
continue
}
clientOption := options.Client()
@@ -78,20 +80,20 @@ func InitUsingJSON(configs []MongoHost) error {
}
client, err := mongo.NewClient(clientOption)
if err != nil {
- sessionError = err
+ sessionError = fmt.Errorf("Failed to create MongoDB client for host: %s | Error: %w", hostDetails.HostName, err)
loggermdl.LogError(sessionError)
return
}
err = client.Connect(context.Background())
if err != nil {
- sessionError = err
+ sessionError = fmt.Errorf("Failed to connect to MongoDB server: %s | Error: %w", hostDetails.Server, err)
loggermdl.LogError(sessionError)
return
}
err = client.Ping(context.Background(), readpref.Primary())
if err != nil {
- sessionError = err
- loggermdl.LogError("failed to connect to primary - ", sessionError)
+ sessionError = fmt.Errorf("Failed to ping MongoDB server: %s | Error: %w", hostDetails.Server, err)
+ loggermdl.LogError(sessionError)
return
}
instances[hostDetails.HostName] = client
@@ -109,7 +111,7 @@ func DeleteSession(hostName string) error {
defer mutex.Unlock()
mutex.Lock()
if _, ok := instances[hostName]; !ok {
- return errormdl.Wrap("NO_HOST_FOUND")
+ return errormdl.Wrap(fmt.Sprintf("Session not found for instance: %s", hostName))
}
delete(instances, hostName)
return nil
@@ -123,7 +125,7 @@ func InitNewSession(hostDetails MongoHost) error {
instances = make(map[string]*mongo.Client)
}
if _, ok := instances[hostDetails.HostName]; ok {
- return errormdl.Wrap("DUPLICATE_HOSTNAME")
+ return errormdl.Wrap("Session already present for instance: " + hostDetails.HostName)
}
clientOption := options.Client()
clientOption.SetHosts([]string{bindMongoServerWithPort(hostDetails.Server, hostDetails.Port)}).
@@ -140,32 +142,32 @@ func InitNewSession(hostDetails MongoHost) error {
}
client, err := mongo.NewClient(clientOption)
if err != nil {
- loggermdl.LogError(err)
- return err
+ loggermdl.LogError(fmt.Sprintf("Failed to create MongoDB client for host: %s | Error: %v", hostDetails.HostName, err))
+ return errormdl.Wrap(fmt.Sprintf("Failed to create MongoDB client for host: %s | Error: %v", hostDetails.HostName, err))
}
err = client.Connect(context.Background())
if err != nil {
- loggermdl.LogError(err)
- return err
+ loggermdl.LogError(fmt.Sprintf("Failed to connect to MongoDB server: %s | Error: %v", hostDetails.Server, err))
+ return errormdl.Wrap(fmt.Sprintf("Failed to connect to MongoDB server: %s | Error: %v", hostDetails.Server, err))
}
instances[hostDetails.HostName] = client
return nil
}
-//GetMongoConnection method
+// GetMongoConnection method
func GetMongoConnection(hostName string) (*mongo.Client, error) {
mutex.Lock()
defer mutex.Unlock()
if instances == nil {
- return nil, errormdl.Wrap("MONGO_INIT_NOT_DONE")
+ return nil, errormdl.Wrap("Mongo instances map is not initialized")
}
if hostName == "" {
if instance, ok := instances[defaultHost]; ok {
statemdl.MongoHits()
err := instance.Ping(context.Background(), readpref.Primary())
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to ping MongoDB server: %s | Error: %v", defaultHost, err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to ping MongoDB server: %s | Error: %v", defaultHost, err))
}
return instance, nil
}
@@ -174,12 +176,12 @@ func GetMongoConnection(hostName string) (*mongo.Client, error) {
statemdl.MongoHits()
err := instance.Ping(context.Background(), readpref.Primary())
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to ping MongoDB server: %s | Error: %v", hostName, err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to ping MongoDB server: %s | Error: %v", hostName, err))
}
return instance, nil
}
- return nil, errormdl.Wrap("Session not found for instance: " + hostName)
+ return nil, errormdl.Wrap(fmt.Sprintf("Session not found for instance: %s", hostName))
}
// MongoDAO mongo DAO struct
@@ -214,7 +216,7 @@ func GetMongoDAO(collection string) *MongoDAO {
func (mg *MongoDAO) SaveData(data interface{}) (string, error) {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return "", errormdl.CheckErr(sessionError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -222,12 +224,12 @@ func (mg *MongoDAO) SaveData(data interface{}) (string, error) {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return "", errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return "", errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
opts, insertError := collection.InsertOne(context.Background(), data)
if errormdl.CheckErr1(insertError) != nil {
- return "", errormdl.CheckErr1(insertError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to insert data | Error: %v", insertError))
}
return getInsertedId(opts.InsertedID), nil
}
@@ -236,7 +238,7 @@ func (mg *MongoDAO) SaveData(data interface{}) (string, error) {
func (mg *MongoDAO) SaveBulkData(data []interface{}) (string, error) {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return "", errormdl.CheckErr(sessionError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -244,14 +246,14 @@ func (mg *MongoDAO) SaveBulkData(data []interface{}) (string, error) {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return "", errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return "", errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
insertManyOptions := options.InsertMany()
if mg.MetaData.InsertManyOptions != nil {
marshaledQuery, err := json.Marshal(mg.MetaData.InsertManyOptions)
if err != nil {
- return "", errormdl.Wrap("cannot marshal:query option")
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to marshal data | Error: %v", err))
}
obj := gjson.ParseBytes(marshaledQuery)
if obj.Get("ordered").Value() != nil {
@@ -263,7 +265,7 @@ func (mg *MongoDAO) SaveBulkData(data []interface{}) (string, error) {
}
opts, insertManyError := collection.InsertMany(context.Background(), data, insertManyOptions)
if errormdl.CheckErr1(insertManyError) != nil {
- return "", errormdl.CheckErr1(insertManyError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to insert data | Error: %v", insertManyError))
}
return getInsertedId(opts.InsertedIDs), nil
}
@@ -272,7 +274,7 @@ func (mg *MongoDAO) SaveBulkData(data []interface{}) (string, error) {
func (mg *MongoDAO) UpdateAll(selector map[string]interface{}, data interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -280,13 +282,13 @@ func (mg *MongoDAO) UpdateAll(selector map[string]interface{}, data interface{})
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
_, updateError := collection.UpdateMany(context.Background(), selector, bson.M{"$set": data})
if errormdl.CheckErr1(updateError) != nil {
- return errormdl.CheckErr1(updateError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", updateError))
}
return nil
}
@@ -295,7 +297,7 @@ func (mg *MongoDAO) UpdateAll(selector map[string]interface{}, data interface{})
func (mg *MongoDAO) Update(selector map[string]interface{}, data interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -303,12 +305,12 @@ func (mg *MongoDAO) Update(selector map[string]interface{}, data interface{}) er
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
_, updateError := collection.UpdateOne(context.Background(), selector, bson.M{"$set": data})
if errormdl.CheckErr1(updateError) != nil {
- return errormdl.CheckErr1(updateError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", updateError))
}
return nil
}
@@ -317,7 +319,7 @@ func (mg *MongoDAO) Update(selector map[string]interface{}, data interface{}) er
func (mg *MongoDAO) GetData(selector map[string]interface{}) (*gjson.Result, error) {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return nil, errormdl.CheckErr(sessionError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -325,14 +327,14 @@ func (mg *MongoDAO) GetData(selector map[string]interface{}) (*gjson.Result, err
}
db, ok := config[mg.hostName]
if !ok {
- return nil, errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return nil, errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
cur, err := collection.Find(context.Background(), selector)
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to fetch data | Error: %v", err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to fetch data | Error: %v", err))
}
defer cur.Close(context.Background())
var results []interface{}
@@ -340,14 +342,14 @@ func (mg *MongoDAO) GetData(selector map[string]interface{}) (*gjson.Result, err
var result bson.M
err := cur.Decode(&result)
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to decode data | Error: %v", err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to decode data | Error: %v", err))
}
results = append(results, result)
}
ba, marshalError := json.Marshal(results)
if errormdl.CheckErr2(marshalError) != nil {
- return nil, errormdl.CheckErr2(marshalError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to marshal data | Error: %v", marshalError))
}
rs := gjson.ParseBytes(ba)
return &rs, nil
@@ -357,7 +359,7 @@ func (mg *MongoDAO) GetData(selector map[string]interface{}) (*gjson.Result, err
func (mg *MongoDAO) DeleteData(selector map[string]interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -365,12 +367,12 @@ func (mg *MongoDAO) DeleteData(selector map[string]interface{}) error {
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
_, deleteError := collection.DeleteOne(context.Background(), selector)
if errormdl.CheckErr1(deleteError) != nil {
- return errormdl.CheckErr1(deleteError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to delete data | Error: %v", deleteError))
}
return deleteError
}
@@ -379,7 +381,7 @@ func (mg *MongoDAO) DeleteData(selector map[string]interface{}) error {
func (mg *MongoDAO) DeleteAll(selector map[string]interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -387,17 +389,17 @@ func (mg *MongoDAO) DeleteAll(selector map[string]interface{}) error {
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
_, deleteError := collection.DeleteMany(context.Background(), selector)
if errormdl.CheckErr1(deleteError) != nil {
- return errormdl.CheckErr1(deleteError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to delete data | Error: %v", deleteError))
}
return deleteError
}
-//Set Find Options
+// Set Find Options
func (mg *MongoDAO) SetFindOps(findOps map[string]interface{}) {
mg.MetaData.Findops = findOps
}
@@ -416,7 +418,7 @@ func (mg *MongoDAO) SetInsertManyOptions(insertManyOptions map[string]interface{
func (mg *MongoDAO) GetProjectedData(selector map[string]interface{}, projector map[string]interface{}) (*gjson.Result, error) {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return nil, errormdl.CheckErr(sessionError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -424,14 +426,14 @@ func (mg *MongoDAO) GetProjectedData(selector map[string]interface{}, projector
}
db, ok := config[mg.hostName]
if !ok {
- return nil, errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return nil, errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
ops := &options.FindOptions{}
if mg.MetaData.Findops != nil {
marshaledQuery, err := json.Marshal(mg.MetaData.Findops)
if err != nil {
- return nil, errormdl.Wrap("cannot marshal:query option")
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to marshal data | Error: %v", err))
}
obj := gjson.ParseBytes(marshaledQuery)
loggermdl.LogError(obj)
@@ -457,8 +459,8 @@ func (mg *MongoDAO) GetProjectedData(selector map[string]interface{}, projector
ops.Projection = projector
cur, err := collection.Find(context.Background(), selector, ops)
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to fetch data | Error: %v", err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to fetch data | Error: %v", err))
}
defer cur.Close(context.Background())
var results []interface{}
@@ -466,15 +468,15 @@ func (mg *MongoDAO) GetProjectedData(selector map[string]interface{}, projector
var result bson.M
err := cur.Decode(&result)
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to decode data | Error: %v", err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to decode data | Error: %v", err))
}
results = append(results, result)
}
ba, marshalError := json.Marshal(results)
if errormdl.CheckErr2(marshalError) != nil {
- return nil, errormdl.CheckErr2(marshalError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to marshal data | Error: %v", marshalError))
}
rs := gjson.ParseBytes(ba)
return &rs, nil
@@ -484,7 +486,7 @@ func (mg *MongoDAO) GetProjectedData(selector map[string]interface{}, projector
func (mg *MongoDAO) GetAggregateData(selector interface{}) (*gjson.Result, error) {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return nil, errormdl.CheckErr(sessionError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -492,14 +494,14 @@ func (mg *MongoDAO) GetAggregateData(selector interface{}) (*gjson.Result, error
}
db, ok := config[mg.hostName]
if !ok {
- return nil, errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return nil, errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
aggregateOpts := &options.AggregateOptions{}
if mg.MetaData.AggregateOptions != nil {
marshaledQuery, err := json.Marshal(mg.MetaData.AggregateOptions)
if err != nil {
- return nil, errormdl.Wrap("cannot marshal:query option")
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to marshal data | Error: %v", err))
}
obj := gjson.ParseBytes(marshaledQuery)
loggermdl.LogError("Aggregate Options", obj)
@@ -524,8 +526,8 @@ func (mg *MongoDAO) GetAggregateData(selector interface{}) (*gjson.Result, error
}
cur, err := collection.Aggregate(context.Background(), selector, aggregateOpts)
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to fetch data | Error: %v", err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to fetch data | Error: %v", err))
}
defer cur.Close(context.Background())
var results []interface{}
@@ -533,14 +535,14 @@ func (mg *MongoDAO) GetAggregateData(selector interface{}) (*gjson.Result, error
var result bson.M
err := cur.Decode(&result)
if err != nil {
- loggermdl.LogError(err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to decode data | Error: %v", err))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to decode data | Error: %v", err))
}
results = append(results, result)
}
ba, marshalError := json.Marshal(results)
if errormdl.CheckErr2(marshalError) != nil {
- return nil, errormdl.CheckErr2(marshalError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to marshal data | Error: %v", marshalError))
}
rs := gjson.ParseBytes(ba)
return &rs, nil
@@ -554,7 +556,7 @@ func (mg *MongoDAO) GetAggregateData(selector interface{}) (*gjson.Result, error
func (mg *MongoDAO) UpsertWithID(selector map[string]interface{}, data interface{}) (string, error) {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return "", errormdl.CheckErr(sessionError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -562,14 +564,14 @@ func (mg *MongoDAO) UpsertWithID(selector map[string]interface{}, data interface
}
db, ok := config[mg.hostName]
if !ok {
- return "", errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return "", errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
ops := options.UpdateOptions{}
ops.SetUpsert(true)
upsertRes, updateError := collection.UpdateOne(context.Background(), selector, bson.M{"$set": data}, &ops)
if errormdl.CheckErr1(updateError) != nil {
- return "", errormdl.CheckErr1(updateError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to upsert data | Error: %v", updateError))
}
if upsertRes.UpsertedID != nil {
return getInsertedId(upsertRes.UpsertedID), nil
@@ -607,7 +609,7 @@ func (mg *MongoDAO) Upsert(selector map[string]interface{}, data interface{}) er
func (mg *MongoDAO) PushData(selector map[string]interface{}, data interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -615,18 +617,18 @@ func (mg *MongoDAO) PushData(selector map[string]interface{}, data interface{})
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
_, updateError := collection.UpdateMany(context.Background(), selector, bson.M{"$push": data})
if errormdl.CheckErr1(updateError) != nil {
- return errormdl.CheckErr1(updateError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", updateError))
}
return nil
}
-//set update option for custom update
+// set update option for custom update
func (mg *MongoDAO) SetUpdateOps(updateOps map[string]interface{}) {
mg.MetaData.UpdateOps = updateOps
}
@@ -635,7 +637,7 @@ func (mg *MongoDAO) SetUpdateOps(updateOps map[string]interface{}) {
func (mg *MongoDAO) CustomUpdate(selector map[string]interface{}, data interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -643,13 +645,13 @@ func (mg *MongoDAO) CustomUpdate(selector map[string]interface{}, data interface
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
ops := options.UpdateOptions{}
if mg.MetaData.UpdateOps != nil {
resMarshal, err := json.Marshal(mg.MetaData.UpdateOps)
if err != nil {
- return errormdl.Wrap("cannot marshal:update ops")
+ return errormdl.Wrap(fmt.Sprintf("Failed to marshal update options | Error: %v", err))
}
obj := gjson.ParseBytes(resMarshal)
if obj.Get("arrayFilter").Value() != nil {
@@ -665,7 +667,7 @@ func (mg *MongoDAO) CustomUpdate(selector map[string]interface{}, data interface
collection := session.Database(db.Database).Collection(mg.collectionName)
_, updateError := collection.UpdateMany(context.Background(), selector, data, &ops)
if errormdl.CheckErr1(updateError) != nil {
- return errormdl.CheckErr1(updateError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", updateError))
}
return nil
}
@@ -674,7 +676,7 @@ func (mg *MongoDAO) CustomUpdate(selector map[string]interface{}, data interface
func (mg *MongoDAO) CustomUpdateOne(selector map[string]interface{}, data interface{}) error {
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -682,12 +684,12 @@ func (mg *MongoDAO) CustomUpdateOne(selector map[string]interface{}, data interf
}
db, ok := config[mg.hostName]
if !ok {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
_, updateError := collection.UpdateOne(context.Background(), selector, data)
if errormdl.CheckErr1(updateError) != nil {
- return errormdl.CheckErr1(updateError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", updateError))
}
return nil
}
@@ -701,7 +703,7 @@ func (mg *MongoDAO) BulkSaveData(data []interface{}) error {
}
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -709,7 +711,7 @@ func (mg *MongoDAO) BulkSaveData(data []interface{}) error {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
opts := &options.BulkWriteOptions{}
@@ -722,8 +724,8 @@ func (mg *MongoDAO) BulkSaveData(data []interface{}) error {
}
_, insertError := collection.BulkWrite(context.Background(), models, opts)
if errormdl.CheckErr1(insertError) != nil {
- loggermdl.LogError(insertError)
- return errormdl.CheckErr1(insertError)
+ loggermdl.LogError(fmt.Sprintf("Failed to insert data | Error: %v", insertError))
+ return errormdl.Wrap(fmt.Sprintf("Failed to insert data | Error: %v", insertError))
}
return nil
@@ -737,7 +739,7 @@ func (mg *MongoDAO) BulkUpdateData(data []interface{}) error {
}
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -745,7 +747,7 @@ func (mg *MongoDAO) BulkUpdateData(data []interface{}) error {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
opts := &options.BulkWriteOptions{}
@@ -761,8 +763,8 @@ func (mg *MongoDAO) BulkUpdateData(data []interface{}) error {
_, insertError := collection.BulkWrite(context.Background(), models, opts)
if errormdl.CheckErr1(insertError) != nil {
- loggermdl.LogError(insertError)
- return errormdl.CheckErr1(insertError)
+ loggermdl.LogError(fmt.Sprintf("Failed to update data | Error: %v", insertError))
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", insertError))
}
return nil
}
@@ -775,7 +777,7 @@ func (mg *MongoDAO) BulkUpdate(data []interface{}) error {
}
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -783,7 +785,7 @@ func (mg *MongoDAO) BulkUpdate(data []interface{}) error {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
opts := &options.BulkWriteOptions{}
@@ -799,8 +801,8 @@ func (mg *MongoDAO) BulkUpdate(data []interface{}) error {
_, insertError := collection.BulkWrite(context.Background(), models, opts)
if errormdl.CheckErr1(insertError) != nil {
- loggermdl.LogError(insertError)
- return errormdl.CheckErr1(insertError)
+ loggermdl.LogError(fmt.Sprintf("Failed to update data | Error: %v", insertError))
+ return errormdl.Wrap(fmt.Sprintf("Failed to update data | Error: %v", insertError))
}
return nil
}
@@ -813,7 +815,7 @@ func (mg *MongoDAO) BulkDeleteData(data []interface{}) error {
}
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -821,7 +823,7 @@ func (mg *MongoDAO) BulkDeleteData(data []interface{}) error {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
opts := &options.BulkWriteOptions{}
@@ -834,8 +836,8 @@ func (mg *MongoDAO) BulkDeleteData(data []interface{}) error {
}
_, insertError := collection.BulkWrite(context.Background(), models, opts)
if errormdl.CheckErr1(insertError) != nil {
- loggermdl.LogError(insertError)
- return errormdl.CheckErr1(insertError)
+ loggermdl.LogError(fmt.Sprintf("Failed to delete data | Error: %v", insertError))
+ return errormdl.Wrap(fmt.Sprintf("Failed to delete data | Error: %v", insertError))
}
return nil
}
@@ -847,7 +849,7 @@ func (mg *MongoDAO) BulkUpsertData(data []interface{}) error {
}
session, sessionError := GetMongoConnection(mg.hostName)
if errormdl.CheckErr(sessionError) != nil {
- return errormdl.CheckErr(sessionError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to get mongo connection | Error: %v", sessionError))
}
if mg.hostName == "" {
@@ -855,7 +857,7 @@ func (mg *MongoDAO) BulkUpsertData(data []interface{}) error {
}
db, ok := config[mg.hostName]
if errormdl.CheckBool(!ok) {
- return errormdl.Wrap("No_Configuration_Found_For_Host: " + mg.hostName)
+ return errormdl.Wrap(fmt.Sprintf("No Configuration Found For Host: %s", mg.hostName))
}
collection := session.Database(db.Database).Collection(mg.collectionName)
opts := &options.BulkWriteOptions{}
@@ -873,7 +875,7 @@ func (mg *MongoDAO) BulkUpsertData(data []interface{}) error {
_, insertError := collection.BulkWrite(context.Background(), models, opts)
if errormdl.CheckErr1(insertError) != nil {
loggermdl.LogError(insertError)
- return errormdl.CheckErr1(insertError)
+ return errormdl.Wrap(fmt.Sprintf("Failed to upsert data | Error: %v", insertError))
}
return nil
}
diff --git a/dalmdl/mysql/mysql.go b/dalmdl/mysql/mysql.go
index 7e8b136..1a587ab 100644
--- a/dalmdl/mysql/mysql.go
+++ b/dalmdl/mysql/mysql.go
@@ -3,6 +3,7 @@ package mysql
import (
"database/sql"
"database/sql/driver"
+ "fmt"
"strconv"
"strings"
"sync"
@@ -59,13 +60,13 @@ func InitUsingJSON(configs []MySQLConnection) error {
}
connection, err := InitConnection(connectionDetails)
if errormdl.CheckErr1(err) != nil {
- loggermdl.LogError("Init dbr.Open Err : ", err)
+ loggermdl.LogError(err)
connectionError = err
return
}
pingError := connection.Ping()
if errormdl.CheckErr1(pingError) != nil {
- loggermdl.LogError(pingError)
+ loggermdl.LogError(fmt.Sprintf("Failed to ping connection to %s | Error: %s", connectionDetails.HostName, pingError.Error()))
connectionError = pingError
return
}
@@ -116,8 +117,8 @@ func InitConnection(connectionDetails MySQLConnection) (*dbr.Connection, error)
conStr.WriteString(paramsString.String())
connection, err := dbr.Open("mysql", conStr.String(), nil)
if errormdl.CheckErr1(err) != nil {
- loggermdl.LogError("Init dbr.Open Err : ", err)
- return nil, err
+ loggermdl.LogError(fmt.Sprintf("Failed to open connection to %s | Error: %s", connectionDetails.HostName, err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to open connection to %s | Error: %s", connectionDetails.HostName, err.Error()))
}
if connectionDetails.MaxIdleConns == 0 {
connectionDetails.MaxIdleConns = constantmdl.MAX_IDLE_CONNECTIONS // default is 2
@@ -149,8 +150,8 @@ func Init(tomlFilepath string, defaultHostName string) (map[string]*dbr.Connecti
sqlConnections = make(map[string]*dbr.Connection)
_, err := configmdl.InitConfig(tomlFilepath, &config)
if errormdl.CheckErr(err) != nil {
- loggermdl.LogError("Init InitConfig Err : ", err)
- connectionError = err
+ loggermdl.LogError(fmt.Sprintf("Failed to read config file %s | Error: %s", tomlFilepath, err.Error()))
+ connectionError = fmt.Errorf("Failed to read config file %s | Error: %s", tomlFilepath, err.Error())
return
}
for connectionName, connectionDetails := range config.MysqlHosts {
@@ -170,8 +171,8 @@ func Init(tomlFilepath string, defaultHostName string) (map[string]*dbr.Connecti
connection, err := dbr.Open("mysql", connectionDetails.Username+":"+connectionDetails.Password+"@"+connectionDetails.Protocol+"("+connectionDetails.Server+")/"+connectionDetails.Database+paramsString, nil)
if errormdl.CheckErr1(err) != nil {
- loggermdl.LogError("Init dbr.Open Err : ", err)
- connectionError = err
+ loggermdl.LogError(fmt.Sprintf("Failed to open connection to %s | Error: %s", connectionName, err.Error()))
+ connectionError = fmt.Errorf("Failed to open connection to %s | Error: %s", connectionName, err.Error())
return
}
if connectionDetails.MaxIdleConns == 0 {
@@ -196,8 +197,8 @@ func Init(tomlFilepath string, defaultHostName string) (map[string]*dbr.Connecti
// GetMYSQLConnection -
func GetMYSQLConnection(connectionName string) (*dbr.Connection, error) {
if errormdl.CheckBool(sqlConnections == nil) {
- loggermdl.LogError("GetMYSQLConnection Err : ", errormdl.Wrap("MYSQL_INIT_NOT_DONE"))
- return nil, errormdl.Wrap("MYSQL_INIT_NOT_DONE")
+ loggermdl.LogError(fmt.Sprintf("MYSQL connections map is not initialized"))
+ return nil, errormdl.Wrap("MYSQL connections map is not initialized")
}
if connectionName == "" {
if instance, keyExist := sqlConnections[defaultHost]; keyExist {
@@ -209,7 +210,7 @@ func GetMYSQLConnection(connectionName string) (*dbr.Connection, error) {
statemdl.MySQLHits()
return session, nil
}
- loggermdl.LogError("GetMYSQLConnection Err : ", errormdl.Wrap("Connection not found for host: "+connectionName))
+ loggermdl.LogError(fmt.Sprintf("Connection not found for host: %s", connectionName))
return nil, errormdl.Wrap("Connection not found for host: " + connectionName)
}
@@ -236,18 +237,18 @@ func GetMySQLDAOWithHost(host string) *MySQLDAO {
func (md *MySQLDAO) ExecQuery(query string, args ...interface{}) (string, error) {
connection, connectionError := GetMYSQLConnection(md.hostName)
if errormdl.CheckErr(connectionError) != nil {
- loggermdl.LogError("SaveUpdateOrDelete GetMYSQLConnection Err : ", connectionError)
- return "", errormdl.CheckErr(connectionError)
+ loggermdl.LogError(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", md.hostName, connectionError.Error()))
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", md.hostName, connectionError.Error()))
}
pingError := connection.Ping()
if errormdl.CheckErr(pingError) != nil && pingError != driver.ErrBadConn {
loggermdl.LogError(pingError)
- return "", errormdl.CheckErr(pingError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to ping connection for host: %s | Error: %s", md.hostName, pingError.Error()))
}
result, execError := connection.Exec(query, args...)
if errormdl.CheckErr(execError) != nil {
loggermdl.LogError(execError)
- return "", errormdl.CheckErr(execError)
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to execute query | Error: %s", execError.Error()))
}
_, affectError := result.RowsAffected()
@@ -257,8 +258,8 @@ func (md *MySQLDAO) ExecQuery(query string, args ...interface{}) (string, error)
}
ID, err := result.LastInsertId()
if errormdl.CheckErr(err) != nil {
- loggermdl.LogError(err)
- return "", errormdl.CheckErr(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to get last inserted id | Error: %s", err.Error()))
+ return "", errormdl.CheckErr(fmt.Errorf("Failed to get last inserted id | Error: %s", err.Error()))
}
return strconv.Itoa(int(ID)), nil
}
@@ -267,26 +268,26 @@ func (md *MySQLDAO) ExecQuery(query string, args ...interface{}) (string, error)
func (md *MySQLDAO) SelectQuery(query string, args ...interface{}) (*gjson.Result, error) {
connection, connectionError := GetMYSQLConnection(md.hostName)
if errormdl.CheckErr(connectionError) != nil {
- loggermdl.LogError("SaveUpdateOrDelete GetMYSQLConnection Err : ", connectionError)
- return nil, errormdl.CheckErr(connectionError)
+ loggermdl.LogError(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", md.hostName, connectionError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", md.hostName, connectionError.Error()))
}
// loggermdl.LogSpot(connection)
pingError := connection.Ping()
if errormdl.CheckErr(pingError) != nil && pingError != driver.ErrBadConn {
- loggermdl.LogError(pingError)
- return nil, errormdl.CheckErr(pingError)
+ loggermdl.LogError(fmt.Sprintf("Failed to ping connection for host: %s | Error: %s", md.hostName, pingError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to ping connection for host: %s | Error: %s", md.hostName, pingError.Error()))
}
rows, queryError := connection.Query(query, args...)
if errormdl.CheckErr(queryError) != nil {
loggermdl.LogError(queryError)
- return nil, errormdl.CheckErr(queryError)
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to query | Error: %s", queryError.Error()))
}
defer rows.Close()
columns, err := rows.Columns()
if errormdl.CheckErr2(err) != nil {
- loggermdl.LogError("GetAllData rows.Columns() Err : ", err)
- return nil, errormdl.CheckErr2(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to get columns | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get columns | Error: %s", err.Error()))
}
values := make([]interface{}, len(columns))
valuePtrs := make([]interface{}, len(columns))
@@ -298,13 +299,13 @@ func (md *MySQLDAO) SelectQuery(query string, args ...interface{}) (*gjson.Resul
rows.Scan(valuePtrs...)
data, err := sjsonhelpermdl.SetMultiple("", columns, values)
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set multiple sjson | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set multiple sjson | Error: %s", err.Error()))
}
tableData, err = sjson.Set(tableData, "-1", gjson.Parse(data).Value())
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set sjson | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set sjson | Error: %s", err.Error()))
}
}
resultSet := gjson.Parse(tableData)
@@ -316,18 +317,18 @@ func ExecTxQuery(query string, tx *sql.Tx, args ...interface{}) (string, error)
result, execError := tx.Exec(query, args...)
if errormdl.CheckErr(execError) != nil {
- loggermdl.LogError(execError)
- return "", errormdl.CheckErr(execError)
+ loggermdl.LogError(fmt.Sprintf("Failed to execute transactional query | Error: %s", execError.Error()))
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to execute transactional query | Error: %s", execError.Error()))
}
_, affectError := result.RowsAffected()
if errormdl.CheckErr(affectError) != nil {
- loggermdl.LogError(affectError)
- return "", errormdl.CheckErr(affectError)
+ loggermdl.LogError(fmt.Sprintf("Failed to get rows affected | Error: %s", affectError.Error()))
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get rows affected | Error: %s", affectError.Error()))
}
ID, err := result.LastInsertId()
if errormdl.CheckErr(err) != nil {
- loggermdl.LogError(err)
- return "", errormdl.CheckErr(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to get last inserted id | Error: %s", err.Error()))
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get last inserted id | Error: %s", err.Error()))
}
return strconv.Itoa(int(ID)), nil
}
@@ -336,14 +337,14 @@ func ExecTxQuery(query string, tx *sql.Tx, args ...interface{}) (string, error)
func SelectTxQuery(query string, tx *sql.Tx, args ...interface{}) (*gjson.Result, error) {
rows, queryError := tx.Query(query, args...)
if errormdl.CheckErr(queryError) != nil {
- loggermdl.LogError(queryError)
- return nil, errormdl.CheckErr(queryError)
+ loggermdl.LogError(fmt.Sprintf("Failed to execute transactional query | Error: %s", queryError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to execute transactional query | Error: %s", queryError.Error()))
}
defer rows.Close()
columns, err := rows.Columns()
if errormdl.CheckErr2(err) != nil {
- loggermdl.LogError("GetAllData rows.Columns() Err : ", err)
- return nil, errormdl.CheckErr2(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to get columns | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get columns | Error: %s", err.Error()))
}
values := make([]interface{}, len(columns))
valuePtrs := make([]interface{}, len(columns))
@@ -355,13 +356,13 @@ func SelectTxQuery(query string, tx *sql.Tx, args ...interface{}) (*gjson.Result
rows.Scan(valuePtrs...)
data, err := sjsonhelpermdl.SetMultiple("", columns, values)
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set multiple sjson | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set multiple sjson | Error: %s", err.Error()))
}
tableData, err = sjson.Set(tableData, "-1", gjson.Parse(data).Value())
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set sjson | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set sjson | Error: %s", err.Error()))
}
}
resultSet := gjson.Parse(tableData)
diff --git a/dalmdl/sqlserver/sqlserver.go b/dalmdl/sqlserver/sqlserver.go
index cb8c8b4..98b8cd7 100644
--- a/dalmdl/sqlserver/sqlserver.go
+++ b/dalmdl/sqlserver/sqlserver.go
@@ -18,7 +18,7 @@ import (
"github.com/tidwall/sjson"
)
-//SQLServerConfig
+// SQLServerConfig
type SQLServerConfig struct {
HostName string `json:"hostName"`
Server string `json:"server"`
@@ -39,7 +39,7 @@ type SQLParameters struct {
Value string
}
-//SQLServerDAO
+// SQLServerDAO
type SQLServerDAO struct {
HostName string
}
@@ -69,12 +69,12 @@ func InitUsingJSON(configs []SQLServerConfig) error {
// hostDetails.Server, hostDetails.Username, hostDetails.Password, hostDetails.Port, hostDetails.Database)
connString := genereateConnectionString(hostDetails)
var err error
- loggermdl.LogError("connString: ", connString)
+ loggermdl.LogError("sql server connection string:", connString)
// Create connection pool
conn, err := sql.Open("mssql", connString)
if err != nil {
- connectionErr = err
- loggermdl.LogError("error while creating connection:", err)
+ connectionErr = fmt.Errorf("Failed to open connection to %s | Error: %s", hostDetails.HostName, err.Error())
+ loggermdl.LogError(connectionErr)
return
}
@@ -84,8 +84,8 @@ func InitUsingJSON(configs []SQLServerConfig) error {
err = conn.Ping()
if err != nil {
- connectionErr = err
- loggermdl.LogError("failed to connect:", err)
+ connectionErr = fmt.Errorf("Failed to ping connection to %s | Error: %s", hostDetails.HostName, err.Error())
+ loggermdl.LogError(connectionErr)
return
}
@@ -108,8 +108,8 @@ func InitConnection(connectionDetails SQLServerConfig) (*sql.DB, error) {
// Create connection pool
connection, err := sql.Open("mssql", connString)
if err != nil {
- loggermdl.LogError("error while creating connection:", err)
- return nil, err
+ loggermdl.LogError("Failed to open connection to %s | Error: %s", connectionDetails.HostName, err.Error())
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to open connection to %s | Error: %s", connectionDetails.HostName, err.Error()))
}
connection.SetConnMaxLifetime(connectionDetails.ConnMaxLifetime)
@@ -119,7 +119,7 @@ func InitConnection(connectionDetails SQLServerConfig) (*sql.DB, error) {
return connection, nil
}
-//makeConnURL prepare the url for connection
+// makeConnURL prepare the url for connection
func makeConnURL(config SQLServerConfig) *url.URL {
return &url.URL{
Scheme: "sqlserver",
@@ -128,14 +128,14 @@ func makeConnURL(config SQLServerConfig) *url.URL {
}
}
-//GetSQLServerConnection returns connection by hostname
+// GetSQLServerConnection returns connection by hostname
func GetSQLServerConnection(hostName string) (*sql.DB, error) {
mutex.Lock()
defer mutex.Unlock()
if sqlServerConnections == nil {
- return nil, errormdl.Wrap("SQLSERVER_INIT_NOT_DONE")
+ return nil, errormdl.Wrap(fmt.Sprintf("SQLServer connections map is not initialized"))
}
if hostName == "" {
if connection, ok := sqlServerConnections[defaultHost]; ok {
@@ -148,14 +148,14 @@ func GetSQLServerConnection(hostName string) (*sql.DB, error) {
return nil, errormdl.Wrap("Connection not found for : " + hostName)
}
-//GetSQLServerDAO returns SQLServer DAO instance with default host
+// GetSQLServerDAO returns SQLServer DAO instance with default host
func GetSQLServerDAO() *SQLServerDAO {
return &SQLServerDAO{
HostName: defaultHost,
}
}
-//GetSQLServerDAOWithHost returns SQLServer DAO instance with provided host
+// GetSQLServerDAOWithHost returns SQLServer DAO instance with provided host
func GetSQLServerDAOWithHost(hostName string) *SQLServerDAO {
return &SQLServerDAO{
HostName: hostName,
@@ -166,26 +166,26 @@ func GetSQLServerDAOWithHost(hostName string) *SQLServerDAO {
func (ss *SQLServerDAO) SelectQuery(query string, args ...interface{}) (*gjson.Result, error) {
connection, connectionError := GetSQLServerConnection(ss.HostName)
if errormdl.CheckErr(connectionError) != nil {
- loggermdl.LogError("GetSqlServerConnection Err : ", connectionError)
- return nil, errormdl.CheckErr(connectionError)
+ loggermdl.LogError(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", ss.HostName, connectionError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", ss.HostName, connectionError.Error()))
}
// loggermdl.LogSpot(connection)
pingError := connection.Ping()
if errormdl.CheckErr(pingError) != nil && pingError != driver.ErrBadConn {
- loggermdl.LogError(pingError)
- return nil, errormdl.CheckErr(pingError)
+ loggermdl.LogError(fmt.Sprintf("Failed to ping connection for host: %s | Error: %s", ss.HostName, pingError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to ping connection for host: %s | Error: %s", ss.HostName, pingError.Error()))
}
rows, queryError := connection.Query(query, args...)
if errormdl.CheckErr(queryError) != nil {
- loggermdl.LogError(queryError)
- return nil, errormdl.CheckErr(queryError)
+ loggermdl.LogError(fmt.Sprintf("Failed to execute query: %s | Error: %s", query, queryError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to execute query: %s | Error: %s", query, queryError.Error()))
}
defer rows.Close()
columns, err := rows.Columns()
if errormdl.CheckErr2(err) != nil {
- loggermdl.LogError("GetAllData rows.Columns() Err : ", err)
- return nil, errormdl.CheckErr2(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to get columns for query: %s | Error: %s", query, err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get columns for query: %s | Error: %s", query, err.Error()))
}
values := make([]interface{}, len(columns))
valuePtrs := make([]interface{}, len(columns))
@@ -197,13 +197,13 @@ func (ss *SQLServerDAO) SelectQuery(query string, args ...interface{}) (*gjson.R
rows.Scan(valuePtrs...)
data, err := sjsonhelpermdl.SetMultiple("", columns, values)
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
}
tableData, err = sjson.Set(tableData, "-1", gjson.Parse(data).Value())
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
}
}
resultSet := gjson.Parse(tableData)
@@ -214,14 +214,14 @@ func (ss *SQLServerDAO) SelectQuery(query string, args ...interface{}) (*gjson.R
func SelectTxQuery(query string, tx *sql.Tx, args ...interface{}) (*gjson.Result, error) {
rows, queryError := tx.Query(query, args...)
if errormdl.CheckErr(queryError) != nil {
- loggermdl.LogError(queryError)
- return nil, errormdl.CheckErr(queryError)
+ loggermdl.LogError(fmt.Sprintf("Failed to execute trasactional query | Error: %s", queryError.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to execute trasactional query | Error: %s", queryError.Error()))
}
defer rows.Close()
columns, err := rows.Columns()
if errormdl.CheckErr2(err) != nil {
- loggermdl.LogError("GetAllData rows.Columns() Err : ", err)
- return nil, errormdl.CheckErr2(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to get columns for query: %s | Error: %s", query, err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to get columns for query: %s | Error: %s", query, err.Error()))
}
values := make([]interface{}, len(columns))
valuePtrs := make([]interface{}, len(columns))
@@ -233,30 +233,30 @@ func SelectTxQuery(query string, tx *sql.Tx, args ...interface{}) (*gjson.Result
rows.Scan(valuePtrs...)
data, err := sjsonhelpermdl.SetMultiple("", columns, values)
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
}
tableData, err = sjson.Set(tableData, "-1", gjson.Parse(data).Value())
if errormdl.CheckErr3(err) != nil {
- loggermdl.LogError("GetAllData sjson.Set Err : ", err)
- return nil, errormdl.CheckErr3(err)
+ loggermdl.LogError(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
+ return nil, errormdl.Wrap(fmt.Sprintf("Failed to set data | Error: %s", err.Error()))
}
}
resultSet := gjson.Parse(tableData)
return &resultSet, nil
}
-//ExecQuery to execute query
+// ExecQuery to execute query
func (ss *SQLServerDAO) ExecQuery(query string, args ...interface{}) (string, error) {
conn, err := GetSQLServerConnection(ss.HostName)
if err != nil {
- return "", err
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get connection for host: %s | Error: %s", ss.HostName, err.Error()))
}
result, err := conn.Exec(query, args...)
if err != nil {
- return "", err
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to execute query | Error: %s", err.Error()))
}
_ = result
@@ -275,13 +275,13 @@ func ExecTxQuery(query string, tx *sql.Tx, args ...interface{}) (string, error)
result, execError := tx.Exec(query, args...)
if errormdl.CheckErr(execError) != nil {
- loggermdl.LogError(execError)
- return "", errormdl.CheckErr(execError)
+ loggermdl.LogError(fmt.Sprintf("Failed to execute query | Error: %s", execError.Error()))
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to execute query | Error: %s", execError.Error()))
}
_, affectError := result.RowsAffected()
if errormdl.CheckErr(affectError) != nil {
- loggermdl.LogError(affectError)
- return "", errormdl.CheckErr(affectError)
+ loggermdl.LogError(fmt.Sprintf("Failed to get affected rows | Error: %s", affectError.Error()))
+ return "", errormdl.Wrap(fmt.Sprintf("Failed to get affected rows | Error: %s", affectError.Error()))
}
//TODO: get last inserted id
--
GitLab