Delete 'Find & Join Feature in MongoDB and PostgreSQL.md'

5 months ago · 5142a24400
parent b2c28e9c4e
commit 5142a24400
1 changed files with 0 additions and 153 deletions
--- a/PostgreSQL.md
+++ b/PostgreSQL.md
@ -1,153 +0,0 @@
 ## Query Across SQL and NoSQL — Without Writing Code
 MongoDB and PostgreSQL are often used together in modern applications — each bringing unique strengths. While PostgreSQL offers structured, relational storage, MongoDB gives flexibility through document-based collections.
 But combining data from both in real time has always been a challenge. Traditionally, you’d have to:
 - Write custom backend logic to merge data
 - Create multiple API calls or aggregation pipelines
 - Maintain sync through fragile ETL workflows
 To solve this challenge, API Maker introduces the **Find & Join** feature.
 ## Why Use Find & Join for MongoDB and PostgreSQL
 Modern applications often use a **polyglot database architecture** — leveraging **MongoDB** for unstructured or flexible data and **PostgreSQL** for structured, relational data.
 While this separation is practical from a design and performance standpoint, it introduces a major challenge:
 **How do you fetch connected data across MongoDB and PostgreSQL in a single query** — without building and maintaining complex backend logic?
 This is exactly where **API Maker’s Find & Join feature** shines.
 It allows you to **perform deep, cross-database joins and filters between MongoDB and PostgreSQL** using a single, declarative JSON query — all through REST APIs.
 This page provides information on using the Find & Join feature specifically with MongoDB and PostgreSQL.  
 If you're looking for a general overview of the Find & Join feature, please refer to the - [Find & Join Feature](https://apimaker.dev/find-and-join)
 ## Schema Setup in Api Maker
 To enable Find & Join operations between MongoDB and PostgreSQL, you need to define relationships in your table/collection schema using **API Maker’s Table schema.**
 For a Detailed Information about the Schema Setup, you can refer to this page - [Schema Setup](https://docs.apimaker.dev/v1/docs/schema/schema.html)
 Once the schema is defined, API Maker can automatically resolve joins at runtime — even across different database types.
 ### Defining the Relationship in Schema
 Let’s say:
 - You have a **`users`** table in **PostgreSQL**
 - You have a **`profiles`** collection in **MongoDB**
 You want to use an API that supports the **Find & Join** feature on the `profiles` collection (MongoDB). In this case, you'd define the relationship like this:
 ```typescript
 user_id: <ISchemaProperty>{
    __type: EType.number,
    instance: "Postgres",
    database: "accounts_db",
 	table: "users",
 	column: "id"
 }
 ```
 Here what each field means: 
 - **`__type: EType.number :`** Indicates that the `user_id` field is a number (to match the PostgreSQL `id` column type).
 - **`instance: "Postgres" :`** Specifies the target database engine — in this case, PostgreSQL.
 - **`database: "accounts_db" :`** The name of the PostgreSQL database where the `users` table resides.
 - **`table: "users" :`** The relational table in PostgreSQL to which the `user_id` field will be linked.
 - **`column: "id" :`** The specific column in the `users` table that the `user_id` field refers to.
 With this schema defined, API Maker can:
 - Automatically recognize and resolve the relationship between MongoDB and PostgreSQL
 - Enable join queries like `user_id.name` directly in your REST API calls
 - Eliminate the need for custom backend join logic — it's all handled for you at runtime
 ## Sample Query Examples :
 Once you've defined relationships between your MongoDB collections and PostgreSQL tables in the schema, you can use the **Find & Join** feature directly in your API calls — without writing any backend logic.
 API Maker supports the Find & Join Feature in both the :
 - **GET requests** (using URL query parameters)
 - **POST requests** (using request body for advanced querying)
 ### **Example Scenario**
 You have:
 - A `users` table in **PostgreSQL**
 - A `profiles` collection in **MongoDB** with a field `user_id` referencing `users.id`
 **1. GET API Example (Using URL Query Parameter) :**
 Use the `find` Query parameter in your auto-generated GET API to filter across relationships.
 **Request:** 
 ```http
 GET /api/profiles?find={ "user_id.name": "Alice" }
 ```
 This query fetches all `profiles` (from MongoDB) where the related `user` (from PostgreSQL) has the name `"Alice"`.
 **2. POST API Example :**
 POST APIs give you more flexibility — allowing you to send a `find` object along with additional options like `sort`, `limit`, and `deep`.
 **Request:**
 ```http
 POST /api/query/profiles
 Content-Type: application/json
 {
  "find": {
    "user_id.signup_date": { "$gt": "2024-01-01" },
    "user_id.role": "admin"
  },
  "limit": 10,
  "sort": {
    "user_id.signup_date": -1
  }
 }
 ```
 This will return up to 10 profiles linked to PostgreSQL users who signed up after January 1st, 2024 and have the role `"admin"` — sorted by most recent signup.
 To explore all REST APIs that support **Find & Join**, check out the [auto-generated REST APIs](https://docs.apimaker.dev/v1/docs/apis-all/generated-apis/auto-generated-get-all-api.html) and [schema-based REST APIs](https://docs.apimaker.dev/v1/docs/apis-all/schema-apis/auto-generated-schema-based-get-all-api.html) available on the [API Maker Docs Page](https://docs.apimaker.dev/).
 ## Comparison to Traditional Methods & Other Platforms
 Joining data between **MongoDB** and **PostgreSQL** has traditionally been a complex, manual process for developers.
 **Traditional Methods:**
 Before tools like API Maker, developers had to:
 - Write custom backend code to connect and query both databases
 - Manually merge results at the application level
 - Build and maintain fragile ETL pipelines
 - Handle sync issues and performance bottlenecks
 These methods are time-consuming and hard to scale — especially when relationships become more complex.
 How API Maker Simplifies Cross Database Joins and Conditional Filtering :
 - **No backend logic** required
 - **Schema-based joins** resolved automatically at runtime
 - **Real-time querying** across different databases
 - Simple REST API interface — easy to use from frontend or backend
 ### Compared to Other Platforms 
 | Feature                       | **API Maker** | **Appwrite** | **Supabase** | **Firebase**   |
 | ----------------------------- | ------------- | ------------ | ------------ | -------------- |
 | Cross-DB Joins (Mongo + SQL)  | Yes           | No           | No           | No             |
 | N-Level Nested Joins          | Unlimited     | No           | Basic        | No             |
 | REST Support for Join Queries | Full          | Partial      | Yes          | Firestore only |
 | Schema-Based Join Logic       | Yes           | No           | Limited      | No             |
 | Works with Mongo + PostgreSQL | Yes           | No           | No           | No             |
 **API Maker** is the only platform among these that offers **real-time, schema-aware, cross database joins** between MongoDB and PostgreSQL — with **no backend logic required**.
 ## FAQ's 
 1. **Can I join MongoDB collections with PostgreSQL tables in both directions?**
 	Yes. As long as the relationship is defined in your schema, you can perform joins in either direction — **`MongoDB`** → **`PostgreSQL`** or **`PostgreSQL`** → **`MongoDB`** — using the same query structure.
 2. **How do I filter on PostgreSQL fields from within a MongoDB collection?**
 	You can use nested dot notation based on your schema definition. 
 	For example: `{ "user_id.role": "admin" }`.
 	In this case, `user_id` is a reference from the MongoDB `profiles` collection to the PostgreSQL `users` table.
 3. **Is performance impacted by cross-database joins?**
 	API Maker optimizes cross-database joins at runtime.
 	For best performance, make sure to **index the join keys** in both MongoDB and PostgreSQL.