goease

func ConvertToJSONB ¶

func ConvertToJSONB(oldData, newData interface{}) (JSONB, JSONB, error)

ConvertToJSONB converts two input data structures into JSONB types.

This function takes two input interfaces representing data structures and converts them into JSONB types, which are custom types typically used to represent JSON data in databases that support JSONB storage.

Parameters:

• oldData: interface{} - The old data structure to be converted into a JSONB type.
• newData: interface{} - The new data structure to be converted into a JSONB type.

Returns:

• JSONB: A JSONB representation of the old data structure.
• JSONB: A JSONB representation of the new data structure.
• error: An error if there's any issue during the conversion process.

Usage Example: Suppose you have two structs named 'OldData' and 'NewData' like this:

type OldData struct {
    Name string
    Age  int
}

type NewData struct {
    Name string
    Age  int
    City string
}

You can convert instances of 'OldData' and 'NewData' into JSONB types like this: oldData := OldData{Name: "John", Age: 30} newData := NewData{Name: "Jane", Age: 25, City: "New York"} oldJSONB, newJSONB, err := ConvertToJSONB(oldData, newData)

if err != nil {
    fmt.Println("Error:", err)
    return
}

Note:

• This function internally uses encoding/json package to marshal and unmarshal the data structures into JSONB types.
• Any errors during the conversion process will be returned as an error.

func StructToMap ¶

func StructToMap(data interface{}) (map[string]interface{}, error)

StructToMap converts a struct into a map[string]interface{}.

This function takes an input interface{} representing a struct and converts it into a map where the keys are the field names of the struct, and the values are the corresponding field values. It is particularly useful when you need to work with data in a more dynamic or generic way.

Parameters:

• data: interface{} - The input value that should be a struct. It accepts an interface to be more flexible in what types can be passed.

Returns:

• map[string]interface{}: A map representation of the struct where field names are the keys and field values are the values.
• error: An error if the input is not a struct.

Usage Example: Suppose you have a struct named 'Person' like this:

type Person struct {
    Name  string
    Age   int
    Email string `json:"email"`
}

You can convert an instance of 'Person' into a map using StructToMap like this: person := Person{Name: "John", Age: 30, Email: "john@example.com"} personMap, err := StructToMap(person)

if err != nil {
    fmt.Println("Error:", err)
    return
}

The 'personMap' will contain:

map[string]interface{}{
    "Name":  "John",
    "Age":   30,
    "email": "john@example.com",
}

Note:

• StructToMap supports struct tags to customize the keys in the resulting map. If a JSON tag is available for a field, it will be used as the key. Otherwise, the field name will be used.
• Only exported (public) fields of the struct can be converted, as unexported (private) fields cannot be accessed.
• It's important to ensure that the input 'data' is indeed a struct, as non-struct types will result in an error.