قواعد التصفية العددية

نظرة عامة

يقوم التعبير المسند بإخراج قيمة منطقية. يقوم ميلفوس بإجراء تصفية عددية من خلال البحث باستخدام المسندات. يقوم التعبير المسند، عند تقييمه، بإرجاع إما TRUE أو FALSE. اعرض مرجع Python SDK API للحصول على تعليمات حول استخدام التعبيرات المسندة.

تصف قواعد نحوEBNF قواعد التعبيرات المنطقية:

Expr = LogicalExpr | NIL
LogicalExpr = LogicalExpr BinaryLogicalOp LogicalExpr 
              | UnaryLogicalOp LogicalExpr
              | "(" LogicalExpr ")"
              | SingleExpr;
BinaryLogicalOp = "&&" | "and" | "||" | "or";
UnaryLogicalOp = "not";
SingleExpr = TermExpr | CompareExpr;
TermExpr = IDENTIFIER "in" ConstantArray;
Constant = INTEGER | FLOAT
ConstantExpr = Constant
               | ConstantExpr BinaryArithOp ConstantExpr
               | UnaryArithOp ConstantExpr;
                                                          
ConstantArray = "[" ConstantExpr { "," ConstantExpr } "]";
UnaryArithOp = "+" | "-"
BinaryArithOp = "+" | "-" | "*" | "/" | "%" | "**";
CompareExpr = IDENTIFIER CmpOp IDENTIFIER
              | IDENTIFIER CmpOp ConstantExpr
              | ConstantExpr CmpOp IDENTIFIER
              | ConstantExpr CmpOpRestricted IDENTIFIER CmpOpRestricted ConstantExpr;
CmpOpRestricted = "<" | "<=";
CmpOp = ">" | ">=" | "<" | "<=" | "=="| "!=";
MatchOp = "like" | "LIKE";
JsonArrayOps = JsonDefs "(" IDENTIFIER "," JsonExpr | JsonArray ")";
JsonArrayDefs = "json_contains" | "JSON_CONTAINS" 
           | "json_contains_all" | "JSON_CONTAINS_ALL" 
           | "json_contains_any" | "JSON_CONTAINS_ANY";
JsonExpr =  Constant | ConstantArray | STRING | BOOLEAN;
JsonArray = "[" JsonExpr { "," JsonExpr } "]";
ArrayOps = ArrayDefs "(" IDENTIFIER "," ArrayExpr | Array ")";
ArrayDefs = "array_contains" | "ARRAY_CONTAINS" 
           | "array_contains_all" | "ARRAY_CONTAINS_ALL" 
           | "array_contains_any" | "ARRAY_CONTAINS_ANY"
           | "array_length"       | "ARRAY_LENGTH";
ArrayExpr =  Constant | ConstantArray | STRING | BOOLEAN;
Array = "[" ArrayExpr { "," ArrayExpr } "]";

يسرد الجدول التالي وصف كل رمز مذكور في قواعد التعبيرات المنطقية أعلاه.

الرمز	الوصف
=	التعريف
,	التسلسل
;	الإنهاء
|	التناوب.
{...}	التكرار.
(...)	تجميع.
لا شيء	فارغ. يمكن أن يكون التعبير سلسلة فارغة.
INTEGER	الأعداد الصحيحة مثل 1، 2، 3.
عائم	أرقام عائمة مثل 1.0، 2.0.
كونست	أعداد صحيحة أو أرقام عائمة.
معرّف	معرّف. في ميلفوس، يمثل المعرف اسم الحقل.
LogicalOp	LogicalOp هو مشغل منطقي يدعم دمج أكثر من عملية علائقية في مقارنة واحدة. القيمة العائدة من LogicalOp هي إما TRUE (1) أو FALSE (0). هناك نوعان من LogicalOps، بما في ذلك BinaryLogicalOps و UnaryLogicalOps.
الأحادي المنطقي	يشير UnaryLogicalOp إلى المشغّل المنطقي الأحادي "ليس".
BinaryLogicalOp	العوامل المنطقية الثنائية التي تنفذ إجراءات على معاملين. في التعبير المعقد الذي يحتوي على معاملين أو أكثر، يعتمد ترتيب التقييم على قواعد الأسبقية.
حسابيOp	يقوم ArithmeticOp، أي عامل حسابي، بتنفيذ عمليات رياضية مثل الجمع والطرح على المعاملات.
UnaryArithOp	UnaryArithOp هو مشغّل حسابي يقوم بإجراء عملية على معامل واحد. يغيّر UnaryArithOp السالب تعبيرًا موجبًا إلى سالب، أو العكس.
ثنائيArithOp	يُجري BinaryArithOp، أي مشغّل ثنائي، عمليات على معاملين. في التعبير المركب الذي يحتوي على معاملين أو أكثر، يعتمد ترتيب التقييم على قواعد الأسبقية.
CmpOp	CmpOp هو مشغّل علائقي ينفذ عمليات على معاملين اثنين.
CmpOpRestricted	يقتصر CmpOpRestricted على "أقل من" و "مساوٍ".
ثابتExpr	يمكن أن يكون ConstantExpr ثابتًا أو ثنائيًا على اثنين من ConstExprs أو أحاديًا على ثابت واحد. يتم تعريفه بشكل متكرر.
مصفوفة ثابتة	يتم تغليف ConstantArray بأقواس مربعة، ويمكن تكرار ConstantExpr في الأقواس المربعة. يجب أن تتضمن ConstantArray على الأقل ConstantExpr واحدًا على الأقل.
مصطلحExpr	يُستخدم TermExpr للتحقق مما إذا كانت قيمة المعرّف تظهر في ConstantArray أم لا. يتم تمثيل TermExpr بحرف "في".
قارنإكسبر	يمكن أن يكون تعبير المقارنة، أي تعبير المقارنة عمليات علائقية على معرّفين، أو عمليات علائقية على معرّف واحد ومعرّف واحد ConstantExpr، أو عمليات ثلاثية على معرّفين ثابتين ومعرّف واحد.
مفردExpr	يمكن أن يكون SingleExpr، أي التعبير المفرد، إما مصطلحExpr أو مقارنةExpr.
LogicalExpr	يمكن أن يكون LogicalExpr تعبيرًا ثنائيًا منطقيًا ثنائيًا على تعبيرين منطقيين، أو تعبيرًا أحاديًا منطقيًا أحاديًا على تعبير منطقي واحد، أو تعبيرًا منطقيًا مجمّعًا داخل قوسين، أو تعبيرًا أحاديًا. يُعرَّف LogicalExpr بشكل متكرر.
Expr	Expr، وهو اختصار يعني التعبير، يمكن أن يكون LogicalExpr أو NIL.
تطابق	يقارن MatchOp، أي مشغل مطابقة، سلسلة بثابت سلسلة أو بادئة سلسلة أو لاحقة أو ثابت لاحقة.
JsonArrayOp	يتحقق JsonOp، أي مشغّل JSON، مما إذا كان المعرف المحدد يحتوي على العناصر المحددة.
ArrayOp	يتحقق ArrayOp، أي مشغّل مصفوفة، من احتواء المعرّف المحدّد على العناصر المحدّدة.

المشغلات

المشغلات المنطقية

يقوم المشغلات المنطقية بإجراء مقارنة بين تعبيرين.

الرمز	عملية	مثال	الوصف
'و' &&&	و	expr1 & & expr2	صحيح إذا كان كل من expr1 و expr2 صحيحين.
'أو' ||	أو	expr1 || expr2	صحيح إذا كان كل من expr1 أو expr2 صحيحين.

العوامل الحسابية الثنائية

تحتوي العوامل الحسابية الثنائية على معاملين ويمكنها إجراء عمليات حسابية أساسية وإرجاع النتيجة المقابلة.

الرمز	العملية	مثال	الوصف
+	الإضافة	أ + ب	جمع المعاملين.
-	الطرح	أ - ب	اطرح المعامل الثاني من المعامل الأول.
*	الضرب	أ * ب	ضرب المعاملين.
/	القسمة	أ/ب	قسمة المعامل الأول على المعامل الثاني.
**	القوة	أ ** ب	ارفع المعامل الأول إلى قوة المعامل الثاني.
%	مودولو	أ % ب	قسمة المعامل الأول على المعامل الثاني وإعطاء الجزء المتبقي.

العوامل العلائقية

تستخدم العوامل العلائقية الرموز للتحقق من التساوي أو عدم المساواة أو الترتيب النسبي بين تعبيرين.

الرمز	العملية	مثال	الوصف
<	أقل من	أ <ب	صحيح إذا كان a أقل من b.
>	أكبر من	أ > ب	صحيح إذا كانت أ أكبر من ب.
==	يساوي	أ = = ب	صواب إذا كان أ يساوي ب.
!=	لا يساوي	أ != ب	صواب إذا كان أ لا يساوي ب.
<=	أقل من أو يساوي	أ <= ب	صواب إذا كان أ أقل من أو يساوي ب.
>=	أكبر من أو يساوي	أ >= ب	صواب إذا كان أ أكبر من أو يساوي ب.

أسبقية وربط العوامل

يسرد الجدول التالي أسبقية وربط المعاملات. يتم سرد المعاملات من الأعلى إلى الأسفل، بأسبقية تنازلية.

الأسبقية	المعامل	الوصف	الارتباطية
1	+ -	يونياري أرثوب	من اليسار إلى اليمين
2	لا	يونياري لوجيكوب	من اليمين إلى اليسار
3	**	ثنائي أرثوب	من اليسار إلى اليمين
4	* / %	BinaryArithOp	من اليسار إلى اليمين
5	+ -	BinaryArithOp	من اليسار إلى اليمين
6	< <= > >>=	CmpOp	من اليسار إلى اليمين
7	== !=	CmpOp	من اليسار إلى اليمين
8	مثل LIKE	ماتشوبوب	من اليسار إلى اليمين
9	json_contains JSON_CONTAINS	JsonArrayOp	من اليسار إلى اليمين
9	مصفوفة_تحتوي على ARRAY_CONTAINS	مصفوفة	من اليسار إلى اليمين
10	json_contains_all JSON_CONTAINS_ALL	JsonArrayOp	من اليسار إلى اليمين
10	صفيف_يحتوي_الجميع ARRAY_CONTAINS_ALL	مصفوفة	من اليسار إلى اليمين
11	json_concontains_any JSON_CONTAINS_ANY	JsonArrayOp	من اليسار إلى اليمين
11	مصفوفة_تحتوي_على_أي ARRAY_CONTAINS_ANY	مصفوفة	من اليسار إلى اليمين
12	طول_المصفوفة ARRAY_LENGTH	مصفوفة	من اليسار إلى اليمين
13	و&و	BinaryLogicOp	من اليسار إلى اليمين
14	| أو	BinaryLogicOp	من اليسار إلى اليمين

يتم تقييم التعبيرات عادةً من اليسار إلى اليمين. يتم تقييم التعبيرات المعقدة واحدًا تلو الآخر. يتم تحديد ترتيب تقييم التعبيرات حسب أسبقية العوامل المستخدمة.

إذا احتوى تعبير ما على عاملين أو أكثر بنفس الأسبقية، يتم تقييم العامل الموجود إلى اليسار أولاً.

عندما يجب أن تتم معالجة عملية ذات أسبقية أقل أولاً، يجب أن تكون بين قوسين.

يمكن تداخل الأقواس داخل التعبيرات. يتم تقييم التعبيرات القوسية الداخلية أولًا.

الاستخدام

يتم سرد نماذج لجميع استخدامات التعبيرات المنطقية المتاحة في ميلفوس على النحو التالي (int64 يمثل الحقل القياسي الذي يحتوي على بيانات من نوع INT64، float يمثل الحقل القياسي الذي يحتوي على بيانات من نوع الفاصلة العائمة، و VARCHAR يمثل الحقل القياسي الذي يحتوي على بيانات من نوع VARCHAR):

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp والقوسين

"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"

3. مصطلحExpr و UnaryLogicOp

"int64 not in [1, 2, 3]"

VARCHAR not in ["str1", "str2"]

4. TermExpr وBinaryLogicalOp وCmpOp (على حقول مختلفة)

"int64 in [1, 2, 3] and float != 2"

5. BinaryLogicalOp وCmpOp

"int64 == 0 || int64 == 1 || int64 == 2"

6. CmpOp و UnaryArithOp أو BinaryArithOp

"200+300 < int64 <= 500+500"

7. تطابق

VARCHAR like "prefix%"
VARCHAR like "%suffix"
VARCHAR like "%middle%"
VARCHAR like "_suffix"

8. JsonArrayOp

• JSON_CONTAINS(identifier, JsonExpr)

  إذا كان تعبير JSON الخاص بعبارة JSON_CONTAINS (الوسيطة الثانية) قائمة، فيجب أن يكون المعرف (الوسيطة الأولى) قائمة قائمة قائمة. خلاف ذلك، يتم تقييم العبارة دائمًا إلى خطأ.

  # {"x": [1,2,3]}
  json_contains(x, 1) # ==> true
  json_contains(x, "a") # ==> false
      
  # {"x": [[1,2,3], [4,5,6], [7,8,9]]}
  json_contains(x, [1,2,3]) # ==> true
  json_contains(x, [3,2,1]) # ==> false
  

• JSON_CONTAINS_ALL(identifier, JsonExpr)

  يجب أن يكون تعبير JSON في عبارة JSON_CONTAINS_ALL دائمًا قائمة.

  # {"x": [1,2,3,4,5,7,8]}
  json_contains_all(x, [1,2,8]) # ==> true
  json_contains_all(x, [4,5,6]) # ==> false 6 is not exists
  

• JSON_CONTAINS_ANY(identifier, JsonExpr)

  يجب أن يكون تعبير JSON في عبارة JSON_CONTAINS_ANY دائمًا قائمة. وإلا فإنها تعمل مثل JSON_CONTAINS.

  # {"x": [1,2,3,4,5,7,8]}
  json_contains_any(x, [1,2,8]) # ==> true
  json_contains_any(x, [4,5,6]) # ==> true
  json_contains_any(x, [6,9]) # ==> false
  

9. مصفوفة

• ARRAY_CONTAINS(identifier, ArrayExpr)

  إذا كان تعبير المصفوفة في عبارة ARRAY_CONTAINS (الوسيطة الثانية) قائمة، فيجب أن يكون المعرف (الوسيطة الأولى) قائمة قائمة قائمة. وإلا فإن العبارة تُقيّم دائمًا على خطأ.

  # 'int_array': [1,2,3]
  array_contains(int_array, 1) # ==> true
  array_contains(int_array, "a") # ==> false
  

• ARRAY_CONTAINS_ALL(identifier, ArrayExpr)

  يجب أن يكون تعبير الصفيف في عبارة ARRAY_CONTAINS_ALL دائمًا قائمة.

  # "int_array": [1,2,3,4,5,7,8]
  array_contains_all(int_array, [1,2,8]) # ==> true
  array_contains_all(int_array, [4,5,6]) # ==> false 6 is not exists
  

• ARRAY_CONTAINS_ANY(identifier, ArrayExpr)

  يجب أن يكون تعبير الصفيف في عبارة ARRAY_CONTAINS_ANY دائمًا قائمة. وإلا فإنها تعمل مثل ARRAY_CONTAINS.

  # "int_array": [1,2,3,4,5,7,8]
  array_contains_any(int_array, [1,2,8]) # ==> true
  array_contains_any(int_array, [4,5,6]) # ==> true
  array_contains_any(int_array, [6,9]) # ==> false
  

• ARRAY_LENGTH(identifier)

  تحقق من عدد العناصر في مصفوفة.

  # "int_array": [1,2,3,4,5,7,8]
  array_length(int_array) # ==> 7
  

ما التالي

الآن بعد أن تعرفت على كيفية عمل مجموعات البتات في ميلفوس، قد ترغب أيضًا في:

• تعلّم كيفية إجراء بحث هجين.
• تعلم كيفية استخدام السلاسل لتصفية نتائج البحث.
• تعلم كيفية استخدام الحقول الديناميكية في بناء التعبيرات المنطقية.