Data Model Generation for PostgreSQL

DinGo is a simple Go code generator that is useful to produce Microservice applications starting from the database schema.


PostgreSQL supported

As I showed in the previous post DinGo produces code reading the database schema and its first version supported only the MySQL database, but now after a not so short and unfortunately not continuous work, finally the PostgreSQL database has been supported.

The current release (2.0.beta) contains all the templates and producers for providing microservices that can operate on Postgres. This DinGo release is still in beta because it requires a few tests and there are also some limitations. Postgres array types are not supported and I don't know if they will be in the future.

Reading the Information Schema

PostgreSQL offers two methods for retrieving meta-data about the table's schema using the system catalogs (pg_class, pg_user, pg_view, ...) or querying the information_schema (available since Postgres 7.4).
DinGo has adopted the second method retrieving all the tables meta-data querying the information_schema. This approach is very similar to that used with MySQL, queries on the PostgreSQL information_schema require only few changes starting from the previous ones.


Updated configuration file

DinGo configuration file requires some additional parameters to connect Postgres. This is an example of configuration 

{ 
    "Hostname": "localhost", 
    "Port": "5432",
    "DatabaseType": "Postgres", 
    "DatabaseName": "Customers", 
    "Username": "postgres", 
    "Password": "mypassword",
    "BasePackage": "github.com/maxzerbini/prjtestPostgres",
    "OutputPath": "$GOPATH/src/github.com/maxzerbini/prjtestPostgres",
    "ExcludedEntities": [],
    "Entities": [],
    "SkipDaoGeneration": false,
    "SkipBizGeneration": false,
    "SkipServiceGeneration": false,
    "ForcePluralResourceName": true,
    "PostgresSchema": "public"
}

The new property DatabaseType can now assume one of the two values "MySQL" or "Postgres" and the PostgresSchema property is used for querying the Information_Schema and get the meta-data of the selected set of tables.

Commenti

Posta un commento

Post popolari in questo blog

OAuth 2.0 Server & Authorization Middleware for Gin-Gonic

Project OAuth OAuth is an open source project developed in Go and available on GitHub .  The project offers an Authorization Server and an Authorization Middleware that can be used to make secure access to resources API and provide a simple and efficient implementation of the OAuth 2.0 specification. Authorization Server and Middleware are both based on Gin-Gonic and can interoperate with any other middleware available for this framework.  Authorization Server The Authorization Server is implemented by the struct OAuthBearerServer that manages two grant types of authorizations: password and client_credentials. This Authorization Server is made to provide authorization token usable for consuming resources API. Developers need only add their own implementation of CredentialsVerifier interface to validate the credentials of users or applications that require a token. package main import (  "errors"  "time"  "gopkg.in/gin-gonic/gin.v1"  &q
Continua a leggere

From the database schema to RESTful API with DinGo

Immagine
In the  previous post I had started writing about data model and code generation and the post coincided with the boot of an open source project called DinGo thought to generate the Go code for a Microservice host analysing the schema of a relational database. It's a very SQL First approach to write code, so I don't think it should be good for all the projects, but surely there are many applications that can take advantage from this, at least those are using already defined relational databases and want to adopt a Microservice architecture and RESTful API. What DinGo does DinGo creates a Microservice application starting from a MySQL database schema. Dingo follows these steps during the generation process: DinGo reads the information_schema of the MySQL database it generates a set of Data Model structs used to map tables into Go structs it generates the Data Access Objects , these objects provide a set of basic operations (CRUD operations) necessary to manipulat
Continua a leggere

Go text and HTML templates

Template packages Server side languages offers a mechanism for inserting a dynamically generated content into static pages. Go provides a mechanism for substituting the value of variables into text or HTML template.  A Go template is string or file containing text (HTML) and  actions , that are string expressions enclosed in double braces {{ ... }} that trigger some behaviors. Actions are powerful notations for selecting and printing fields, expressing control flow and calling functions. Go standard library offers two package for managing templates: The packages share the same interface so the following examples that treat HTML can also be applied to simple text . text/template , implements data-driven templates for generating textual output html/template , is the same as text/template but automatically secures HTML output against certain attacks (script injection) Gin-Gonic Gin, the fast and full-featured web framework for Go that we have already seen in the GIF API post
Continua a leggere