npm install pg

const { Client } = require('pg');

const client = new Client({
  connectionString: 'postgresql://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require',
  ssl: { rejectUnauthorized: false }
});

await client.connect();
const { rows } = await client.query('SELECT id, name, balance FROM accounts');
await client.end();

const { Sequelize } = require('sequelize');

const sequelize = new Sequelize(
  'postgresql://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require',
  { dialectOptions: { ssl: { require: true } } }
);

const Account = sequelize.define('Account', {
  name: { type: DataTypes.STRING(255), allowNull: false },
  email: { type: DataTypes.STRING(255), allowNull: false, unique: true },
  balance: { type: DataTypes.DECIMAL(15, 2), defaultValue: 0 },
}, { tableName: 'accounts', timestamps: true });

await Account.create({ name: 'Alice', email: 'alice@test.com', balance: 1000 });

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["driverAdapters"]
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model Account {
  id        Int      @id @default(autoincrement())
  name      String   @db.VarChar(255)
  email     String   @unique @db.VarChar(255)
  balance   Decimal  @default(0) @db.Decimal(15, 2)
  createdAt DateTime @default(now()) @map("created_at")

  @@map("accounts")
}

DATABASE_URL="postgresql://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require"

const { PrismaClient } = require('@prisma/client')
const { PrismaPg } = require('@prisma/adapter-pg')
const { Pool } = require('pg')

const pool = new Pool({ connectionString: process.env.DATABASE_URL })
const adapter = new PrismaPg(pool)
const prisma = new PrismaClient({ adapter })

await prisma.account.create({
  data: { name: 'Alice', email: 'alice@test.com', balance: 1000 }
})

npm install prisma @prisma/client @prisma/adapter-pg pg

pip install psycopg[binary]      # psycopg 3, recommended
pip install asyncpg              # async
pip install psycopg2-binary      # psycopg 2, legacy

import psycopg

with psycopg.connect(
    "postgresql://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require"
) as conn:
    with conn.cursor() as cur:
        cur.execute("SELECT id, name, balance FROM accounts")
        for row in cur.fetchall():
            print(row)

import asyncio, asyncpg

async def main():
    conn = await asyncpg.connect(
        "postgresql://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require"
    )
    rows = await conn.fetch("SELECT id, name, balance FROM accounts")
    for row in rows:
        print(row)
    await conn.close()

asyncio.run(main())

from sqlalchemy import create_engine, Column, Integer, String, Numeric, DateTime
from sqlalchemy.orm import declarative_base, Session
from datetime import datetime

Base = declarative_base()

class Account(Base):
    __tablename__ = 'accounts'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(255), nullable=False)
    email = Column(String(255), unique=True, nullable=False)
    balance = Column(Numeric(15, 2), default=0)
    created_at = Column(DateTime, default=datetime.utcnow)

engine = create_engine(
    "postgresql+psycopg://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require"
)

with Session(engine) as s:
    s.add(Account(name='Alice', email='alice@test.com', balance=1000))
    s.commit()

go get github.com/jackc/pgx/v5

package main

import (
    "context"
    "fmt"

    "github.com/jackc/pgx/v5"
)

func main() {
    ctx := context.Background()
    conn, err := pgx.Connect(ctx,
        "postgresql://tdb_2abf90d3:tdb_4f2c9d1ab7e8350c@pg.tenantsdb.com:5432/myapp__wayne?sslmode=require")
    if err != nil { panic(err) }
    defer conn.Close(ctx)

    rows, _ := conn.Query(ctx, "SELECT id, name, balance FROM accounts")
    for rows.Next() {
        var id int
        var name string
        var balance float64
        rows.Scan(&id, &name, &balance)
        fmt.Printf("%d: %s ($%.2f)\n", id, name, balance)
    }
}

import (
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

type Account struct {
    ID      uint    `gorm:"primaryKey"`
    Name    string  `gorm:"size:255;not null"`
    Email   string  `gorm:"size:255;uniqueIndex;not null"`
    Balance float64 `gorm:"type:decimal(15,2);default:0"`
}

// Workspace connection for schema work uses the project or workspace pw.
dsn := "postgresql://tdb_2abf90d3:tdb_d2bf66ed7898c448@pg.tenantsdb.com:5432/myapp_workspace?sslmode=require"
db, _ := gorm.Open(postgres.Open(dsn), &gorm.Config{})

// AutoMigrate against the workspace; the DDL is captured as a blueprint.
db.AutoMigrate(&Account{})

<dependency>
  <groupId>org.postgresql</groupId>
  <artifactId>postgresql</artifactId>
  <version>42.7.4</version>
</dependency>

import java.sql.*;
import java.util.Properties;

String url = "jdbc:postgresql://pg.tenantsdb.com:5432/myapp__wayne?sslmode=require";
Properties props = new Properties();
props.setProperty("user", "tdb_2abf90d3");
props.setProperty("password", "tdb_4f2c9d1ab7e8350c");

try (Connection conn = DriverManager.getConnection(url, props);
     Statement s = conn.createStatement();
     ResultSet rs = s.executeQuery("SELECT id, name, balance FROM accounts")) {
    while (rs.next()) {
        System.out.printf("%d: %s ($%.2f)%n",
            rs.getInt("id"), rs.getString("name"), rs.getBigDecimal("balance"));
    }
}

gem install pg

require 'pg'

conn = PG.connect(
  host: 'pg.tenantsdb.com',
  port: 5432,
  dbname: 'myapp__wayne',
  user: 'tdb_2abf90d3',
  password: 'tdb_4f2c9d1ab7e8350c',
  sslmode: 'require'
)

conn.exec('SELECT id, name, balance FROM accounts') do |result|
  result.each { |row| puts row }
end

conn.close

production:
  adapter: postgresql
  host: pg.tenantsdb.com
  port: 5432
  database: myapp__wayne
  username: tdb_2abf90d3
  password: tdb_4f2c9d1ab7e8350c
  sslmode: require