postgresql

package main

import (
	"context"

	"github.com/adamluzsi/frameless/postgresql"
)

func main() {
	connectionManager := postgresql.NewConnectionManager(`dsn`)
	defer connectionManager.Close()

	ctx := context.Background()

	c, err := connectionManager.Connection(ctx)
	if err != nil {
		panic(err)
	}

	_, err = c.ExecContext(ctx, `SELECT VERSION()`)
	if err != nil {
		panic(err)
	}
}

Output:

package main

import (
	"context"
	"time"

	"github.com/adamluzsi/frameless/iterators"
	"github.com/adamluzsi/frameless/postgresql"
)

func main() {
	type ExampleEntity struct {
		ID   int64
		Col1 int
		Col2 string
		Col3 bool
	}
	_ = postgresql.Mapper /* [ExampleEntity] */ {
		Table:   `"public"."entities"`,
		ID:      "entity_id",
		Columns: []string{"entity_id", "col1", "col2", "col3"},
		NewIDFn: func(ctx context.Context) (interface{}, error) {
			// a really bad way to make id,
			// but this is only an example
			return time.Now().UnixNano(), nil
		},
		ToArgsFn: func(ptr interface{}) ([]interface{}, error) {
			ent := ptr.(*ExampleEntity) // Go1.18 will solve this with generics
			return []interface{}{ent.ID, ent.Col1, ent.Col2, ent.Col3}, nil
		},
		MapFn: func(scanner iterators.SQLRowScanner, ptr interface{}) error {
			ent := ptr.(*ExampleEntity)
			return scanner.Scan(&ent.ID, &ent.Col1, &ent.Col2, &ent.Col3)
		},
	}
}

Output:

package main

import (
	"context"
	"math/rand"
	"os"

	"github.com/adamluzsi/frameless/iterators"
	"github.com/adamluzsi/frameless/postgresql"
)

func main() {
	type Entity struct {
		ID    int `ext:"ID"`
		Value string
	}

	mapping := postgresql.Mapper{
		Table:   "entities",
		ID:      "id",
		Columns: []string{`id`, `value`},
		NewIDFn: func(ctx context.Context) (interface{}, error) {
			// only example, don't do this in production code.
			return rand.Int(), nil
		},
		ToArgsFn: func(ptr interface{}) ([]interface{}, error) {
			ent := ptr.(*Entity)
			return []interface{}{ent.ID, ent.Value}, nil
		},
		MapFn: func(s iterators.SQLRowScanner, ptr interface{}) error {
			ent := ptr.(*Entity)
			return s.Scan(&ent.ID, &ent.Value)
		},
	}

	stg := postgresql.NewStorageByDSN(Entity{}, mapping, os.Getenv("DATABASE_URL"))
	defer stg.Close()
}

Output:

package main

import (
	"os"

	"github.com/adamluzsi/frameless/postgresql"
)

func main() {
	type ExampleEntity struct {
		ID string `ext:"id"`
	}

	connectionManager := postgresql.NewConnectionManager(os.Getenv(`DATABASE_URL`))
	mapping := postgresql.Mapper{ /* real mapping data here */ }

	subscriptionManager := postgresql.NewListenNotifySubscriptionManager(ExampleEntity{}, mapping, os.Getenv("DATABASE_URL"), connectionManager)
	defer subscriptionManager.Close()
}

Output: