MindsDB 25.7.3.0__py3-none-any.whl → 25.7.4.0__py3-none-any.whl

mindsdb/integrations/handlers/pgvector_handler/pgvector_handler.py

@@ -5,7 +5,19 @@ from urllib.parse import urlparse
 
 import pandas as pd
 import psycopg
-from mindsdb_sql_parser.ast import Parameter, Identifier, Update, BinaryOperation
+from mindsdb_sql_parser.ast import (
+    Parameter,
+    Identifier,
+    BinaryOperation,
+    Tuple as AstTuple,
+    Constant,
+    Select,
+    OrderBy,
+    TypeCast,
+    Delete,
+    Update,
+    Function,
+)
 from pgvector.psycopg import register_vector
 
 from mindsdb.integrations.handlers.postgres_handler.postgres_handler import (
@@ -17,6 +29,7 @@ from mindsdb.integrations.libs.vectordatabase_handler import (
     VectorStoreHandler,
     DistanceFunction,
     TableField,
+    FilterOperator,
 )
 from mindsdb.integrations.libs.keyword_search_base import KeywordSearchBase
 from mindsdb.integrations.utilities.sql_utils import KeywordSearchArgs
@@ -169,31 +182,42 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         embedding_condition = None
 
         for condition in conditions:
+            is_embedding = condition.column == "embeddings"
+
             parts = condition.column.split(".")
-            key = parts[0]
+            key = Identifier(parts[0])
+
             # converts 'col.el1.el2' to col->'el1'->>'el2'
             if len(parts) > 1:
                 # intermediate elements
                 for el in parts[1:-1]:
-                    key += f" -> '{el}'"
+                    key = BinaryOperation(op="->", args=[key, Constant(el)])
 
                 # last element
-                key += f" ->> '{parts[-1]}'"
+                key = BinaryOperation(op="->>", args=[key, Constant(parts[-1])])
 
             type_cast = None
-            if isinstance(condition.value, int):
+            value = condition.value
+            if (
+                isinstance(value, list)
+                and len(value) > 0
+                and condition.op in (FilterOperator.IN, FilterOperator.NOT_IN)
+            ):
+                value = condition.value[0]
+
+            if isinstance(value, int):
                 type_cast = "int"
-            elif isinstance(condition.value, float):
+            elif isinstance(value, float):
                 type_cast = "float"
             if type_cast is not None:
-                key = f"({key})::{type_cast}"
+                key = TypeCast(type_cast, key)
 
             item = {
                 "name": key,
                 "op": condition.op.value,
                 "value": condition.value,
             }
-            if key == "embeddings":
+            if is_embedding:
                 embedding_condition = item
             else:
                 filter_conditions.append(item)
@@ -205,64 +229,24 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         """
         Construct where clauses from filter conditions
         """
-        if filter_conditions is None:
-            return ""
 
-        where_clauses = []
+        where_clause = None
 
         for item in filter_conditions:
             key = item["name"]
 
             if item["op"].lower() in ("in", "not in"):
-                values = list(repr(i) for i in item["value"])
-                item["value"] = "({})".format(", ".join(values))
+                values = [Constant(i) for i in item["value"]]
+                value = AstTuple(values)
             else:
-                if item["value"] is None:
-                    item["value"] = "null"
-                else:
-                    item["value"] = repr(item["value"])
-            where_clauses.append(f"{key} {item['op']} {item['value']}")
-
-        if len(where_clauses) > 1:
-            return f"WHERE {' AND '.join(where_clauses)}"
-        elif len(where_clauses) == 1:
-            return f"WHERE {where_clauses[0]}"
-        else:
-            return ""
-
-    @staticmethod
-    def _construct_where_clause_with_keywords(filter_conditions=None, keyword_query=None, content_column_name=None):
-        if not keyword_query or not content_column_name:
-            return PgVectorHandler._construct_where_clause(filter_conditions)
-
-        keyword_query_condition = (
-            f"""to_tsvector('english', {content_column_name}) @@ websearch_to_tsquery('english', '{keyword_query}')"""
-        )
-        if filter_conditions is None:
-            return ""
-
-        where_clauses = []
-
-        for item in filter_conditions:
-            key = item["name"]
+                value = Constant(item["value"])
+            condition = BinaryOperation(op=item["op"], args=[key, value])
 
-            if item["op"].lower() in ("in", "not in"):
-                values = list(repr(i) for i in item["value"])
-                item["value"] = "({})".format(", ".join(values))
+            if where_clause is None:
+                where_clause = condition
             else:
-                if item["value"] is None:
-                    item["value"] = "null"
-                else:
-                    item["value"] = repr(item["value"])
-            where_clauses.append(f"{key} {item['op']} {item['value']}")
-
-        where_clauses.append(keyword_query_condition)
-        if len(where_clauses) > 1:
-            return f"WHERE {' AND '.join(where_clauses)}"
-        elif len(where_clauses) == 1:
-            return f"WHERE {where_clauses[0]}"
-        else:
-            return ""
+                where_clause = BinaryOperation(op="AND", args=[where_clause, condition])
+        return where_clause
 
     @staticmethod
     def _construct_full_after_from_clause(
@@ -275,9 +259,8 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
     def _build_keyword_bm25_query(
         self,
         table_name: str,
-        query: str,
+        keyword_search_args: KeywordSearchArgs,
         columns: List[str] = None,
-        content_column_name: str = "content",
         conditions: List[FilterCondition] = None,
         limit: int = None,
         offset: int = None,
@@ -286,21 +269,44 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
             columns = ["id", "content", "metadata"]
 
         filter_conditions, _ = self._translate_conditions(conditions)
+        where_clause = self._construct_where_clause(filter_conditions)
 
-        # given filter conditions, construct where clause
-        where_clause = self._construct_where_clause_with_keywords(filter_conditions, query, content_column_name)
-
-        query = f"""
-            SELECT
-                {", ".join(columns)},
-                ts_rank_cd(to_tsvector('english', {content_column_name}), websearch_to_tsquery('english', '{query}')) as distance
-            FROM
-                {table_name}
-            {where_clause if where_clause else ""}
-            {f"LIMIT {limit}" if limit else ""}
-            {f"OFFSET {offset}" if offset else ""};"""
+        if keyword_search_args:
+            keyword_query_condition = BinaryOperation(
+                op="@@",
+                args=[
+                    Function("to_tsvector", args=[Constant("english"), Identifier(keyword_search_args.column)]),
+                    Function("websearch_to_tsquery", args=[Constant("english"), Constant(keyword_search_args.query)]),
+                ],
+            )
 
-        return query
+            if where_clause:
+                where_clause = BinaryOperation(op="AND", args=[where_clause, keyword_query_condition])
+            else:
+                where_clause = keyword_query_condition
+
+        distance = Function(
+            "ts_rank_cd",
+            args=[
+                Function("to_tsvector", args=[Constant("english"), Identifier(keyword_search_args.column)]),
+                Function("websearch_to_tsquery", args=[Constant("english"), Constant(keyword_search_args.query)]),
+            ],
+            alias=Identifier("distance"),
+        )
+
+        targets = [Identifier(col) for col in columns]
+        targets.append(distance)
+
+        limit_clause = Constant(limit) if limit else None
+        offset_clause = Constant(offset) if offset else None
+
+        return Select(
+            targets=targets,
+            from_table=Identifier(table_name),
+            where=where_clause,
+            limit=limit_clause,
+            offset=offset_clause,
+        )
 
     def _build_select_query(
         self,
@@ -309,12 +315,12 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         conditions: List[FilterCondition] = None,
         limit: int = None,
         offset: int = None,
-    ) -> str:
+    ) -> Select:
         """
         given inputs, build string query
         """
-        limit_clause = f"LIMIT {limit}" if limit else ""
-        offset_clause = f"OFFSET {offset}" if offset else ""
+        limit_clause = Constant(limit) if limit else None
+        offset_clause = Constant(offset) if offset else None
 
         # translate filter conditions to dictionary
         filter_conditions, embedding_search = self._translate_conditions(conditions)
@@ -335,7 +341,15 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
             modified_columns = ["id", "content", "embeddings", "metadata"]
             has_distance = True
 
-        targets = ", ".join(modified_columns)
+        targets = [Identifier(col) for col in modified_columns]
+
+        query = Select(
+            targets=targets,
+            from_table=Identifier(table_name),
+            where=where_clause,
+            limit=limit_clause,
+            offset=offset_clause,
+        )
 
         if embedding_search:
             search_vector = embedding_search["value"]
@@ -352,15 +366,18 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
                 if isinstance(search_vector, list):
                     search_vector = f"[{','.join(str(x) for x in search_vector)}]"
 
+            vector_op = BinaryOperation(
+                op=self.distance_op,
+                args=[Identifier("embeddings"), Constant(search_vector)],
+                alias=Identifier("distance"),
+            )
             # Calculate distance as part of the query if needed
             if has_distance:
-                targets = f"{targets}, (embeddings {self.distance_op} '{search_vector}') as distance"
+                query.targets.append(vector_op)
 
-            return f"SELECT {targets} FROM {table_name} {where_clause} ORDER BY embeddings {self.distance_op} '{search_vector}' ASC {limit_clause} {offset_clause} "
+            query.order_by = [OrderBy(vector_op, direction="ASC")]
 
-        else:
-            # if filter conditions, return rows that satisfy the conditions
-            return f"SELECT {targets} FROM {table_name} {where_clause} {limit_clause} {offset_clause}"
+        return query
 
     def _check_table(self, table_name: str):
         # Apply namespace for a user
@@ -386,8 +403,8 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
             columns = ["id", "content", "embeddings", "metadata"]
 
         query = self._build_select_query(table_name, columns, conditions, limit, offset)
-
-        result = self.raw_query(query)
+        query_str = self.renderer.get_string(query, with_failback=True)
+        result = self.raw_query(query_str)
 
         # ensure embeddings are returned as string so they can be parsed by mindsdb
         if "embeddings" in columns:
@@ -408,12 +425,10 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
 
         if columns is None:
             columns = ["id", "content", "embeddings", "metadata"]
-        content_column_name = keyword_search_args.column
-        query = self._build_keyword_bm25_query(
-            table_name, keyword_search_args.query, columns, content_column_name, conditions, limit, offset
-        )
 
-        result = self.raw_query(query)
+        query = self._build_keyword_bm25_query(table_name, keyword_search_args, columns, conditions, limit, offset)
+        query_str = self.renderer.get_string(query, with_failback=True)
+        result = self.raw_query(query_str)
 
         # ensure embeddings are returned as string so they can be parsed by mindsdb
         if "embeddings" in columns:
@@ -622,8 +637,9 @@ class PgVectorHandler(PostgresHandler, VectorStoreHandler, KeywordSearchBase):
         filter_conditions, _ = self._translate_conditions(conditions)
         where_clause = self._construct_where_clause(filter_conditions)
 
-        query = f"DELETE FROM {table_name} {where_clause}"
-        self.raw_query(query)
+        query = Delete(table=Identifier(table_name), where=where_clause)
+        query_str = self.renderer.get_string(query, with_failback=True)
+        self.raw_query(query_str)
 
     def drop_table(self, table_name: str, if_exists=True):
         """

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -1,5 +1,3 @@
-import csv
-import io
 import time
 import json
 from typing import Optional, Any
@@ -625,7 +623,7 @@ class PostgresHandler(MetaDatabaseHandler):
         result = self.native_query(query)
         return result
 
-    def meta_get_column_statistics(self, table_names: Optional[list] = None) -> dict:
+    def meta_get_column_statistics(self, table_names: Optional[list] = None) -> Response:
         """
         Retrieves column statistics (e.g., most common values, frequencies, null percentage, and distinct value count)
         for the specified tables or all tables if no list is provided.
@@ -634,54 +632,58 @@ class PostgresHandler(MetaDatabaseHandler):
             table_names (list): A list of table names for which to retrieve column statistics.
 
         Returns:
-            dict: A dictionary containing the column statistics.
+            Response: A response object containing the column statistics.
         """
-        query = """
+        table_filter = ""
+        if table_names is not None and len(table_names) > 0:
+            quoted_names = [f"'{t}'" for t in table_names]
+            table_filter = f" AND ps.tablename IN ({','.join(quoted_names)})"
+
+        query = (
+            """
             SELECT
-                ps.attname AS column_name,
-                ps.tablename AS table_name,
-                ps.most_common_vals AS most_common_values,
-                ps.most_common_freqs::text AS most_common_frequencies,
-                ps.null_frac * 100 AS null_percentage,
-                ps.n_distinct AS distinct_values_count,
-                ps.histogram_bounds AS histogram_bounds
+                ps.tablename AS TABLE_NAME,
+                ps.attname AS COLUMN_NAME,
+                ROUND(ps.null_frac::numeric * 100, 2) AS NULL_PERCENTAGE,
+                CASE 
+                    WHEN ps.n_distinct < 0 THEN NULL
+                    ELSE ps.n_distinct::bigint
+                END AS DISTINCT_VALUES_COUNT,
+                ps.most_common_vals AS MOST_COMMON_VALUES,
+                ps.most_common_freqs AS MOST_COMMON_FREQUENCIES,
+                ps.histogram_bounds
             FROM pg_stats ps
             WHERE ps.schemaname = current_schema()
             AND ps.tablename NOT LIKE 'pg_%'
             AND ps.tablename NOT LIKE 'sql_%'
         """
-
-        if table_names is not None and len(table_names) > 0:
-            table_names = [f"'{t}'" for t in table_names]
-            query += f" AND ps.tablename IN ({','.join(table_names)})"
+            + table_filter
+            + """
+            ORDER BY ps.tablename, ps.attname
+        """
+        )
 
         result = self.native_query(query)
-        df = result.data_frame
 
-        def parse_pg_array_string(x):
-            try:
-                return (
-                    [item.strip(" ,") for row in csv.reader(io.StringIO(x.strip("{}"))) for item in row if item.strip()]
-                    if x
-                    else []
-                )
-            except IndexError:
-                logger.error(f"Error parsing PostgreSQL array string: {x}")
-                return []
-
-        # Convert most_common_values and most_common_frequencies from string representation to lists.
-        df["most_common_values"] = df["most_common_values"].apply(lambda x: parse_pg_array_string(x))
-        df["most_common_frequencies"] = df["most_common_frequencies"].apply(lambda x: parse_pg_array_string(x))
-
-        # Get the minimum and maximum values from the histogram bounds.
-        df["minimum_value"] = df["histogram_bounds"].apply(lambda x: parse_pg_array_string(x)[0] if x else None)
-        df["maximum_value"] = df["histogram_bounds"].apply(lambda x: parse_pg_array_string(x)[-1] if x else None)
-
-        # Handle cases where distinct_values_count is negative (indicating an approximation).
-        df["distinct_values_count"] = df["distinct_values_count"].apply(lambda x: x if x >= 0 else None)
+        if result.type == RESPONSE_TYPE.TABLE and result.data_frame is not None:
+            df = result.data_frame
 
-        result.data_frame = df.drop(columns=["histogram_bounds"])
+            # Extract min/max from histogram bounds
+            def extract_min_max(histogram_str):
+                if histogram_str and str(histogram_str) != "nan":
+                    clean = str(histogram_str).strip("{}")
+                    if clean:
+                        values = clean.split(",")
+                        min_val = values[0].strip(" \"'") if values else None
+                        max_val = values[-1].strip(" \"'") if values else None
+                        return min_val, max_val
+                return None, None
 
+            min_max_values = df["histogram_bounds"].apply(extract_min_max)
+            df["MINIMUM_VALUE"] = min_max_values.apply(lambda x: x[0])
+            df["MAXIMUM_VALUE"] = min_max_values.apply(lambda x: x[1])
+
+        result.data_frame = df.drop(columns=["histogram_bounds"])
         return result
 
     def meta_get_primary_keys(self, table_names: Optional[list] = None) -> Response:

mindsdb/integrations/handlers/salesforce_handler/constants.py

@@ -0,0 +1,208 @@
+"""
+Constants for Salesforce handler.
+"""
+
+
+def get_soql_instructions(integration_name):
+    return f"""This handler executes SOQL (Salesforce Object Query Language), NOT SQL! Follow these rules strictly:
+
+**BASIC STRUCTURE:**
+- NO "SELECT *" - must explicitly list all fields
+  SQL: SELECT * FROM Account;
+  SOQL: SELECT Id, Name, Industry FROM Account
+- NO table aliases - use full table names only
+  SQL: SELECT a.Name FROM Account a;
+  SOQL: SELECT Name FROM Account
+- NO column aliases - field names cannot be aliased
+  SQL: SELECT Name AS CompanyName FROM Account;
+  SOQL: SELECT Name FROM Account
+- NO DISTINCT keyword - not supported in SOQL
+  SQL: SELECT DISTINCT Industry FROM Account;
+  SOQL: Not possible - use separate logic
+- NO subqueries in FROM clause - only relationship-based subqueries allowed
+  SQL: SELECT * FROM (SELECT Name FROM Account) AS AccountNames;
+  SOQL: Not supported
+
+**FIELD SELECTION:**
+- Always include Id field when querying
+  CORRECT: SELECT Id, Name, Industry FROM Account
+  INCORRECT: SELECT Name, Industry FROM Account
+- Field names are case-sensitive
+  CORRECT: SELECT CreatedDate FROM Account
+  INCORRECT: SELECT createddate FROM Account
+- Use exact field names from the data catalog
+  CORRECT: SELECT CustomerPriority__c FROM Account
+  INCORRECT: SELECT customer_priority FROM Account
+
+**FILTERING (WHERE clause):**
+- Date/DateTime fields: Use unquoted literals in YYYY-MM-DD or YYYY-MM-DDThh:mm:ssZ format
+  CORRECT: WHERE CloseDate >= 2025-05-28
+  CORRECT: WHERE CreatedDate >= 2025-05-28T10:30:00Z
+  INCORRECT: WHERE CloseDate >= '2025-05-28'
+  INCORRECT: WHERE CreatedDate >= "2025-05-28"
+- Special date literals: TODAY, YESTERDAY, LAST_WEEK, LAST_MONTH, LAST_QUARTER, LAST_YEAR, THIS_WEEK, THIS_MONTH, THIS_QUARTER, THIS_YEAR
+  CORRECT: WHERE CreatedDate = TODAY
+  CORRECT: WHERE LastModifiedDate >= LAST_MONTH
+  CORRECT: WHERE CloseDate = THIS_QUARTER
+- LIKE operator: Only supports % wildcard, NO underscore (_) wildcard
+  CORRECT: WHERE Name LIKE '%Corp%'
+  CORRECT: WHERE Name LIKE 'Acme%'
+  INCORRECT: WHERE Name LIKE 'A_me%'
+- BETWEEN operator: NOT supported, use >= AND <= instead
+  SQL: WHERE CreatedDate BETWEEN '2025-01-01' AND '2025-12-31'
+  SOQL: WHERE CreatedDate >= 2025-01-01 AND CreatedDate <= 2025-12-31
+- Boolean values: Use lowercase true/false, NOT TRUE/FALSE
+  CORRECT: WHERE Active__c = true
+  CORRECT: WHERE IsDeleted = false
+  INCORRECT: WHERE Active__c = TRUE
+  INCORRECT: WHERE IsDeleted = FALSE
+- NULL values: Use lowercase null, NOT NULL
+  CORRECT: WHERE ParentId = null
+  CORRECT: WHERE Description != null
+  INCORRECT: WHERE ParentId IS NULL
+  INCORRECT: WHERE Description IS NOT NULL
+- String values: Use single quotes for strings
+  CORRECT: WHERE Industry = 'Technology'
+  CORRECT: WHERE Name = 'Acme Corp'
+  INCORRECT: WHERE Industry = "Technology"
+- Multi-select picklist fields: Use INCLUDES('value1;value2') or EXCLUDES('value1;value2')
+  CORRECT: WHERE Services__c INCLUDES ('Consulting;Support')
+  CORRECT: WHERE Services__c EXCLUDES ('Training')
+  INCORRECT: WHERE Services__c = 'Consulting'
+
+**JOINS:**
+- NO explicit JOIN syntax supported
+  SQL: SELECT a.Name, c.FirstName FROM Account a JOIN Contact c ON a.Id = c.AccountId
+  SOQL: Not supported - use relationship traversal (not applicable in this use case)
+
+**AGGREGATES:**
+- NO COUNT(*) - use COUNT(Id) instead
+  SQL: SELECT COUNT(*) FROM Account
+  SOQL: SELECT COUNT(Id) FROM Account
+- Cannot mix aggregate functions with non-aggregate fields unless using GROUP BY
+  CORRECT: SELECT Industry, COUNT(Id) FROM Account GROUP BY Industry
+  CORRECT: SELECT COUNT(Id) FROM Account
+  INCORRECT: SELECT Industry, Name, COUNT(Id) FROM Account
+- NO GROUP_CONCAT or string aggregation functions
+  SQL: SELECT GROUP_CONCAT(Name) FROM Account
+  SOQL: Not supported
+- NO HAVING clause
+  SQL: SELECT Industry, COUNT(*) FROM Account GROUP BY Industry HAVING COUNT(*) > 5
+  SOQL: Not supported - filter with separate logic
+- GROUP BY has limited field type support
+  CORRECT: SELECT Industry, COUNT(Id) FROM Account GROUP BY Industry
+  INCORRECT: SELECT Description, COUNT(Id) FROM Account GROUP BY Description (textarea fields not supported)
+
+**FUNCTIONS:**
+- Date functions: CALENDAR_MONTH(), CALENDAR_YEAR(), CALENDAR_QUARTER(), DAY_IN_MONTH(), DAY_IN_WEEK(), DAY_IN_YEAR(), HOUR_IN_DAY(), WEEK_IN_MONTH(), WEEK_IN_YEAR()
+  CORRECT: SELECT Id, Name FROM Account WHERE CALENDAR_YEAR(CreatedDate) = 2025
+  CORRECT: SELECT Id, Name FROM Account WHERE CALENDAR_MONTH(CreatedDate) = 5
+  CORRECT: SELECT Id, Name FROM Account WHERE DAY_IN_WEEK(CreatedDate) = 2
+- NO math functions: ROUND, FLOOR, CEILING, ABS, etc.
+  SQL: SELECT ROUND(AnnualRevenue, 2) FROM Account
+  SOQL: Not supported
+- NO conditional functions: CASE WHEN, COALESCE, NULLIF, etc.
+  SQL: SELECT CASE WHEN Industry = 'Technology' THEN 'Tech' ELSE 'Other' END FROM Account
+  SOQL: Not supported
+- NO string functions except INCLUDES/EXCLUDES for multi-select picklists
+  SQL: SELECT UPPER(Name) FROM Account
+  SOQL: Not supported
+
+**OPERATORS:**
+- Supported: =, !=, <, >, <=, >=, LIKE, IN, NOT IN, INCLUDES, EXCLUDES
+  CORRECT: WHERE Industry = 'Technology'
+  CORRECT: WHERE AnnualRevenue >= 1000000
+  CORRECT: WHERE Industry IN ('Technology', 'Finance')
+  CORRECT: WHERE Industry NOT IN ('Government', 'Non-Profit')
+  CORRECT: WHERE Services__c INCLUDES ('Consulting')
+- NOT supported: REGEXP, BETWEEN, EXISTS, NOT EXISTS
+  SQL: WHERE Name REGEXP '^[A-Z]'
+  SOQL: Not supported
+
+**SORTING & LIMITING:**
+- ORDER BY: Fully supported
+  CORRECT: SELECT Id, Name FROM Account ORDER BY Name ASC
+  CORRECT: SELECT Id, Name FROM Account ORDER BY CreatedDate DESC, Name ASC
+  CORRECT: SELECT Id, Name FROM Account ORDER BY Name NULLS LAST
+- LIMIT: Maximum 2000 records, use smaller limits for better performance
+  CORRECT: SELECT Id, Name FROM Account LIMIT 100
+  CORRECT: SELECT Id, Name FROM Account LIMIT 2000
+  INCORRECT: SELECT Id, Name FROM Account LIMIT 5000
+- NO OFFSET: Not supported for pagination
+  SQL: SELECT Id, Name FROM Account LIMIT 10 OFFSET 20
+  SOQL: Not supported
+
+**DATA TYPES:**
+- picklist: Single-select dropdown, use = operator with string values
+  CORRECT: WHERE Industry = 'Technology'
+  CORRECT: WHERE Rating = 'Hot'
+- reference: Foreign key field, typically ends with Id
+  CORRECT: WHERE OwnerId = '00530000003OOwn'
+  CORRECT: WHERE AccountId = '0013000000UzXyz'
+- boolean: Use lowercase true/false
+  CORRECT: WHERE IsDeleted = false
+  CORRECT: WHERE Active__c = true
+- currency: Numeric field for money values
+  CORRECT: WHERE AnnualRevenue > 1000000
+  CORRECT: WHERE AnnualRevenue >= 500000.50
+- date: Date only, use YYYY-MM-DD format
+  CORRECT: WHERE LastActivityDate = 2025-05-28
+  CORRECT: WHERE SLAExpirationDate__c >= 2025-01-01
+- datetime: Date and time, use YYYY-MM-DDThh:mm:ssZ format
+  CORRECT: WHERE CreatedDate >= 2025-05-28T10:30:00Z
+  CORRECT: WHERE LastModifiedDate = 2025-05-28T00:00:00Z
+- double/int: Numeric fields
+  CORRECT: WHERE NumberOfEmployees > 100
+  CORRECT: WHERE NumberofLocations__c >= 5.5
+- string/textarea: Text fields, use single quotes
+  CORRECT: WHERE Name = 'Acme Corporation'
+  CORRECT: WHERE Description = 'Leading tech company'
+- phone/url/email: Specialized string fields, treat as strings
+  CORRECT: WHERE Phone = '555-1234'
+  CORRECT: WHERE Website = 'https://example.com'
+
+**COMMON MISTAKES TO AVOID:**
+- Using SELECT * (not allowed)
+  WRONG: SELECT * FROM Account
+  RIGHT: SELECT Id, Name, Industry FROM Account
+- Quoting date literals (dates must be unquoted)
+  WRONG: WHERE CreatedDate >= '2025-01-01'
+  RIGHT: WHERE CreatedDate >= 2025-01-01
+- Using SQL JOIN syntax (not supported)
+  WRONG: SELECT Account.Name FROM Account JOIN Contact ON Account.Id = Contact.AccountId
+  RIGHT: Use relationship traversal (not applicable in this use case)
+- Using BETWEEN operator (not supported)
+  WRONG: WHERE CreatedDate BETWEEN 2025-01-01 AND 2025-12-31
+  RIGHT: WHERE CreatedDate >= 2025-01-01 AND CreatedDate <= 2025-12-31
+- Using uppercase TRUE/FALSE/NULL (must be lowercase)
+  WRONG: WHERE Active__c = TRUE
+  RIGHT: WHERE Active__c = true
+- Using underscore _ in LIKE patterns (only % supported)
+  WRONG: WHERE Name LIKE 'A_me%'
+  RIGHT: WHERE Name LIKE 'A%me%'
+- Mixing aggregate and non-aggregate fields without GROUP BY
+  WRONG: SELECT Name, COUNT(Id) FROM Account
+  RIGHT: SELECT Industry, COUNT(Id) FROM Account GROUP BY Industry
+
+**EXAMPLE QUERIES:**
+- Basic selection: SELECT Id, Name, Industry FROM Account WHERE Industry = 'Technology'
+- Date filtering: SELECT Id, Name FROM Account WHERE CreatedDate >= 2025-01-01
+- Multiple conditions: SELECT Id, Name FROM Account WHERE Name LIKE '%Corp%' AND Industry IN ('Technology', 'Finance')
+- Aggregation: SELECT Industry, COUNT(Id) FROM Account GROUP BY Industry
+- Boolean and numeric: SELECT Id, Name FROM Account WHERE Active__c = true AND NumberOfEmployees > 100
+- Date functions: SELECT Id, Name FROM Account WHERE CALENDAR_YEAR(CreatedDate) = 2025
+- Null checks: SELECT Id, Name FROM Account WHERE ParentId = null
+- Multi-select picklist: SELECT Id, Name FROM Account WHERE Services__c INCLUDES ('Consulting;Support')
+- Sorting and limiting: SELECT Id, Name FROM Account ORDER BY Name ASC LIMIT 50
+
+***EXECUTION INSTRUCTIONS. IMPORTANT!***
+After generating the core SOQL (and nothing else), always make sure you wrap it exactly as:
+
+    SELECT * 
+      FROM {integration_name}(
+        /* your generated SOQL goes here, without a trailing semicolon */
+      )
+
+Return only that wrapper call.
+
+"""