January 22, 2026

Google Sheets to PostgreSQL, answers you can trust

Lisa Granqvist Partner Workflow Automation Expert

Get a free AI assessment → ⬇️ Use template

Your “source of truth” is probably a Google Sheet that started simple, then quietly turned into a fragile mess. One broken formula, one copy-paste mistake, one tab someone “cleaned up,” and suddenly your totals don’t match what finance expects.

This is where Sheets to Postgres automation pays off fast. Marketing leads stop arguing with ops about numbers. Business owners get the same answer twice in a row. And analysts who are tired of spreadsheet whack-a-mole finally get a clean reporting layer.

This workflow moves structured data from Google Sheets (or CSV) into PostgreSQL, then lets you ask questions in plain English and get consistent totals back. You’ll see what it automates, what you get out of it, and how to avoid the usual setup snags.

How This Automation Works

The full n8n workflow, from trigger to final output:

n8n Workflow Template: Google Sheets to PostgreSQL, answers you can trust

Click to explore

flowchart LR

    subgraph sg0["Google Drive Flow"]
        direction LR
        n0["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>create table query"]
        n1["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>create insertion query"]
        n2@{ icon: "mdi:play-circle", form: "rounded", label: "Google Drive Trigger", pos: "b", h: 48 }
        n6@{ icon: "mdi:swap-vertical", form: "rounded", label: "change_this", pos: "b", h: 48 }
        n7@{ icon: "mdi:swap-horizontal", form: "rounded", label: "is not in database", pos: "b", h: 48 }
        n8["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/postgres.svg' width='40' height='40' /></div><br/>table exists?"]
        n9@{ icon: "mdi:database", form: "rounded", label: "fetch sheet data", pos: "b", h: 48 }
        n10["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/postgres.svg' width='40' height='40' /></div><br/>remove table"]
        n11["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/postgres.svg' width='40' height='40' /></div><br/>create table"]
        n12["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/postgres.svg' width='40' height='40' /></div><br/>perform insertion"]
        n6 --> n8
        n11 --> n1
        n10 --> n0
        n8 --> n9
        n9 --> n7
        n0 --> n11
        n7 --> n0
        n7 --> n10
        n2 --> n6
        n1 --> n12
    end

    subgraph sg1["When chat message received Flow"]
        direction LR
        n3@{ icon: "mdi:wrench", form: "rounded", label: "execute_query_tool", pos: "b", h: 48 }
        n4@{ icon: "mdi:brain", form: "rounded", label: "Google Gemini Chat Model", pos: "b", h: 48 }
        n5@{ icon: "mdi:wrench", form: "rounded", label: "get_postgres_schema", pos: "b", h: 48 }
        n14@{ icon: "mdi:play-circle", form: "rounded", label: "When chat message received", pos: "b", h: 48 }
        n19@{ icon: "mdi:robot", form: "rounded", label: "AI Agent With SQL Query Prompt", pos: "b", h: 48 }
        n3 -.-> n19
        n5 -.-> n19
        n4 -.-> n19
        n14 --> n19
    end

    subgraph sg2["Execute Workflow Flow"]
        direction LR
        n13@{ icon: "mdi:play-circle", form: "rounded", label: "Execute Workflow Trigger", pos: "b", h: 48 }
        n15@{ icon: "mdi:swap-vertical", form: "rounded", label: "response output", pos: "b", h: 48 }
        n16["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/postgres.svg' width='40' height='40' /></div><br/>sql query executor"]
        n17["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/postgres.svg' width='40' height='40' /></div><br/>schema finder"]
        n18["<div style='background:#f5f5f5;padding:10px;border-radius:8px;display:inline-block;border:1px solid #e0e0e0'><img src='https://flowpast.com/wp-content/uploads/n8n-workflow-icons/code.svg' width='40' height='40' /></div><br/>schema to string"]
        n17 --> n18
        n16 --> n15
        n13 --> n16
        n13 --> n17
    end

    %% Styling
    classDef trigger fill:#e8f5e9,stroke:#388e3c,stroke-width:2px
    classDef ai fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
    classDef aiModel fill:#e8eaf6,stroke:#3f51b5,stroke-width:2px
    classDef decision fill:#fff8e1,stroke:#f9a825,stroke-width:2px
    classDef database fill:#fce4ec,stroke:#c2185b,stroke-width:2px
    classDef api fill:#fff3e0,stroke:#e65100,stroke-width:2px
    classDef code fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    classDef disabled stroke-dasharray: 5 5,opacity: 0.5
    class n2,n14,n13 trigger
    class n19 ai
    class n4 aiModel
    class n3,n5 ai
    class n7 decision
    class n8,n9,n10,n11,n12,n16,n17 database
    class n0,n1,n18 code
    classDef customIcon fill:none,stroke:none
    class n0,n1,n8,n10,n11,n12,n16,n17,n18 customIcon

The Problem: Spreadsheet Numbers You Can’t Defend

Google Sheets is great for collecting data. It’s not great for being interrogated like a database, especially when the questions get specific. “Total sales last week” sounds simple until dates are formatted inconsistently, a column header changes, or a filter is left on. Then you’re chasing the issue across tabs, fixing formulas, and trying to remember which version of the sheet was “correct” for last month’s report. The worst part is the confidence drain: even when the number looks right, you can’t fully prove it.

It adds up fast. Here’s where it breaks down in real teams.

Small formula edits ripple through the sheet, which means yesterday’s totals mysteriously change today.
Two people build two different pivots, and you waste an hour just arguing over definitions.
When someone asks a new question, you end up doing manual filtering and re-checking calculations instead of answering it.
Sharing a spreadsheet link feels “easy,” but it also invites accidental changes and silent errors.

The Solution: Put Sheet Data in PostgreSQL, Then Ask Questions

This n8n workflow takes the structured data you already keep in Google Sheets (or a CSV) and turns it into an actual reporting database in PostgreSQL. When a file changes in Google Drive, the workflow pulls the latest rows, inspects the column headers, and builds the SQL needed to create a matching table. If the table doesn’t exist, it creates it. If it does, it can rebuild it and repopulate so your database mirrors the sheet. Then, instead of writing SQL, you ask a plain-language question in chat. An AI agent translates your question into a SQL query, runs it against PostgreSQL, and returns the result with the speed and consistency you expect from a database.

The workflow starts with a Google Drive trigger (or manual run) to fetch your Sheet/CSV. It builds schema-aware SQL, creates or refreshes a PostgreSQL table, and inserts the rows. Finally, a chat trigger routes your question into an AI SQL agent, which queries PostgreSQL and formats the response.

What You Get: Automation vs. Results

What This Workflow Automates

Results You’ll Get

Pulls rows from a Google Sheet (or CSV) when a Drive file changes.
Detects your data structure and generates the table creation SQL automatically.
Creates or refreshes the PostgreSQL table, then inserts all rows.
Turns natural-language questions into SQL and executes them against Postgres.

Typical teams get back about 3 hours a week from fewer manual checks.
More consistent reporting, because calculations happen in one place.
Fewer disputes with stakeholders since queries are repeatable and auditable.
Faster answers to ad-hoc questions, even when the question changes daily.
A cleaner path to dashboards later (Looker Studio, Metabase, etc.).

Example: What This Looks Like

Say you have one finance sheet with 5 tabs, and each week you answer 10 “quick questions” from leadership. Manually, each question usually takes about 10 minutes of filtering, double-checking, and redoing a pivot, so you’re at roughly 100 minutes a week. With this workflow: you spend about 20 minutes one time to connect the sheet and database, then each new question is a chat message plus a few seconds for the query to run. That’s easily an hour or two back every week, and the answers stop drifting.

What You’ll Need

n8n instance (try n8n Cloud free)
Self-hosting option if you prefer (Hostinger works well)
Google Drive to trigger when your file updates.
Google Sheets as the structured data source.
PostgreSQL to store data for reliable querying.
OpenAI or Google Gemini to generate SQL from questions.

Skill level: Intermediate. You’ll connect accounts, add credentials, and confirm your table/data behavior (create vs. rebuild).

Don’t want to set this up yourself? Talk to an automation expert (free 15-minute consultation).

How It Works

A Google Drive change kicks things off. When the watched file updates, n8n grabs the sheet link and the configuration needed to read the right data.

The workflow inspects your columns and prepares the database. It checks if the PostgreSQL table exists, builds the “create table” SQL from your headers, and can drop/recreate the table when you want a clean refresh.

Rows move from Sheets into Postgres automatically. The workflow composes insert statements and loads your sheet data into PostgreSQL so you’re querying stable records, not formulas.

You ask a question in chat, the agent returns the number. A chat trigger sends your prompt to the AI agent, which uses your schema details to write SQL, runs it in Postgres, then formats a plain response you can paste into Slack or a report.

You can easily modify the refresh behavior to only append new rows instead of rebuilding tables each time based on your needs. See the full implementation guide below for customization options.

Step-by-Step Implementation Guide

Step 1: Configure the Drive File Watcher Trigger

This workflow starts when a specific Google Drive file changes, then passes the file context into the sheet-to-Postgres pipeline.

Add and open Drive File Watcher.
Set Trigger On to specificFile.
In File to Watch, select the spreadsheet file (this must match the sheet used later).
Credential Required: Connect your googleDriveOAuth2Api credentials.

Step 2: Connect Google Sheets

These nodes define which sheet to read and then fetch all rows from that sheet.

Open Configure Sheet Inputs and set table_url to https://docs.google.com/spreadsheets/d/[YOUR_ID]/edit?gid=0#gid=0.
Set sheet_name to product_list (this becomes the table suffix).
Open Retrieve Sheet Records and confirm Document ID uses {{ $('Configure Sheet Inputs').item.json.table_url }}.
Confirm Sheet Name uses {{ $('Configure Sheet Inputs').item.json.sheet_name }}.
Credential Required: Connect your googleSheetsOAuth2Api credentials.

Step 3: Configure Table Verification and Conditional Flow

The workflow checks if the destination table exists, then conditionally drops and recreates it before inserting new rows.

Open Verify Table Presence and confirm the query is SELECT EXISTS ( SELECT 1 FROM information_schema.tables WHERE table_name = 'ai_table_{{ $json.sheet_name }}' );.
Credential Required: Connect your postgres credentials in Verify Table Presence (this workflow uses multiple Postgres nodes).
Open Check Table Missing and confirm the condition uses {{ $('Verify Table Presence').item.json.exists }} with the boolean operator set to false.
Ensure the routing from Check Table Missing goes to Build Table SQL (true path) and to Drop Existing Table (false path), then to Build Table SQL.

⚠️ Common Pitfall: The sheet name in Configure Sheet Inputs must match the actual tab name in Google Sheets, or Verify Table Presence will check the wrong table name.

Step 4: Set Up SQL Generation and Insert Pipeline

These nodes build a dynamic CREATE TABLE statement and prepare parameterized inserts for Postgres.

Open Build Table SQL and keep the dynamic table name based on ai_table_{{ $('Configure Sheet Inputs').first().json.sheet_name }}.
Open Create New Table and ensure the query is set to {{ $json.query }}.
Credential Required: Connect your postgres credentials in Create New Table, Drop Existing Table, and Insert Rows.
Open Compose Insert SQL and keep the dynamic insert generation tied to Build Table SQL and Retrieve Sheet Records.
In Insert Rows, confirm the query uses {{$json.query}} and Query Replacement uses {{ $json.parameters }}.

Step 5: Set Up the AI Query Interface

This workflow includes an AI agent that can answer chat queries by looking up schema details and running SQL.

Open SQL Query Agent and review the system instructions (no changes required unless you want different behavior).
Ensure Gemini Chat Engine is connected as the language model for SQL Query Agent and set Model Name to models/gemini-2.0-flash.
Credential Required: Connect your googlePalmApi credentials in Gemini Chat Engine.
Confirm the tools Run Query Tool and Fetch DB Schema Tool are connected to SQL Query Agent. Add credentials to the parent SQL Query Agent if your tools require access.
Open Chat Message Trigger to enable manual chat-based testing of the agent.

⚠️ Common Pitfall: Tool nodes like Run Query Tool and Fetch DB Schema Tool inherit permissions from the parent agent—do not add credentials directly to the tool nodes.

Step 6: Configure Subflow Execution and Parallel SQL Branches

The workflow has a subflow trigger that runs two SQL branches at the same time and returns a combined response.

Open Subflow Trigger and keep it as the entry point for workflow execution from another workflow.
Subflow Trigger outputs to both Execute SQL Request and Lookup Schema Details in parallel.
In Execute SQL Request, confirm the query uses {{ $json.query.sql }}.
Credential Required: Connect your postgres credentials in Execute SQL Request and Lookup Schema Details.
Ensure Lookup Schema Details feeds into Schema Text Builder to format schema output.
In Prepare Response Payload, keep response set to {{ $json }}.

Step 7: Test and Activate Your Workflow

Run tests from both triggers to validate the sheet-to-database flow and the AI query interface.

Click Execute Workflow and modify the watched file to trigger Drive File Watcher.
Verify a new table named ai_table_product_list is created and populated in Postgres.
Use Chat Message Trigger to send a test question and confirm the agent returns results from Postgres.
Check Prepare Response Payload for a structured response when using Subflow Trigger.
Once validated, toggle the workflow to Active for production use.

🔒

Unlock Full Step-by-Step Guide

Get the complete implementation guide + downloadable template

Common Gotchas

Google Drive credentials can expire or need specific permissions. If things break, check the n8n credential settings and the file’s sharing access first.
If you’re using Wait nodes or external rendering, processing times vary. Bump up the wait duration if downstream nodes fail on empty responses.
Default prompts in AI nodes are generic. Add your brand voice early or you’ll be editing outputs forever.

Frequently Asked Questions

How long does it take to set up this Sheets to Postgres automation?

About 30 minutes if your database and sheet are ready.

Do I need coding skills to automate Sheets to Postgres reporting?

No coding required. You’ll mostly paste credentials, choose a sheet, and test a couple of questions.

Is n8n free to use for this Sheets to Postgres workflow?

Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in AI model usage costs (often just a few dollars a month for light querying).

Where can I host n8n to run this automation?

Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.

Can I customize this Sheets to Postgres workflow for daily syncing instead of manual refresh?

Yes, and it’s a common tweak. Add a Schedule Trigger and route it into the same “Retrieve Sheet Records → table check → insert rows” path. If you don’t want the table dropped each run, keep the “Drop Existing Table” branch off and switch inserts to append-only. Some teams also add a “last_updated” column so the agent can filter by fresh data.

Why is my Google Sheets connection failing in this workflow?

Most of the time it’s permissions. Make sure the sheet is shared with the Google account tied to your n8n credentials, and confirm the sheet name matches what the workflow expects. If you’re using a URL from Drive, verify the file is still in the same location and hasn’t been replaced. Also check for rate limits if you’re pulling lots of rows at once.

How many records can this Sheets to Postgres automation handle?

If you self-host n8n, there’s no fixed execution limit and record volume mostly depends on your server and Postgres performance. On n8n Cloud, your limit depends on your plan’s monthly executions, but most small reporting syncs fit comfortably. Practically, thousands of rows per sync is normal; if you’re pushing very large sheets, you may want batching and incremental updates.

Is this Sheets to Postgres automation better than using Zapier or Make?

Often, yes. This workflow isn’t just “move rows”; it also builds schema-aware SQL and runs dynamic queries, which is where no-code tools can get awkward or expensive. n8n also gives you branching, database control, and the option to self-host for higher volume without surprise bills. If you only need a basic two-step sync, Zapier or Make can be quicker. If you want trustworthy numbers and a real query layer, this setup wins more often than not. Talk to an automation expert if you want a quick recommendation.

Once your sheet data lives in PostgreSQL, your reporting stops being a guessing game. The workflow handles the repetitive plumbing so you can focus on decisions, not debugging totals.

Need Help Setting This Up?

Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.

Lisa Granqvist

Workflow Automation Expert

Expert in workflow automation and no-code tools.

{
"id": null,
"meta": {
"instanceId": "831c322def2898044f7dfd9da9baec29fff0bbc01f092d37674a8c9703a730f0",
"templateId": null,
"templateCredsSetupCompleted": null
},
"name": "Automated Sheet SQL Retrieval",
"tags": [],
"nodes": [
{
"id": "flowpast-topbar-3079",
"name": "Flowpast Branding",
"type": "n8n-nodes-base.stickyNote",
"position": [
0,
50
],
"parameters": {
"color": 7,
"width": 1790,
"height": 80,
"content": "## Flowpast.com | Automation Workflow Library\n**\ud83d\udcd6 Full tutorial & setup guide:** flowpast.com"
},
"typeVersion": 1
},
{
"id": "a073154f-53ad-45e2-9937-d0a4196c7838",
"name": "Build Table SQL",
"type": "n8n-nodes-base.code",
"position": [
1440,
400
],
"parameters": {
"jsCode": "// Helper function to check if a string is in MM/DD/YYYY format\nfunction isDateString(value) {\n  const dateRegex = /^\\d{2}\\/\\d{2}\\/\\d{4}$/;\n  if (typeof value !== 'string') return false;\n  if (!dateRegex.test(value)) return false;\n  const [month, day, year] = value.split('/').map(Number);\n  const date = new Date(year, month - 1, day);\n  return !isNaN(date.getTime());\n}\n\nconst tableName = `ai_table_${$('Configure Sheet Inputs').first().json.sheet_name}`;\nconst rows = $('Retrieve Sheet Records').all();\nconst allColumns = new Set();\n\n// Collect column names dynamically\nrows.forEach(row => {\n  Object.keys(row.json).forEach(col => allColumns.add(col));\n});\n\n// Ensure \"ai_table_identifier\" is always the first column\nconst originalColumns = [\"ai_table_identifier\", ...Array.from(allColumns)];\n\n// Function to detect currency type (unchanged)\nfunction detectCurrency(values) {\n  const currencySymbols = {\n    '\u20b9': 'INR', '$': 'USD', '\u20ac': 'EUR', '\u00a3': 'GBP', '\u00a5': 'JPY',\n    '\u20a9': 'KRW', '\u0e3f': 'THB', 'z\u0142': 'PLN', 'kr': 'SEK', 'R$': 'BRL',\n    'C$': 'CAD', 'A$': 'AUD'\n  };\n\n  let detectedCurrency = null;\n  for (const value of values) {\n    if (typeof value === 'string' && value.trim() !== '') {\n      for (const [symbol, code] of Object.entries(currencySymbols)) {\n        if (value.trim().startsWith(symbol)) {\n          detectedCurrency = code;\n          break;\n        }\n      }\n    }\n  }\n  return detectedCurrency;\n}\n\n// Function to generate consistent column names\nfunction generateColumnName(originalName, typeInfo) {\n  if (typeInfo.isCurrency) {\n    return `${originalName}_${typeInfo.currencyCode.toLowerCase()}`;\n  }\n  return originalName;\n}\n\n// Infer column types and transform names\nconst columnMapping = {};\noriginalColumns.forEach(col => {\n  let typeInfo = { type: \"TEXT\" };\n\n  if (col !== \"ai_table_identifier\") {\n    const sampleValues = rows\n      .map(row => row.json[col])\n      .filter(value => value !== undefined && value !== null);\n\n    // Check for currency first\n    const currencyCode = detectCurrency(sampleValues);\n    if (currencyCode) {\n      typeInfo = { type: \"DECIMAL(15,2)\", isCurrency: true, currencyCode };\n    }\n    // If all sample values match MM/DD/YYYY, treat the column as a date\n    else if (sampleValues.length > 0 && sampleValues.every(val => isDateString(val))) {\n      typeInfo = { type: \"TIMESTAMP\" };\n    }\n  }\n\n  const newColumnName = generateColumnName(col, typeInfo);\n  columnMapping[col] = { newName: newColumnName, typeInfo };\n});\n\n// Final column names\nconst mappedColumns = originalColumns.map(col => columnMapping[col]?.newName || col);\n\n// Define SQL columns \u2013 note that for simplicity, this example still uses TEXT for non-special types,\n// but you can adjust it so that TIMESTAMP columns are created with a TIMESTAMP type.\nconst columnDefinitions = [`\"ai_table_identifier\" UUID PRIMARY KEY DEFAULT gen_random_uuid()`]\n  .concat(mappedColumns.slice(1).map(col => {\n    // If the column was inferred as TIMESTAMP, use that type in the CREATE TABLE statement.\n    const originalCol = Object.keys(columnMapping).find(key => columnMapping[key].newName === col);\n    const inferredType = columnMapping[originalCol]?.typeInfo?.type;\n    return `\"${col}\" ${inferredType === \"TIMESTAMP\" ? \"TIMESTAMP\" : \"TEXT\"}`;\n  }))\n  .join(\", \");\n\nconst createTableQuery = `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefinitions});`;\n\nreturn [{ \n  query: createTableQuery,\n  columnMapping: columnMapping \n}];\n"
},
"typeVersion": 2
},
{
"id": "2beb72c4-dab4-4058-b587-545a8ce8b86d",
"name": "Compose Insert SQL",
"type": "n8n-nodes-base.code",
"position": [
950,
410
],
"parameters": {
"jsCode": "const tableName = `ai_table_${$('Configure Sheet Inputs').first().json.sheet_name}`;\nconst rows = $('Retrieve Sheet Records').all();\nconst allColumns = new Set();\n\n// Get column mapping from previous node\nconst columnMapping = $('Build Table SQL').first().json.columnMapping || {};\n\n// Collect column names dynamically\nrows.forEach(row => {\n  Object.keys(row.json).forEach(col => allColumns.add(col));\n});\n\nconst originalColumns = Array.from(allColumns);\nconst mappedColumns = originalColumns.map(col => \n  columnMapping[col] ? columnMapping[col].newName : col\n);\n\n// Helper function to check if a string is a valid timestamp\nfunction isValidTimestamp(value) {\n  const date = new Date(value);\n  return !isNaN(date.getTime());\n}\n\n// Helper to detect currency symbol (unchanged)\nfunction getCurrencySymbol(value) {\n  if (typeof value !== 'string') return null;\n  \n  const currencySymbols = ['\u20b9', '$', '\u20ac', '\u00a3', '\u00a5', '\u20a9', '\u0e3f', 'z\u0142', 'kr', 'R$', 'C$', 'A$'];\n  for (const symbol of currencySymbols) {\n    if (value.trim().startsWith(symbol)) {\n      return symbol;\n    }\n  }\n  return null;\n}\n\n// Helper to normalize currency values (unchanged)\nfunction normalizeCurrencyValue(value, currencySymbol) {\n  if (typeof value !== 'string') return null;\n  if (!currencySymbol) return value;\n  \n  const numericPart = value.replace(currencySymbol, '').replace(/,/g, '');\n  return !isNaN(parseFloat(numericPart)) ? parseFloat(numericPart) : null;\n}\n\n// Helper to normalize percentage values (unchanged)\nfunction normalizePercentageValue(value) {\n  if (typeof value !== 'string') return value;\n  if (!value.trim().endsWith('%')) return value;\n  \n  const numericPart = value.replace('%', '');\n  return !isNaN(parseFloat(numericPart)) ? parseFloat(numericPart) / 100 : null;\n}\n\n// Function to parse MM/DD/YYYY strings into ISO format\nfunction parseDateString(value) {\n  const dateRegex = /^\\d{2}\\/\\d{2}\\/\\d{4}$/;\n  if (typeof value === 'string' && dateRegex.test(value)) {\n    const [month, day, year] = value.split('/').map(Number);\n    const date = new Date(year, month - 1, day);\n    return !isNaN(date.getTime()) ? date.toISOString() : null;\n  }\n  return value;\n}\n\n// Format rows properly based on column mappings and types\nconst formattedRows = rows.map(row => {\n  const formattedRow = {};\n\n  originalColumns.forEach((col, index) => {\n    const mappedCol = mappedColumns[index];\n    let value = row.json[col];\n    const typeInfo = columnMapping[col]?.typeInfo || { type: \"TEXT\" };\n\n    if (value === \"\" || value === null || value === undefined) {\n      value = null;\n    } \n    else if (typeInfo.isCurrency) {\n      const symbol = getCurrencySymbol(value);\n      if (symbol) {\n        value = normalizeCurrencyValue(value, symbol);\n      } else {\n        value = null;\n      }\n    }\n    else if (typeInfo.isPercentage) {\n      if (typeof value === 'string' && value.trim().endsWith('%')) {\n        value = normalizePercentageValue(value);\n      } else {\n        value = !isNaN(parseFloat(value)) ? parseFloat(value) / 100 : null;\n      }\n    }\n    else if (typeInfo.type === \"DECIMAL(15,2)\" || typeInfo.type === \"INTEGER\") {\n      if (typeof value === 'string') {\n        const cleanedValue = value.replace(/,/g, '');\n        value = !isNaN(parseFloat(cleanedValue)) ? parseFloat(cleanedValue) : null;\n      } else if (typeof value === 'number') {\n        value = parseFloat(value);\n      } else {\n        value = null;\n      }\n    } \n    else if (typeInfo.type === \"BOOLEAN\") {\n      if (typeof value === 'string') {\n        const lowercased = value.toString().toLowerCase();\n        value = lowercased === \"true\" ? true : \n                lowercased === \"false\" ? false : null;\n      } else {\n        value = Boolean(value);\n      }\n    } \n    else if (typeInfo.type === \"TIMESTAMP\") {\n      // Check if the value is in MM/DD/YYYY format and parse it accordingly.\n      if (/^\\d{2}\\/\\d{2}\\/\\d{4}$/.test(value)) {\n        value = parseDateString(value);\n      } else if (isValidTimestamp(value)) {\n        value = new Date(value).toISOString();\n      } else {\n        value = null;\n      }\n    }\n    else if (typeInfo.type === \"TEXT\") {\n      value = value !== null && value !== undefined ? String(value) : null;\n    }\n\n    formattedRow[mappedCol] = value;\n  });\n\n  return formattedRow;\n});\n\n// Generate SQL placeholders dynamically\nconst valuePlaceholders = formattedRows.map((_, rowIndex) =>\n  `(${mappedColumns.map((_, colIndex) => `$${rowIndex * mappedColumns.length + colIndex + 1}`).join(\", \")})`\n).join(\", \");\n\n// Build the insert query string\nconst insertQuery = `INSERT INTO ${tableName} (${mappedColumns.map(col => `\"${col}\"`).join(\", \")}) VALUES ${valuePlaceholders};`;\n\n// Flatten parameter values for PostgreSQL query\nconst parameters = formattedRows.flatMap(row => mappedColumns.map(col => row[col]));\n\nreturn [\n  {\n    query: insertQuery,\n    parameters: parameters\n  }\n];\n"
},
"typeVersion": 2
},
{
"id": "ba19c350-ffb7-4fe1-9568-2a619c914434",
"name": "Drive File Watcher",
"type": "n8n-nodes-base.googleDriveTrigger",
"position": [
730,
200
],
"parameters": {
"pollTimes": {
"item": [
[]
]
},
"triggerOn": "specificFile",
"fileToWatch": {
"__rl": true,
"mode": "list",
"value": "[YOUR_ID]",
"cachedResultUrl": "https://docs.google.com/spreadsheets/d/[YOUR_ID]/edit",
"cachedResultName": "Spreadsheet"
}
},
"credentials": {
"googleDriveOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 1
},
{
"id": "dd2108fe-0cfe-453c-ac03-c0c5b10397e6",
"name": "Run Query Tool",
"type": "@n8n/n8n-nodes-langchain.toolWorkflow",
"position": [
590,
440
],
"parameters": {
"name": "query_executer",
"schemaType": "manual",
"workflowId": {
"__rl": true,
"mode": "list",
"value": "",
"cachedResultName": ""
},
"description": "Call this tool to execute a query. Remember that it should be in a postgreSQL query structure.",
"inputSchema": "{\n\"type\": \"object\",\n\"properties\": {\n\t\"sql\": {\n\t\t\"type\": \"string\",\n\t\t\"description\": \"A SQL query based on the users question and database schema.\"\n\t\t}\n\t}\n}",
"specifyInputSchema": true
},
"typeVersion": 1.2
},
{
"id": "f2c110db-1097-4b96-830d-f028e08b6713",
"name": "Gemini Chat Engine",
"type": "@n8n/n8n-nodes-langchain.lmChatGoogleGemini",
"position": [
380,
150
],
"parameters": {
"options": [],
"modelName": "models/gemini-2.0-flash"
},
"credentials": {
"googlePalmApi": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 1
},
{
"id": "2460801c-5b64-41b3-93f7-4f2fbffabfd6",
"name": "Fetch DB Schema Tool",
"type": "@n8n/n8n-nodes-langchain.toolWorkflow",
"position": [
230,
450
],
"parameters": {
"name": "get_postgres_schema",
"workflowId": {
"__rl": true,
"mode": "list",
"value": "",
"cachedResultName": ""
},
"description": "Call this tool to retrieve the schema of all the tables inside of the database. A string will be retrieved with the name of the table and its columns, each table is separated by \\n\\n.",
"workflowInputs": {
"value": [],
"schema": [],
"mappingMode": "defineBelow",
"matchingColumns": [],
"attemptToConvertTypes": false,
"convertFieldsToString": false
}
},
"typeVersion": 2
},
{
"id": "4b43ff94-df0d-40f1-9f51-cf488e33ff68",
"name": "Configure Sheet Inputs",
"type": "n8n-nodes-base.set",
"position": [
920,
210
],
"parameters": {
"options": [],
"assignments": {
"assignments": [
{
"id": "908ed843-f848-4290-9cdb-f195d2189d7c",
"name": "table_url",
"type": "string",
"value": "https://docs.google.com/spreadsheets/d/[YOUR_ID]/edit?gid=0#gid=0"
},
{
"id": "50f8afaf-0a6c-43ee-9157-79408fe3617a",
"name": "sheet_name",
"type": "string",
"value": "product_list"
}
]
}
},
"typeVersion": 3.4
},
{
"id": "a27a47ff-9328-4eef-99e8-280452cff189",
"name": "Check Table Missing",
"type": "n8n-nodes-base.if",
"position": [
1690,
210
],
"parameters": {
"options": [],
"conditions": {
"options": {
"version": 2,
"leftValue": "",
"caseSensitive": true,
"typeValidation": "strict"
},
"combinator": "and",
"conditions": [
{
"id": "619ce84c-0a50-4f88-8e55-0ce529aea1fc",
"operator": {
"type": "boolean",
"operation": "false",
"singleValue": true
},
"leftValue": "={{ $('Verify Table Presence').item.json.exists }}",
"rightValue": "true"
}
]
}
},
"typeVersion": 2.2
},
{
"id": "8ad9bc36-08b1-408e-ba20-5618a801b4ed",
"name": "Verify Table Presence",
"type": "n8n-nodes-base.postgres",
"position": [
1200,
190
],
"parameters": {
"query": "SELECT EXISTS (\n    SELECT 1 \n    FROM information_schema.tables \n    WHERE table_name = 'ai_table_{{ $json.sheet_name }}'\n);\n",
"options": [],
"operation": "executeQuery"
},
"credentials": {
"postgres": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.5
},
{
"id": "f66b7ca7-ecb7-47fc-9214-2d2b37b0fbe4",
"name": "Retrieve Sheet Records",
"type": "n8n-nodes-base.googleSheets",
"position": [
1390,
220
],
"parameters": {
"options": [],
"sheetName": {
"__rl": true,
"mode": "name",
"value": "={{ $('Configure Sheet Inputs').item.json.sheet_name }}"
},
"documentId": {
"__rl": true,
"mode": "url",
"value": "={{ $('Configure Sheet Inputs').item.json.table_url }}"
}
},
"credentials": {
"googleSheetsOAuth2Api": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 4.5
},
{
"id": "11ba5da0-e7c4-49ee-8d35-24c8d3b9fea9",
"name": "Drop Existing Table",
"type": "n8n-nodes-base.postgres",
"position": [
1640,
410
],
"parameters": {
"query": "DROP TABLE IF EXISTS ai_table_{{ $('Configure Sheet Inputs').item.json.sheet_name }} CASCADE;",
"options": [],
"operation": "executeQuery"
},
"credentials": {
"postgres": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.5
},
{
"id": "3936ecb3-f084-4f86-bd5f-abab0957ebc0",
"name": "Create New Table",
"type": "n8n-nodes-base.postgres",
"position": [
1150,
420
],
"parameters": {
"query": "{{ $json.query }}",
"options": [],
"operation": "executeQuery"
},
"credentials": {
"postgres": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.5
},
{
"id": "8a3ea239-f3fa-4c72-af99-31f4bd992b58",
"name": "Insert Rows",
"type": "n8n-nodes-base.postgres",
"position": [
670,
400
],
"parameters": {
"query": "{{$json.query}}",
"options": {
"queryReplacement": "={{$json.parameters}}"
},
"operation": "executeQuery"
},
"credentials": {
"postgres": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.5
},
{
"id": "21239928-b573-4753-a7ca-5a9c3aa8aa3e",
"name": "Subflow Trigger",
"type": "n8n-nodes-base.executeWorkflowTrigger",
"position": [
0,
600
],
"parameters": [],
"typeVersion": 1
},
{
"id": "8908e342-fcbe-4820-b623-cb95a55ea5db",
"name": "Chat Message Trigger",
"type": "@n8n/n8n-nodes-langchain.manualChatTrigger",
"position": [
60,
240
],
"parameters": [],
"typeVersion": 1.1
},
{
"id": "d0ae90c2-169e-44d7-b3c2-4aff8e7d4be9",
"name": "Prepare Response Payload",
"type": "n8n-nodes-base.set",
"position": [
650,
600
],
"parameters": {
"options": [],
"assignments": {
"assignments": [
{
"id": "e2f94fb1-3deb-466a-a36c-e3476511d5f2",
"name": "response",
"type": "string",
"value": "={{ $json }}"
}
]
}
},
"typeVersion": 3.4
},
{
"id": "81c58d9b-ded4-4b74-8227-849e665cbdff",
"name": "Execute SQL Request",
"type": "n8n-nodes-base.postgres",
"position": [
320,
600
],
"parameters": {
"query": "{{ $json.query.sql }}",
"options": [],
"operation": "executeQuery"
},
"credentials": {
"postgres": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.5
},
{
"id": "377d1727-4577-41bb-8656-38273fc4412b",
"name": "Lookup Schema Details",
"type": "n8n-nodes-base.postgres",
"position": [
300,
800
],
"parameters": {
"query": "SELECT \n    t.schemaname,\n    t.tablename,\n    c.column_name,\n    c.data_type\nFROM \n    pg_catalog.pg_tables t\nJOIN \n    information_schema.columns c\n    ON t.schemaname = c.table_schema\n    AND t.tablename = c.table_name\nWHERE \n    t.schemaname = 'public'\nORDER BY \n    t.tablename, c.ordinal_position;",
"options": [],
"operation": "executeQuery"
},
"credentials": {
"postgres": {
"id": "credential-id",
"name": ""
}
},
"typeVersion": 2.5
},
{
"id": "89d3c59c-2b67-454d-a8f3-e90e75a28a8c",
"name": "Schema Text Builder",
"type": "n8n-nodes-base.code",
"position": [
640,
800
],
"parameters": {
"jsCode": "function transformSchema(input) {\n    const tables = {};\n    \n    input.forEach(({ json }) => {\n        if (!json) return;\n        \n        const { tablename, schemaname, column_name, data_type } = json;\n        \n        if (!tables[tablename]) {\n            tables[tablename] = { schema: schemaname, columns: [] };\n        }\n        tables[tablename].columns.push(`${column_name} (${data_type})`);\n    });\n    \n    return Object.entries(tables)\n        .map(([tablename, { schema, columns }]) => `Table ${tablename} (Schema: ${schema}) has columns: ${columns.join(\", \")}`)\n        .join(\"\\n\\n\");\n}\n\n// Example usage\nconst input = $input.all();\n\nconst transformedSchema = transformSchema(input);\n\nreturn { data: transformedSchema };"
},
"typeVersion": 2
},
{
"id": "42d1b316-60ca-49db-959b-581b162ca1f9",
"name": "SQL Query Agent",
"type": "@n8n/n8n-nodes-langchain.agent",
"position": [
400,
260
],
"parameters": {
"options": {
"maxIterations": 5,
"systemMessage": "=## Role\nYou are a **Database Query Assistant** specializing in generating PostgreSQL queries based on natural language questions. You analyze database schemas, construct appropriate SQL queries, and provide clear explanations of results.\n\n## Tools\n1. `get_postgres_schema`: Retrieves the complete database schema (tables and columns)\n2. `execute_query_tool`: Executes SQL queries with the following input format:\n   ```json\n   {\n     \"sql\": \"Your SQL query here\"\n   }\n   ```\n\n## Process Flow\n\n### 1. Analyze the Question\n- Identify the **data entities** being requested (products, customers, orders, etc.)\n- Determine the **query type** (COUNT, AVG, SUM, SELECT, etc.)\n- Extract any **filters** or **conditions** mentioned\n\n### 2. Fetch and Analyze Schema\n- Call `get_postgres_schema` to retrieve database structure\n- Identify relevant tables and columns that match the entities in the question\n- Prioritize exact matches, then semantic matches\n\n### 3. Query Construction\n- Build case-insensitive queries using `LOWER(column) LIKE LOWER('%value%')`\n- Filter out NULL or empty values with appropriate WHERE clauses\n- Use joins when information spans multiple tables\n- Apply aggregations (COUNT, SUM, AVG) as needed\n\n### 4. Query Execution\n- Execute query using the `execute_query_tool` with proper formatting\n- If results require further processing, perform calculations as needed\n\n### 5. Result Presentation\n- Format results in a conversational, easy-to-understand manner\n- Explain how the data was retrieved and any calculations performed\n- When appropriate, suggest further questions the user might want to ask\n\n## Best Practices\n- Use parameterized queries to prevent SQL injection\n- Implement proper error handling\n- Respond with \"NOT_ENOUGH_INFO\" when the question lacks specificity\n- Always verify table/column existence before attempting queries\n- Use explicit JOINs instead of implicit joins\n- Limit large result sets when appropriate\n\n## Numeric Validation (IMPORTANT)\nWhen validating or filtering numeric values in string columns:\n1. **AVOID** complex regular expressions with `~` operator as they cause syntax errors\n2. Use these safer alternatives instead:\n   ```sql\n   -- Simple numeric check without regex\n   WHERE column_name IS NOT NULL AND trim(column_name) != '' AND column_name NOT LIKE '%[^0-9.]%'\n   \n   -- For type casting with validation\n   WHERE column_name IS NOT NULL AND trim(column_name) != '' AND column_name ~ '[0-9]'\n   \n   -- Safe numeric conversion\n   WHERE CASE WHEN column_name ~ '[0-9]' THEN TRUE ELSE FALSE END\n   ```\n3. For simple pattern matching, use LIKE instead of regex when possible\n4. When CAST is needed, always guard against invalid values:\n   ```sql\n   SELECT SUM(CASE WHEN column_name ~ '[0-9]' THEN CAST(column_name AS NUMERIC) ELSE 0 END) AS total\n   ```\n\n## Response Structure\n1. **Analysis**: Brief mention of how you understood the question\n2. **Query**: The SQL statement used (in code block format)\n3. **Results**: Clear presentation of the data found\n4. **Explanation**: Simple description of how the data was retrieved\n\n## Examples\n\n### Example 1: Basic Counting Query\n**Question**: \"How many products are in the inventory?\"\n\n**Process**:\n1. Analyze schema to find product/inventory tables\n2. Construct a COUNT query on the relevant table\n3. Execute the query\n4. Present the count with context\n\n**SQL**:\n```sql\nSELECT COUNT(*) AS product_count \nFROM products \nWHERE quantity IS NOT NULL;\n```\n\n**Response**:\n\"There are 1,250 products currently in the inventory. This count includes all items with a non-null quantity value in the products table.\"\n\n### Example 2: Filtered Aggregation Query\n**Question**: \"What is the average order value for premium customers?\"\n\n**Process**:\n1. Identify relevant tables (orders, customers)\n2. Determine join conditions\n3. Apply filters for \"premium\" customers\n4. Calculate average\n\n**SQL**:\n```sql\nSELECT AVG(o.total_amount) AS avg_order_value\nFROM orders o\nJOIN customers c ON o.customer_id = c.id\nWHERE LOWER(c.customer_type) = LOWER('premium')\nAND o.total_amount IS NOT NULL;\n```\n\n**Response**:\n\"Premium customers spend an average of $85.42 per order. This was calculated by averaging the total_amount from all orders placed by customers with a 'premium' customer type.\"\n\n### Example 3: Numeric Calculation from String Column\n**Question**: \"What is the total of all ratings?\"\n\n**Process**:\n1. Find the ratings table and column\n2. Use safe numeric validation\n3. Sum the values\n\n**SQL**:\n```sql\nSELECT SUM(CASE WHEN rating ~ '[0-9]' THEN CAST(rating AS NUMERIC) ELSE 0 END) AS total_rating\nFROM ratings\nWHERE rating IS NOT NULL AND trim(rating) != '';\n```\n\n**Response**:\n\"The sum of all ratings is 4,285. This calculation includes all valid numeric ratings from the ratings table.\"\n\n### Example 4: Date Range Aggregation for Revenue  \n**Question**: \"How much did I make last week?\"  \n\n**Process**:  \n1. Identify the sales table and relevant columns (e.g., `sale_date` for dates and `revenue_amount` for revenue).  \n2. Use PostgreSQL date functions (`date_trunc` and interval arithmetic) to calculate the date range for the previous week.  \n3. Sum the revenue within the computed date range.  \n\n**SQL**:  \n```sql\nSELECT SUM(revenue_amount) AS total_revenue\nFROM sales_data\nWHERE sale_date >= date_trunc('week', CURRENT_DATE) - INTERVAL '1 week'\n  AND sale_date < date_trunc('week', CURRENT_DATE);\n```  \n\n**Response**:  \n\"Last week's total revenue is calculated by summing the `revenue_amount` for records where the `sale_date` falls within the previous week. This query uses date functions to dynamically determine the correct date range.\"\n\nToday's date: {{ $now }}"
}
},
"typeVersion": 1.7
}
],
"active": false,
"pinData": [],
"settings": {
"executionOrder": "v1"
},
"versionId": null,
"connections": {
"Configure Sheet Inputs": {
"main": [
[
{
"node": "Verify Table Presence",
"type": "main",
"index": 0
}
]
]
},
"Create New Table": {
"main": [
[
{
"node": "Compose Insert SQL",
"type": "main",
"index": 0
}
]
]
},
"Drop Existing Table": {
"main": [
[
{
"node": "Build Table SQL",
"type": "main",
"index": 0
}
]
]
},
"Lookup Schema Details": {
"main": [
[
{
"node": "Schema Text Builder",
"type": "main",
"index": 0
}
]
]
},
"Verify Table Presence": {
"main": [
[
{
"node": "Retrieve Sheet Records",
"type": "main",
"index": 0
}
]
]
},
"Retrieve Sheet Records": {
"main": [
[
{
"node": "Check Table Missing",
"type": "main",
"index": 0
}
]
]
},
"Build Table SQL": {
"main": [
[
{
"node": "Create New Table",
"type": "main",
"index": 0
}
]
]
},
"Run Query Tool": {
"ai_tool": [
[
{
"node": "SQL Query Agent",
"type": "ai_tool",
"index": 0
}
]
]
},
"Check Table Missing": {
"main": [
[
{
"node": "Build Table SQL",
"type": "main",
"index": 0
}
],
[
{
"node": "Drop Existing Table",
"type": "main",
"index": 0
}
]
]
},
"Execute SQL Request": {
"main": [
[
{
"node": "Prepare Response Payload",
"type": "main",
"index": 0
}
]
]
},
"Fetch DB Schema Tool": {
"ai_tool": [
[
{
"node": "SQL Query Agent",
"type": "ai_tool",
"index": 0
}
]
]
},
"Drive File Watcher": {
"main": [
[
{
"node": "Configure Sheet Inputs",
"type": "main",
"index": 0
}
]
]
},
"Compose Insert SQL": {
"main": [
[
{
"node": "Insert Rows",
"type": "main",
"index": 0
}
]
]
},
"Subflow Trigger": {
"main": [
[
{
"node": "Execute SQL Request",
"type": "main",
"index": 0
},
{
"node": "Lookup Schema Details",
"type": "main",
"index": 0
}
]
]
},
"Gemini Chat Engine": {
"ai_languageModel": [
[
{
"node": "SQL Query Agent",
"type": "ai_languageModel",
"index": 0
}
]
]
},
"Chat Message Trigger": {
"main": [
[
{
"node": "SQL Query Agent",
"type": "main",
"index": 0
}
]
]
}
}
}