### Instruction:
Develop a Golang web application that allows users to authenticate using OAuth 2.0 with Google or Facebook, displays their profile information (name, email, profile picture), and stores this data in a PostgreSQL database.

### Response:

To create a Golang web application that allows users to authenticate using OAuth 2.0 with Google or Facebook, you'll need to follow these steps:

1. Set up your project and dependencies
2. Create the PostgreSQL database and tables
3. Register your app with Google and Facebook
4. Implement OAuth 2.0 authentication for Google and Facebook
5. Display user profile information
6. Store user data in the PostgreSQL database

Here's an outline of how you can implement this:

1. Set up your project and dependencies:

Create a new directory for your project and initialize it as a Go module:

```bash
mkdir go-oauth-example
cd go-oauth-example
go mod init github.com/yourusername/go-oauth-example
```

Install the required dependencies:

```bash
go get -u github.com/gin-gonic/gin
go get -u golang.org/x/oauth2
go get -u github.com/lib/pq
```

2. Create the PostgreSQL database and tables:

Assuming you have PostgreSQL installed, create a new database and table to store user information:

```sql
CREATE DATABASE oauth_example;

\c oauth_example;

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255),
    email VARCHAR(255) UNIQUE NOT NULL,
    picture_url VARCHAR(255)
);
```

3. Register your app with Google and Facebook:

- For Google: Follow the instructions at https://developers.google.com/identity/sign-in/web/sign-in#before_you_begin to create a new project and obtain your client ID and secret.
- For Facebook: Follow the instructions at https://developers.facebook.com/docs/facebook-login/web/#simple-app to create a new app and obtain your App ID and secret.

4. Implement OAuth 2.0 authentication for Google and Facebook:

Create a `main.go` file in your project directory and add the following code:

```go
package main

import (
	"database/sql"
	"fmt"
	"log"
	"net/http"

	"github.com/gin-gonic/gin"
	_ "github.com/lib/pq"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/facebook"
	"golang.org/x/oauth2/google"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "your_db_user"
	password = "your_db_password"
	dbname   = "oauth_example"
)

var (
	googleOauthConfig = &oauth2.Config{
		ClientID:     "your_google_client_id",
		ClientSecret: "your_google_client_secret",
		RedirectURL:  "http://localhost:8080/auth/google/callback",
		Scopes:       []string{"https://www.googleapis.com/auth/userinfo.profile", "https://www.googleapis.com/auth/userinfo.email"},
		Endpoint:     google.Endpoint,
	}
	facebookOauthConfig = &oauth2.Config{
		ClientID:     "your_facebook_app_id",
		ClientSecret: "your_facebook_app_secret",
		RedirectURL:  "http://localhost:8080/auth/facebook/callback",
		Scopes:       []string{"public_profile", "email"},
		Endpoint:     facebook.Endpoint,
	}
	oauthStateString = "random_state_string"
)

func main() {
	router := gin.Default()

	router.LoadHTMLGlob("templates/*")

	router.GET("/", indexHandler)
	router.GET("/login", loginHandler)
	router.GET("/auth/google/login", beginGoogleOAuth)
	router.GET("/auth/google/callback", handleGoogleOAuthCallback)
	router.GET("/auth/facebook/login", beginFacebookOAuth)
	router.GET("/auth/facebook/callback", handleFacebookOAuthCallback)

	err := router.Run(":8080")
	if err != nil {
		log.Fatal(err)
	}
}

func indexHandler(c *gin.Context) {
	c.HTML(http.StatusOK, "index.html", nil)
}

func loginHandler(c *gin.Context) {
	c.HTML(http.StatusOK, "login.html", nil)
}

func beginGoogleOAuth(c *gin.Context) {
	url := googleOauthConfig.AuthCodeURL(oauthStateString)
	c.Redirect(http.StatusTemporaryRedirect, url)
}

func handleGoogleOAuthCallback(c *gin.Context) {
	// Implement the logic to exchange the authorization code for an access token,
	// retrieve user profile information and store it in the PostgreSQL database.
}

func beginFacebookOAuth(c *gin.Context) {
	url := facebookOauthConfig.AuthCodeURL(oauthStateString)
	c.Redirect(http.StatusTemporaryRedirect, url)
}

func handleFacebookOAuthCallback(c *gin.Context) {
	// Implement the logic to exchange the authorization code for an access token,
	// retrieve user profile information and store it in the PostgreSQL database.
}
```

5. Display user profile information:

Create a `templates` directory in your project folder and add two HTML files: `index.html` and `login.html`.

`index.html`:

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Go OAuth Example</title>
</head>
<body>
    <h1>Welcome!</h1>
    <a href="/login">Login with Google or Facebook</a>
</body>
</html>
```

`login.html`:

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
    <h1>Login</h1>
    <a href="/auth/google/login">Login with Google</a><br>
    <a href="/auth/facebook/login">Login with Facebook</a>
</body>
</html>
```

6. Store user data in the PostgreSQL database:

Update the `handleGoogleOAuthCallback` and `handleFacebookOAuthCallback` functions in your `main.go` file to exchange the authorization code for an access token, retrieve user profile information, and store it in the PostgreSQL database.

You can find examples of how to do this in the following articles:

- For Google: https://developers.google.com/identity/sign-in/web/backend-auth
- For Facebook: https://developers.facebook.com/docs/facebook-login/manually-build-a-login-flow/#logindialog

After completing these steps, you should have a working Golang web application that allows users to authenticate using OAuth 2.0 with Google or Facebook, displays their profile information, and stores this data in a PostgreSQL database.