שאילתות — סינון, מיון ועימוד

GET /parse/classes/{Table}?where=…&keys=…&order=…&limit=…

כל השליפות עוברות דרך אותה נקודת קצה, ומשתנות רק בפרמטרים. הכול ב‑query string, הכול אופציונלי מלבד הטבלה עצמה.

פרמטרי השאילתה

פרמטר	טיפוס	משמעות	דוגמה
where	JSON מקודד ל‑URL	תנאי הסינון	where={"PhoneNumber":"0501234567"}
keys	רשימה מופרדת בפסיקים	אילו שדות להחזיר (projection)	keys=Name,PhoneNumber,Email
include	רשימה מופרדת בפסיקים	הרחבת שדות Pointer לאובייקט מלא בתשובה	include=AccountId,OwnerId
order	מחרוזת	מיון. - בהתחלה = יורד; פסיקים לריבוי שדות	order=-createdAt,Name
limit	מספר	כמות. ברירת מחדל 100. אין תקרה נאכפת — ראו למטה	limit=500
skip	מספר	דילוג — לעימוד	skip=500
count	0 / 1	count=1 מוסיף ספירה כוללת. עם limit=0 — ספירה בלבד	limit=0&count=1

תבנית התשובה: { "results": [ … ] }, ועם count=1 גם "count": N.

שני פרמטרים שמופיעים ב‑Parse הגנרי ואינם נתמכים כאן

distinct ו‑readPreference אינם קיימים בפריסה הזו, וכל אחד מהם מוחזר עם {"code":102,"error":"Invalid parameter for query: <name>"} — גם עם Master Key. לרשימת ערכים ייחודיים: שלפו את השדה עם keys וייחדו בצד שלכם, או קבצו ב‑אגרגציה.

where הוא JSON שעובר URL‑encoding

where הוא מחרוזת JSON. בפועל השרת סלחני למדי — JSON פשוט שלא קודד (גם עם עברית) יעבור — אבל ערך שמכיל תווים מיוחדים ישבור את השאילתה, וכל תו בדרך אחרת:

התו בערך	מה קורה בלי קידוד
+	הופך לרווח — 200 עם מערך ריק, בלי שגיאה
&	חותך את ה‑JSON — 400 עם {"code":102,"error":"Invalid parameter for query: …"}
#	נחתך כ‑fragment — 500 עם {"code":1,"message":"Internal server error."}

אל תשרשרו מחרוזות ידנית — תנו לספרייה לעשות את זה: --data-urlencode ב‑curl, params= ב‑requests, URLSearchParams ב‑JavaScript.

ומה שכן מחזיר שגיאה: JSON פגום ב‑where מוחזר כ‑500 עם {"code":1,"message":"Internal server error."}, ופרמטר שאינו מוכר כ‑400 עם {"code":102,…} — הודעה מפורשת, לא “400 סתום”.

אופרטורי where

אופרטור	משמעות	דוגמה
ערך חשוף	שווה ל	{"Status":"Active"}
$lt $lte $gt $gte	קטן / קטן‑שווה / גדול / גדול‑שווה	{"Total":{"$gte":1000,"$lte":3000}}
$ne	שונה מ	{"IsAccount":{"$ne":true}}
$in	ברשימה	{"StatusId":{"$in":["E9cYlAlooc","piKPNxodMJ"]}}
$nin	לא ברשימה	{"City":{"$nin":["תל אביב","חיפה"]}}
$exists	לשדה יש ערך (או אין). null נחשב “יש”; "" לא נתפס באף צד — ראו עבודה עם רשומות	{"Email":{"$exists":true}}
$regex	ביטוי רגולרי	{"Name":{"$regex":"^א"}}
$all	מערך מכיל את כל הערכים	{"Tags":{"$all":["דחוף","VIP"]}}
$text	חיפוש טקסט חופשי	רק על שדות מאונדקסים — ראו האזהרה למטה
$inQuery	Pointer שמצביע על רשומה מתוך תת‑שאילתה	ראו למטה
$notInQuery	ההפך מ‑$inQuery
$select	שדה סקלרי שווה לערך של מפתח מתוצאת תת‑שאילתה	ראו למטה
$dontSelect	ההפך מ‑$select
$or	OR — ברמה העליונה של האובייקט בלבד	{"$or":[{"PhoneNumber":"050…"},{"Email":"x@y"}]}

מפתחות מרובים באותה רמה מתחברים ב‑AND. {"IsAccount":true,"City":"תל אביב"} = לקוחות וגם מתל אביב.

סינון לפי Pointer — אובייקט מלא, לא מחרוזת

JSON

{ "AccountId": { "__type": "Pointer", "className": "Accounts", "objectId": "xK9mP2qRsT" } }

מחרוזת חשופה ({"AccountId":"xK9mP2qRsT"}) לא תתאים לשום דבר ותחזיר מערך ריק — בלי שגיאה.

סינון לפי תאריך — גם כאן אובייקט עטוף

JSON

{ "createdAt": { "$gt": { "__type": "Date", "iso": "2026-01-01T00:00:00.000Z" } } }

זה נכון גם ל‑createdAt ו‑updatedAt, למרות שהם חוזרים בתשובה כמחרוזת ISO שטוחה. ראו סוגי נתונים.

$inQuery — תת‑שאילתה דרך Pointer

“כל המשימות של לקוחות מתל אביב”, בלי שתי קריאות:

JSON

{
  "AccountId": {
    "$inQuery": { "className": "Accounts", "where": { "City": "תל אביב" } }
  }
}

$select לא מתאים ל‑Pointer

$select משווה ערך סקלרי של השדה לערך של key בתוצאות תת‑השאילתה. על שדה Pointer עם "key":"objectId" הוא מחזיר מערך ריק, בלי שגיאה — כי הערך המאוחסן הוא מצביע, לא מחרוזת. ל‑Pointer השתמשו ב‑$inQuery / $notInQuery; $select / $dontSelect נועדו למקרים כמו {"City":{"$select":{"query":{"className":"Branches","where":{…}},"key":"City"}}}.

$text דורש אינדקס — ובלעדיו מקבלים 500

חיפוש טקסט חופשי עובד רק על שדות שיש עליהם אינדקס טקסט, ורשימת האינדקסים אינה חשופה בשום נקודת קצה. הדרך היחידה לדעת היא לנסות: על שדה בלי אינדקס התשובה היא

JSON

// HTTP 500
{ "ok": 0, "code": 27, "codeName": "IndexNotFound", "operationTime": { "$timestamp": "…" } }

כלומר לא שגיאת {code, error} מסודרת אלא אובייקט השגיאה הגולמי של מנוע הנתונים, בקוד סטטוס שגורם ללקוחות עם נסיגה אקספוננציאלית לנסות שוב לחינם.

לחיפוש “מכיל” רגיל על שדה קצר, $regex צפוי יותר — והוא עובד על כל שדה.

דוגמאות מלאות

ספירה בלבד — הכי זול שיש

Bash

curl -sS -G "https://api.mbapps.co.il/parse/classes/Accounts" \
  -H "X-Parse-Application-Id: $APP_ID" \
  -H "X-Parse-API-Key: $API_KEY" \
  --data-urlencode 'where={"IsAccount":true}' \
  --data-urlencode 'limit=0' \
  --data-urlencode 'count=1'

JavaScript

const params = new URLSearchParams({
  where: JSON.stringify({ IsAccount: true }),
  limit: '0',
  count: '1',
});
const res = await fetch(`https://api.mbapps.co.il/parse/classes/Accounts?${params}`, {
  headers: {
    'X-Parse-Application-Id': APP_ID,
    'X-Parse-API-Key': API_KEY,
  },
});

Python

import json, requests

res = requests.get(
    "https://api.mbapps.co.il/parse/classes/Accounts",
    headers={
        "X-Parse-Application-Id": APP_ID,
        "X-Parse-API-Key": API_KEY,
    },
    params={
        "where": json.dumps({"IsAccount": True}),
        "limit": 0,
        "count": 1,
    },
    timeout=30,
)

PHP

<?php
$params = http_build_query([
    'where' => json_encode(['IsAccount' => true]),
    'limit' => 0,
    'count' => 1,
]);
$ch = curl_init("https://api.mbapps.co.il/parse/classes/Accounts?$params");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'X-Parse-Application-Id: ' . $appId,
        'X-Parse-API-Key: ' . $apiKey,
    ],
]);
$response = curl_exec($ch);
curl_close($ch);

JSON

{ "results": [], "count": 412 }

שליפה ממוקדת עם הרחבת Pointer

Bash

curl -sS -G "https://api.mbapps.co.il/parse/classes/Sales" \
  -H "X-Parse-Application-Id: $APP_ID" \
  -H "X-Parse-API-Key: $API_KEY" \
  --data-urlencode 'where={"Total":{"$gt":10000},"SaleStatusId":{"__type":"Pointer","className":"SaleStatuses","objectId":"zrP1MSVBoq"}}' \
  --data-urlencode 'keys=Name,Total,ClosingDate,AccountId' \
  --data-urlencode 'include=AccountId' \
  --data-urlencode 'order=-Total' \
  --data-urlencode 'limit=20'

JavaScript

const params = new URLSearchParams({
  where: JSON.stringify({
    Total: { $gt: 10000 },
    SaleStatusId: { __type: 'Pointer', className: 'SaleStatuses', objectId: 'zrP1MSVBoq' },
  }),
  keys: 'Name,Total,ClosingDate,AccountId',
  include: 'AccountId',
  order: '-Total',
  limit: '20',
});
const res = await fetch(`https://api.mbapps.co.il/parse/classes/Sales?${params}`, {
  headers: {
    'X-Parse-Application-Id': APP_ID,
    'X-Parse-API-Key': API_KEY,
  },
});

Python

import json, requests

res = requests.get(
    "https://api.mbapps.co.il/parse/classes/Sales",
    headers={
        "X-Parse-Application-Id": APP_ID,
        "X-Parse-API-Key": API_KEY,
    },
    params={
        "where": json.dumps({
            "Total": {"$gt": 10000},
            "SaleStatusId": {"__type": "Pointer", "className": "SaleStatuses", "objectId": "zrP1MSVBoq"},
        }),
        "keys": "Name,Total,ClosingDate,AccountId",
        "include": "AccountId",
        "order": "-Total",
        "limit": 20,
    },
    timeout=30,
)

PHP

<?php
$params = http_build_query([
    'where' => json_encode([
        'Total' => ['$gt' => 10000],
        'SaleStatusId' => ['__type' => 'Pointer', 'className' => 'SaleStatuses', 'objectId' => 'zrP1MSVBoq'],
    ]),
    'keys' => 'Name,Total,ClosingDate,AccountId',
    'include' => 'AccountId',
    'order' => '-Total',
    'limit' => 20,
]);
$ch = curl_init("https://api.mbapps.co.il/parse/classes/Sales?$params");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'X-Parse-Application-Id: ' . $appId,
        'X-Parse-API-Key: ' . $apiKey,
    ],
]);
$response = curl_exec($ch);
curl_close($ch);

עם include, שדה ה‑Pointer חוזר כאובייקט מלא ולא כמצביע:

JSON

{
  "results": [
    {
      "objectId": "aB3dEf9HiJ",
      "Name": "חידוש רישיון 2026",
      "Total": 24000,
      "ClosingDate": { "__type": "Date", "iso": "2026-07-31T00:00:00.000Z" },
      "AccountId": {
        "__type": "Object",
        "className": "Accounts",
        "objectId": "xK9mP2qRsT",
        "Name": "חברת דוגמה בע\"מ",
        "Email": "office@example.co.il"
      }
    }
  ]
}

keys + include ביחד = פחות תעבורה

בטבלה עם 130 שדות, keys הופך תשובה של מגה‑בייטים לתשובה של קילו‑בייטים. include חוסך קריאת N+1 לכל שורה. השתמשו בשניהם כברירת מחדל, לא כאופטימיזציה מאוחרת.

OR בין טלפון לאימייל — דפוס חיפוש לפני יצירה

Bash

curl -sS -G "https://api.mbapps.co.il/parse/classes/Accounts" \
  -H "X-Parse-Application-Id: $APP_ID" \
  -H "X-Parse-API-Key: $API_KEY" \
  --data-urlencode 'where={"$or":[{"PhoneNumber":"0501234567"},{"Email":"israel@example.co.il"}]}' \
  --data-urlencode 'limit=5'

JavaScript

const params = new URLSearchParams({
  where: JSON.stringify({
    $or: [
      { PhoneNumber: '0501234567' },
      { Email: 'israel@example.co.il' },
    ],
  }),
  limit: '5',
});
const res = await fetch(`https://api.mbapps.co.il/parse/classes/Accounts?${params}`, {
  headers: {
    'X-Parse-Application-Id': APP_ID,
    'X-Parse-API-Key': API_KEY,
  },
});

Python

import json, requests

res = requests.get(
    "https://api.mbapps.co.il/parse/classes/Accounts",
    headers={
        "X-Parse-Application-Id": APP_ID,
        "X-Parse-API-Key": API_KEY,
    },
    params={
        "where": json.dumps({
            "$or": [
                {"PhoneNumber": "0501234567"},
                {"Email": "israel@example.co.il"},
            ],
        }),
        "limit": 5,
    },
    timeout=30,
)

PHP

<?php
$params = http_build_query([
    'where' => json_encode([
        '$or' => [
            ['PhoneNumber' => '0501234567'],
            ['Email' => 'israel@example.co.il'],
        ],
    ]),
    'limit' => 5,
]);
$ch = curl_init("https://api.mbapps.co.il/parse/classes/Accounts?$params");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'X-Parse-Application-Id: ' . $appId,
        'X-Parse-API-Key: ' . $apiKey,
    ],
]);
$response = curl_exec($ch);
curl_close($ch);

טלפונים ישראליים מאוחסנים בכמה פורמטים

באותה טבלה חיים 0501234567, 972501234567, +972-50-1234567 ומקפים למיניהם. הפלטפורמה אינה מנרמלת אותם. מנוע זיהוי הכפילויות של getlead שואל כמה ווריאציות במפורש, אבל לא את כולן: הוא סורק חמישה פורמטים קבועים, ופורמטים נפוצים עם רווח או מקף נוסף (למשל 05X XXXXXXX או +972 5X XXXXXXX) לא מזוהים אפילו כשהמספר זהה. אינטגרציה שעושה חיפוש‑לפני‑יצירה בעצמה צריכה לשאול את כל הווריאציות שהיא מכירה, או להשוות על שדה מנורמל משלה.

עימוד

שתי מגבלות limit שאסור לבלבל ביניהן

השכבה	ברירת מחדל	מקסימום
REST — /parse/classes/…	100	אין תקרה נאכפת (עד 2000 ומעלה)
MCP — הכלי Get-Data	5	2000 — נאכף בסכימת הכלי

מי שמעביר לוגיקה מסוכן AI לשרת ביניים ומניח “ברירת המחדל היא 5” יקבל פי 20 רשומות. מי שהולך בכיוון ההפוך יחשוב שהטבלה כמעט ריקה. תמיד ציינו limit במפורש.

אין תקרת 1000 ב‑REST

בניגוד לברירת המחדל הגנרית של Parse, הפריסה הזו אינה חוסמת limit גדול: limit=2000 על טבלה בת 1,100 שורות החזיר את כולן. זו לא רשות לשלוף טבלה שלמה בקריאה אחת — זמן התשובה והזיכרון בצד שלכם הם המגבלה האמיתית. עמדו בעימוד.

בשכבת ה‑MCP המגבלה כן נאכפת: limit=2001 נדחה עוד לפני שהגיע לשרת הנתונים — Input validation error … limit: Too big: expected number to be <=2000.

הדפוס הבסיסי — skip + limit

JavaScript

async function* allRows(table, pageSize = 1000) {
  let skip = 0;
  for (;;) {
    const qs = new URLSearchParams({
      limit: String(pageSize),
      skip: String(skip),
      order: 'createdAt,objectId',  // מיון יציב — חובה שובר‑שוויון, ראו האזהרה למטה
    });
    const res = await fetch(`https://api.mbapps.co.il/parse/classes/${table}?${qs}`, { headers: H });
    if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
    const { results } = await res.json();
    if (!results.length) return;
    yield* results;
    if (results.length < pageSize) return;   // העמוד האחרון
    skip += pageSize;
  }
}

skip עמוק מסוכן על טבלה חיה

skip סופר שורות בזמן הביצוע. בזמן שאתם קוראים עמוד 40, אנשי המכירות ממשיכים ליצור רשומות. התוצאה:

• מיון לפי שדה שמשתנה (-updatedAt, StatusId) → רשומה שעודכנה קופצת קדימה, ואתם או מדלגים עליה או קוראים אותה פעמיים.
• הכנסות תכופות → כל הרשומות אחרי נקודת ההכנסה מוסטות באחת.
• skip גדול יקר גם בביצועים — השרת עדיין נדרש לעבור על השורות שדילג עליהן.
• createdAt אינו ייחודי. רשומות שנוצרו ב‑batch או בייבוא חולקות את אותה אלפית שנייה (עד 106 רשומות על אותו createdAt), ומיון לפיו בלבד אינו דטרמיניסטי בין עמודים — על טבלה בת 1,100 שורות order=createdAt מחזיר 19 כפילויות ו‑19 חוסרים, ו‑order=createdAt,objectId מחזיר את כולן בדיוק. תמיד הוסיפו objectId כשובר‑שוויון.

הדפוס העמיד — עימוד לפי createdAt + objectId

במקום לספור שורות, זכרו איפה עצרתם. createdAt אינו משתנה אחרי היצירה, ולכן הוא סמן יציב — אבל כיוון שהוא אינו ייחודי, הסמן חייב להיות הזוג (createdAt, objectId):

Python

import json, requests

API = "https://api.mbapps.co.il/parse"
H = {"X-Parse-Application-Id": APP_ID, "X-Parse-API-Key": API_KEY}

def iter_all(table, page_size=1000, since=None):
    """מייצר את כל הרשומות בטבלה בסדר (createdAt, objectId) עולה, בלי skip."""
    cursor = since  # (iso, objectId), או None להתחלה
    while True:
        if cursor:
            iso, oid = cursor
            where = {"$or": [
                {"createdAt": {"$gt": {"__type": "Date", "iso": iso}}},
                {"createdAt": {"__type": "Date", "iso": iso}, "objectId": {"$gt": oid}},
            ]}
        else:
            where = {}
        params = {
            "limit": page_size,
            "order": "createdAt,objectId",
            "where": json.dumps(where),
        }
        r = requests.get(f"{API}/classes/{table}", headers=H, params=params, timeout=30)
        r.raise_for_status()
        rows = r.json()["results"]
        if not rows:
            return
        for row in rows:
            yield row
        cursor = (rows[-1]["createdAt"], rows[-1]["objectId"])   # createdAt חוזר כמחרוזת ISO שטוחה
        if len(rows) < page_size:
            return

סמן של createdAt בלבד מאבד רשומות

הגרסה הנאיבית — {"createdAt":{"$gt":cursor}} — מדלגת על כל הרשומות שחולקות את ה‑createdAt של השורה האחרונה בעמוד. על טבלה בת 1,925 שורות: עם page_size=1000 אובדות 2 רשומות, ועם page_size=300 אובדות 209. ה‑$or למעלה הוא מה שסוגר את הפער: על אותה טבלה אחרי שגדלה ל‑2,046 שורות הוא מחזיר 2,046 מתוך 2,046, בלי אובדן ובלי כפילות.

בונוס: אותה פונקציה היא גם סנכרון דלתא. שמרו את ה‑cursor האחרון, והריצה הבאה תתחיל בדיוק ממנו.

מה עם רשומות שהתעדכנו ולא נוצרו?

עימוד לפי createdAt תופס רשומות חדשות. לסנכרון של רשומות שהשתנו, החליפו את שדה הסמן ל‑updatedAt — ותכננו לכך שאותה רשומה תחזור שוב בריצה הבאה אם עודכנה בינתיים. חתכו כפילויות לפי objectId בצד שלכם.

כמה זה בכלל? תשאלו לפני שתמשכו

Bash

curl -sS -G "https://api.mbapps.co.il/parse/classes/Accounts" \
  -H "X-Parse-Application-Id: $APP_ID" -H "X-Parse-API-Key: $API_KEY" \
  --data-urlencode 'limit=0' --data-urlencode 'count=1'

JavaScript

const params = new URLSearchParams({ limit: '0', count: '1' });
const res = await fetch(`https://api.mbapps.co.il/parse/classes/Accounts?${params}`, {
  headers: {
    'X-Parse-Application-Id': APP_ID,
    'X-Parse-API-Key': API_KEY,
  },
});

Python

import requests

res = requests.get(
    "https://api.mbapps.co.il/parse/classes/Accounts",
    headers={
        "X-Parse-Application-Id": APP_ID,
        "X-Parse-API-Key": API_KEY,
    },
    params={"limit": 0, "count": 1},
    timeout=30,
)

PHP

<?php
$params = http_build_query(['limit' => 0, 'count' => 1]);
$ch = curl_init("https://api.mbapps.co.il/parse/classes/Accounts?$params");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'X-Parse-Application-Id: ' . $appId,
        'X-Parse-API-Key: ' . $apiKey,
    ],
]);
$response = curl_exec($ch);
curl_close($ch);

1,800 רשומות = שתי קריאות. 180,000 = 180 קריאות, וכדאי לתכנן השהיה ביניהן: אין מגבלות קצב מתועדות לשרת, ובאלפי קריאות רצופות לא חוזר אף 429 — אבל “לא נצפה” אינו “לא קיים”, ולכן הכלל המעשי הוא לחתוך ולהאט מרצון. ראו מגבלות ומכסות.

מלכודות מהירות

התסמין	הסיבה
400 עם {"code":102,"error":"Invalid parameter for query: X"}	פרמטר שאינו נתמך — למשל distinct או readPreference
500 עם {"code":1,"message":"Internal server error."}	where שאינו JSON תקין
500 עם IndexNotFound	$text על שדה בלי אינדקס טקסט
מערך ריק, בלי שגיאה	סינון Pointer במחרוזת חשופה במקום באובייקט
מערך ריק על שאילתת תאריך	תאריך שנשלח כמחרוזת שטוחה ב‑where
מערך ריק על טבלה שאמורה להיות מלאה	שם טבלה שגוי — טבלה שאינה קיימת מחזירה 200 ומערך ריק, לא שגיאה
בדיוק 100 תוצאות, תמיד	לא ציינתם limit — זו ברירת המחדל של REST
בדיוק 5 תוצאות, תמיד	אתם בשכבת ה‑MCP, לא ב‑REST
$or “לא עובד”	$or תקף רק ברמה העליונה של אובייקט ה‑where (אחרת: 400 עם {"code":107,"error":"bad constraint: $or"})
$select על Pointer מחזיר ריק	$select משווה ערך סקלרי; ל‑Pointer — $inQuery
400 עם bad $text: $search, should be object	$search חייב להיות {"$term":"…"} ולא מחרוזת
רשומות חסרות בייצוא מלא	skip עמוק על טבלה שממשיכה להשתנות — או מיון לפי createdAt בלי objectId כשובר‑שוויון
רשומה עם "" לא מופיעה לא ב‑$exists:true ולא ב‑$exists:false	מחרוזת ריקה נופלת בין הכיסאות; השתמשו ב‑{"$in":[null,""]}

המשך מכאן

• עבודה עם רשומות — יצירה, עדכון ומחיקה
• אגרגציות — כשצריך סכום ולא רשימה
• batch — כמה פעולות בבקשה אחת
• מגבלות ומכסות — כל המספרים במקום אחד
• שגיאות ופתרון תקלות