visual-foxpro
ऑपरेटर्स

टिप्पणियों

न्यूमेरिक ऑपरेटर्स

न्यूमेरिक ऑपरेटर अन्य भाषाओं की तरह सबसे आसान और लगभग समान हैं।

• +, -, * और /। जोड़, घटाव, गुणा और भाग संचालक (VFP में पूर्णांक विभाजन नहीं है, आप परिणाम को INT (), CEILING () और FLOOR ()) के साथ पूर्णांक में बदल सकते हैं।
• % मापांक ऑपरेटर।
• ^ और **। ऑपरेटर की शक्ति। वे दोनों एक ही काम करते हैं।
• ()। समूह संचालक।
• संचालकों की पूर्वता है। आदेश है:

   ( )
   ^ (or **) 
   / and *
   - and +

    ? 10 / 5 + 2 && Outputs 4
    ? 2 + 10 / 5 && Outputs 4 as well. Division has precedence.
     
    * Both multiplication and division have same precedence
    * They would be interpreted from left to right.
    ? 4 * 5 / 2 + 5 && Outputs 15
    * Use parentheses whenever you are in doubt or want to be explicit
    ? ( (4 * 5) / 2 ) + 5 && Outputs 15. Explicit grouping of operations

    ? 4 * 5^2 && ^ has precedence, this is same as 4 * (5^2) = 100.
    ? (4 + 5)^2 && Using parentheses we say add 5 to 4 (9) and then square = 81. 

लॉजिकल ऑपरेटर्स

VFP के तार्किक संचालक, उनके क्रम के क्रम में हैं:

ऐतिहासिक रूप से, नहीं, और, या .NOT।, .AND।, .OR के रूप में लिखे गए हैं। यदि आप चाहें, तो भी आप उनका उपयोग कर सकते हैं, लेकिन AND, OR, NOT सरल और साफ है।

झूठे और सच्चे के लिए, आपको उपयोग करना होगा। और टी। क्रमशः शाब्दिक। आप इसके बजाय F और T का उपयोग नहीं कर सकते।

* Some logical variables
local llOld, llEmail  && any variable declaration implicitly initializes the variable as .F. - false
? m.llOld, m.llEmail && Prints .F. .F.

llOld   = .T.
llEmail = .F.

if ( m.llOld AND m.llEmail )
   ? 'Old AND should be emailed to'
endif
if ( m.llOld OR m.llEmail )
   ? 'Old OR should be emailed to'
endif
if ( m.llOld AND !m.llEmail ) && Same as (m.llOld AND NOT m.llEmail)
   ? 'Old BUT should NOT be emailed to'
endif

* Above code outputs
Old OR should be emailed to
Old BUT should NOT be emailed to

VFP में, तार्किक अभिव्यक्तियों का मूल्यांकन शॉर्टकट फैशन में किया जाता है। यही है, अगर चेक का पहला भाग पूरे परिणाम को संतुष्ट करता है, तो बाकी अभिव्यक्ति की व्याख्या भी नहीं की जाती है। एक नमूना इस प्रकार है:

? 1 = '2' && An obvious error. It would complain operator/operand type mismatch.

* However we could use such an expression in an if and get no error
* because it is not interpreted at all 
* (VFP is dynamic and there is no compile time check)

local llProcess
llProcess = .T.

if (m.llProcess OR (1='2'))
   ? 'Should do processing'
endif

* Would output

Should do processing

* without any error because m.llProcess true means
* the whole expression would be true, thus the expression after OR 
* is not interpreted at all.

एसक्यूएल क्वेरी, जो AND, या ऑपरेटर्स के साथ जुड़े हुए हैं, में कहा जाता है कि कभी-कभी आपको एक ऐसा नुकसान होता है, जिसमें आपको कई चेक की आवश्यकता होती है। जब उनमें से कई होते हैं, तो कोई इस तथ्य को अनदेखा कर सकता है कि ऑपरेटरों की एक मिसाल है (क्रम में), नहीं, और, या) और लगता है कि व्याख्या एक श्रृंखला में दाएं से बाएं की जाएगी। एक नमूने पर विचार करें:

select * from myTable where !isCustomer AND debit > 5000 OR discount > 5

इस प्रश्न का इरादा क्या है? यदि हम यह कहते हैं कि समूहबद्ध कोष्ठकों का उपयोग करके इसे स्पष्ट किया जाए:

((NOT isCustomer) AND debit > 5000) OR discount > 5

सरलीकृत यह "फर्स्ट एक्सप्रेशन" या (डिस्काउंट> 5) जैसा दिखता है। जो भी इरादा था, इस वजह से या यह चयन करेगा:

सभी पंक्तियों में (छूट> 5) - और यह भी कि यह 5000 से अधिक डेबिट वाला ग्राहक है।

शायद इरादा था "मुझे वे दे दो जहां यह ग्राहक नहीं है और (डेबिट 5000 से अधिक है या छूट 5 से अधिक है)"। यदि हम कोष्ठक का उपयोग करते हैं तो यह शुरू से ही स्पष्ट होगा:

select * from myTable where !isCustomer AND (debit > 5000 OR discount > 5)

आप उपयोग नहीं कर सकते हैं, लेकिन प्रारंभिक संचालक के लिए कोष्ठक के लायक नहीं है, जब इसका ऑपरेंड एक एकल अभिव्यक्ति है जो इसकी पूर्ववर्तीता के साथ पर्याप्त रूप से पठनीय है -! IsCustomer स्पष्ट रूप से (NOTCustomer) के रूप में पढ़ा जाता है।

चरित्र संचालक

पूर्वता के क्रम में केवल 4 वर्ण ऑपरेटर हैं:

+ सबसे सरल है और कई अन्य भाषाओं में तार को जोड़ने के लिए भी उपयोग किया जाता है।

local firstName, lastName
firstName = "John"
lastName  = "Smith"

? m.firstName + " " + m.lastName

आउटपुट: जॉन स्मिथ

- थोड़ा मुश्किल है, और व्यापक रूप से ज्ञात नहीं है। यह बाएं स्ट्रिंग से रिक्त स्थान लेता है, उन रिक्त स्थान को दाईं ओर स्ट्रिंग में जोड़ता है। मान लीजिए कि आपके पास पहले और अंतिम नामों वाली एक तालिका है और उनमें से प्रत्येक में 20 अक्षर हैं। हम पूर्ण नाम बनाने के लिए पहले और अंतिम नामों को संक्षिप्त करना चाहते हैं, और हम यह भी चाहते हैं कि परिणामी आकार निश्चित हो (इस मामले में 20 + 20 + 1 स्थान = 41)। चलिए इसे बनाते हैं आपका एक मध्य नाम का कॉलम भी है और हम चाहते हैं कि पूरा नाम "lastName, firstName midName_______" जैसा हो। इसका उपयोग करना आसान है - ऑपरेटर लेकिन आपको समूहन के लिए कोष्ठक का उपयोग करने की चाल को नोट करना चाहिए ताकि हम वास्तव में वही प्राप्त करें जो आप चाहते हैं:

* Create a cursor for our sample and fill in a few names
Create Cursor Names (firstName c(20), midName c(20), lastName c(20))

Insert Into Names (firstName, midName, lastName) Values ('Cetin','', 'Basoz')
Insert Into Names (firstName, midName, lastName) Values ('John', 'M', 'Smith')
Insert Into Names (firstName, midName, lastName) Values ('John', 'F', 'Kennedy')
Insert Into Names (firstName, midName, lastName) Values ('Tom', '', 'Hanks')

* Select with tricky - operator
Select *, ;
    lastName - (', '+firstName-(' '+midName)) As FullName ;
    from Names ;
    INTO Cursor crsNames ;
    nofilter

Browse

और ouput इस तरह है:

FullName कॉलम में सभी अनुगामी रिक्त स्थान को अच्छी तरह से अंत तक धकेल दिया जाता है। यदि आप संरचना की जाँच करते हैं तो पूरा नाम स्तंभ 63 वर्ण चौड़ा (3 * 20 + 3 वर्ण जो हमने जोड़ा)।

कोष्ठक के समूहीकरण के महत्व पर ध्यान दें (कोष्ठक को हटाने या अलग तरीके से व्यवस्थित करने का प्रयास करें)।

हालांकि - ऑपरेटर ऐसे मामलों में उपयोग करने के लिए आकर्षक हो सकता है, सिक्के का दूसरा पहलू है। यह ऑपरेटर VFP विशिष्ट है और इस प्रकार SQL पोर्टेबल नहीं है। आप इसके बजाय ANSI संगत SQL द्वारा समान परिणाम प्राप्त कर सकते हैं:

Select *, ;
    CAST(RTRIM(lastName) +', '+ RTRIM(firstName) +' '+ midName as char(63)) As FullName ;
    from Names ;
    INTO Cursor crsNames ;
    nofilter

अंतिम ऑपरेटर $ है। यह केवल जाँचता है कि क्या बायाँ स्ट्रिंग दाएँ स्ट्रिंग का हिस्सा है।

local upcased, digits, hexDigits
upcased = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
digits  = '0123456789'
hexDigits  = m.digits + 'ABCDEF'

? 'A' $ m.upcased && .T.
? 'a' $ m.upcased && .F.
? '1' $ m.digits && .T.
? 'F' $ m.digits && .F.
? 'F' $ m.hexDigits && .T.

महत्वपूर्ण: वीएफपी में, हालांकि आप किसी भी मामले (ऊपरी, निचले या मिश्रित) में अपना कोड लिख सकते हैं, तार हमेशा संवेदनशील होते हैं। उदाहरण के लिए: "स्मिथ" और "स्मिथ" दो अलग-अलग मूल्य हैं। या आपकी तालिका में यदि कोई देश स्तंभ है, तो आप 'यूएसए' नहीं पाएंगे यदि आप इसे 'यूएसए' के साथ खोजते हैं। समान $ ऑपरेटर के साथ जाता है, "जीई" $ "जर्मनी" झूठा है।

व्यक्तिगत नोट: हालाँकि आपको इसकी सादगी के लिए $ $ पसंद हो सकता है और आप इसे अक्सर Microsoft स्रोत कोड में उपयोग कर सकते हैं, IMHO यह बहुत कम मूल्य का है। अपने कैरियर में लिखी गई कई हजारों लाइनों के बारे में सोचकर, मुझे लगता है कि मुझे अपने कोड में बहुत कम घटनाएं मिलेंगी। लगभग हमेशा एक बेहतर विकल्प होता है (विशेषकर जब बायाँ ऑपरेंड एक एकल वर्ण और \ या केस संवेदी मामले नहीं होता है)।

दिनांक और समय ऑपरेटर

डेट के लिए मूल रूप से दो ऑपरेटर हैं, डेटाइम वैल्यूज़। तिथि करने के लिए + (- शायद एक सी अवधि) अतिभारित हैं / डेटाइम टाइम:

+ आसान है। इसके दो ऑपरेंड हैं, एक डेट या डेटाइम वैल्यू है और दूसरा एक न्यूमेरिक है (हालाँकि आप किसी भी न्यूमेरिक का इस्तेमाल कर सकते हैं, यह सभी व्यावहारिक उद्देश्यों के लिए एक पूर्णांक है)।

जब कोई ऑपरेंड एक तारीख होता है, तो संख्यात्मक ऑपरेंड को "दिन" के रूप में लिया जाता है:

? Date() + 10 && Get the date 10 days later
* VFP is leap year aware when doing date math
? Date(2016, 2, 28) + 1 && Add 1 day to Feb 28, 2016. Returns Feb 29, 2016.
? Date(2017, 2, 28) + 1 && Add 1 day to Feb 28, 2017. Returns Mar 1, 2017.

जब कोई एक ऑपरेंड एक डेटाइम होता है, तो न्यूमेरिक ऑपरेंड को "दूसरा" के रूप में लिया जाता है:

एक दिन में 24 * 60 * 60 = 86400 सेकंड होते हैं

? Datetime() + 86400 && Add 1 day to current datetime. 

जनवरी 1, 2016 2:20 बजे 4 घंटे और 15 मिनट जोड़ें

? Datetime(2016, 1, 1, 14, 20, 0) + (4 * 3600 + 15 * 60) 

आउटपुट शुक्रवार, 1 जनवरी 2016, शाम 6:35:00 बजे।

एक साधारण मुद्रण का उपयोग करके, जो आप अपनी स्क्रीन पर देखते हैं, वह आपकी दिनांक सेटिंग्स पर निर्भर है। उदाहरण के लिए, यदि आपने कुछ भी नहीं बदला है, तो आपकी दिनांक सेटिंग अमेरिकन शैली (MDY), 12 घंटे का प्रारूप (AM / PM) और शताब्दी केवल अंतिम 2 अंकों के साथ दिखाई गई है।

तिथि और डेटाटाइम के लिए एक विशेष प्रतीक ^ है जिसमें एक स्ट्रिंग को '' कड़ाई '' के रूप में व्याख्या करने के लिए मजबूर किया जाता है जैसे कि yyyy / MM / dd [HH: mm: ss | hh: mm: ss tt] प्रारूप। इसलिए ^ को डेट / डेटटाइम ऑपरेटर के रूप में भी माना जा सकता है। उदाहरण के लिए विचार करें कि कुछ डेटा 201610082230 (yyyMMddHHmm) जैसे प्रारूप में एक स्रोत से आ रहा है। उस मूल्य को वैध डेटटाइम के रूप में प्राप्त करने के लिए:

Local cSample, tSample
cSample = '201610082230'
tSample = Ctot(Transform(m.cSample, '@R ^9999/99/99 99:99'))
? Transform(m.tSample, '@YL')

आउटपुट (आपके सिस्टम की लंबी तिथि सेटिंग के आधार पर):

शनिवार, 8 अक्टूबर 2016, रात 10:30:00 बजे

- घटाव के लिए प्रयोग किया जाता है। इसके ऑपरेंड या तो दोनों डेट / डेटाइम मान हैं या एक डेट / डेटटाइम है और दूसरा न्यूमेरिक है।

आइए सरल तिथि / डेटाटाइम और संख्यात्मक ऑपरेंड्स के साथ शुरू करें (जैसे + ऑपरेटर के साथ):

जब कोई ऑपरेंड एक तारीख होता है, तो संख्यात्मक ऑपरेंड को "दिन" के रूप में लिया जाता है:

? Date() - 10 && What was the date 10 days ago?
? Date(2016, 3, 1) - 1 && Returns Feb 29, 2016.
? Date(2017, 3, 1) - 1 && Returns Feb 28, 2017.

जब कोई एक ऑपरेंड एक डेटाइम होता है, तो न्यूमेरिक ऑपरेंड को "दूसरा" के रूप में लिया जाता है:

? Datetime() - 86400 && Go back exactly one day

"अभी" से 1 घंटा और 30 मिनट पहले प्राप्त करें:

? Datetime() - (1 * 3600 + 30 * 60) 

दूसरा रूप दो तिथि / डेटाइम मानों के बीच अंतर प्राप्त करना है। ऑपरेंड डेट या डेटटाइम दोनों हैं, आप एक ही समय में डेट और डेटटाइम का उपयोग नहीं कर सकते हैं (आवश्यकतानुसार रूपांतरण टाइप करें, वीएफपी आपके लिए ऐसा नहीं करता है)। नियम + और - के रूप में हैं, ऑपरेंड डेट हैं फिर भी अंतर दिनों में है , ऑपरेंड डेटाइम हैं फिर अंतर सेकंड में है ।

नए साल की पूर्व संध्या (वर्ष 2016 के लिए) कितने दिन है?

? Date(2016, 12, 31) - Date()

आधी रात को कितने सेकंड बचे हैं?

? Dtot(Date()+1) - Datetime()

पिछले नमूने में हमने कल की आधी रात के मूल्य प्राप्त करने के लिए एक दिनांक / डेटाइम फ़ंक्शन, DTOT - DateToTime का उपयोग किया था। कई उपयोगी दिनांक / डेटटाइम फ़ंक्शन उपलब्ध हैं, हमने उन सभी को छोड़ दिया है क्योंकि वे तकनीकी रूप से ऑपरेटर नहीं माने जाते हैं (हालाँकि वे डेट / डेटाइम पर काम करते हैं :) वही अन्य ऑपरेटरों के साथ भी सही होता है।

दिनांक / डेटाटाइम घटाव हस्ताक्षरित है । यदि आप पहले ऑपरेंड के रूप में छोटी तिथि / डेटटाइम का उपयोग करते हैं तो परिणाम नकारात्मक होगा। यदि आप तिथि / तिथि के आदेश की परवाह किए बिना सकारात्मक परिणाम प्राप्त करने की आवश्यकता है तो आप एब्स () फ़ंक्शन का उपयोग कर सकते हैं।

संबंधपरक संकारक

सभी ऑपरेटरों में से, रिलेशनल ऑपरेटर सबसे जटिल हैं, यही कारण है कि हमने उन्हें अंत तक छोड़ दिया।

रिलेशनल ऑपरेटर्स को कंपेरिजन ऑपरेटर के रूप में भी जाना जाता है, उनका उपयोग चीजों की तुलना करने के लिए किया जाता है।

तुलना परिणाम बूलियन गलत या सच है।

दिलचस्प बात यह है कि, अगर आप इसे VFP में जाँचते हैं तो आपको केवल एक छोटी सूची संचालन और कुछ और लाइनें देखने में मदद मिलती हैं जैसे कि यह उन सभी ऑपरेटरों के बारे में है।

खैर, जटिलता इस तथ्य से आती है कि, वे किसी भी प्रकार पर काम करते हैं यह एक संख्यात्मक, तिथि, तिथि, तार्किक या एक स्ट्रिंग और यहां तक कि वस्तुओं पर भी हो सकता है। इसके अलावा, व्यवहार अजीब लग सकता है, आपको वह नहीं मिलता जो आप उम्मीद करते हैं जब तक कि आपको नहीं पता कि परिणाम क्या होते हैं।

आइए रिलेशनल ऑपरेटरों की सूची से शुरू करते हैं:

यद्यपि आप इनका उपयोग सभी डेटा प्रकारों के साथ कर सकते हैं, लेकिन ऑपरेंड्स के बीच एक प्रकार की संगतता होनी चाहिए। उदाहरण के लिए, यदि आप किसी दिनांक को किसी पूर्णांक से तुलना करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी।

दिनांक और डेटाटाइम की तुलना की जा सकती है, हालांकि वे अलग-अलग प्रकार के होते हैं, VFP रूपांतरण आपके लिए निहित है।

? Date() > DateTime() && .F. 
? Date() <= DateTime() && .T. 
? Date() < DateTime() && .T. if it is not midnight

जब ऑपरेंड संख्यात्मक होते हैं, तो ये सभी ऑपरेटर सरल और सीधे आगे होते हैं, वे काम करते हैं जैसे वे गणितीय अभिव्यक्ति में करते हैं।

तार्किक ऑपरेंड्स के साथ, .F। से कम माना जाता है।

वस्तुओं के साथ हम जो तुलना कर रहे हैं वह स्मृति में ऑब्जेक्ट का संदर्भ है। इस प्रकार सबसे अधिक इस्तेमाल की जाने वाली तुलना यह निर्धारित करने के लिए है कि दो वस्तु चर एक ही वस्तु की ओर इशारा कर रहे हैं। अर्थात:

local o1, o2
o1 = createobject('Label')
o2 = createobject('Label')
? m.o1 = m.o2 && is o1 and o2 the same object?
? m.o1 > m.o2 && this would work too but likely you would never use

* remember we are comparing their references in memory
* 
* They are different objects, but do they have any difference in their properties?
? CompObj(m.o1, m.o2) && .T. They are identical properties wise

वर्ण डेटा प्रकार की तुलना, स्ट्रिंग्स की उर्फ तुलना वीएफपी में सबसे अधिक भ्रमित करने वाली है। यह अन्य भाषाओं और / या डेटाबेस की तरह काम नहीं करता है और VFP के लिए अद्वितीय है (और शायद कुछ अन्य xBase भाषा के लिए)।

कई साल पहले, मैंने समुदाय में कुछ वास्तव में उन्नत सदस्यों को भी देखा है जिन्हें अभी तक पता नहीं था कि ये ऑपरेटर वीएफपी में कैसे काम करते हैं। तो यह काफी समझ में आता है मामूली बारीकियों को आसानी से newbies भ्रमित कर सकता है।

तुलना मूल रूप से समान होने या न होने के बारे में है। यदि वे समान नहीं हैं, तो हम ऑपरेटरों के बारे में सोच सकते हैं>, <,> =, <=, सही? तार के साथ यह भ्रामक है जब दो तारों को समान माना जाता है ।

महत्वपूर्ण: VFP तार संवेदनशील होते हैं। 'ए' और 'ए' दो अलग तार हैं। यह कई डेटाबेस के साथ ऐसा नहीं है, जहां डिफ़ॉल्ट केस असंवेदनशील टकराव का उपयोग करना है। उदाहरण के लिए postgreSQL, या MS SQL सर्वर में असंवेदनशील (CI) समतलीकरण के साथ बनाई गई तालिका पर:

select * from myTable where Country = 'TURKEY'

select * from myTable where Country = 'Turkey'

एक ही परिणाम होगा। वीएफपी में हालांकि आपको केवल वही मिलता है जहां केसिंग मैच होता है। हालांकि वीएफपी के पास कुछ समतलीकरण समर्थन है और मामले को असंवेदनशील तुलना करता है। (भरोसा मत करो, नीचे देखें)

• यदि दो तार बराबर नहीं हैं, तो अब तक अच्छे हैं, बशर्ते कि आपने कोई चूक नहीं बदली है तो उनकी तुलना उनके ASIIII मूल्यों के आधार पर की जाती है ।

  ? 'Basoz' < 'Cetin' && is true.
  ? 'basoz' < 'Cetin' && is false.
  ? 'Cetin' < 'David' && is true.
  ? 'Çetin' < 'David' && is false.
  

टक्कर के लिए डिफ़ॉल्ट 'मशीन' है और यही आपको मिलता है। जब आप किसी और चीज़ से कोलाज को बदलते हैं तो आपको उस कोलाजेशन के क्रम के आधार पर तुलना मिलती है। डिफ़ॉल्ट मशीन के अलावा अन्य कोलाज सेटिंग के साथ आप तुलना पर असंवेदनशीलता का भी आरोप लगा रहे हैं (समानता के लिए इस पर भरोसा न करें):

  set collate to 'GENERAL'
  ? 'Basoz' < 'Cetin'
  ? 'basoz' < 'Cetin'
  ? 'Cetin' < 'David'
  ? 'Çetin' < 'David'

अब ये सभी अभिव्यक्तियाँ सत्य हैं।

व्यक्तिगत सलाह: VFP में Collations पर्याप्त विश्वसनीय कभी नहीं किया गया है। मेरा सुझाव है कि आप डिफ़ॉल्ट 'MACHINE' से टकराव और छड़ी का उपयोग न करें। यदि आप टकरावों का उपयोग करते हैं, तो पहले ध्यान रखें कि जब आप किसी ऐसी चीज़ का अनुभव करें जो चरित्र डेटा के बारे में बहुत अप्रत्याशित हो। मैंने देखा है और प्रदर्शित किया है कि यह कई मामलों में विफल रहता है, लेकिन फिर मैंने इसे VFP9 संस्करण से पहले उपयोग करने की कोशिश करना बंद कर दिया, यह अब संगत हो सकता है, मुझे वास्तव में नहीं पता है।

स्ट्रिंग्स के साथ असमानता के मामलों को कवर करने पर विचार करते हुए, ट्रिकी एक समानता का मामला है। VFP में मूल रूप से दो सेटिंग्स प्रभाव की तुलना करती हैं:

1. सेट एक्सपैक्ट (डिफ़ॉल्ट बंद है और एसक्यूएल को छोड़कर - नियमित तुलना के प्रभाव)
2. SET ANSI (डिफ़ॉल्ट बंद है और केवल SQL में तुलना प्रभाव। SET EXACT का SQL प्रश्नों के भीतर की गई तुलना पर कोई प्रभाव नहीं है ।

SET EXACT OFF के साथ, तुलना को पढ़ें "स्ट्रिंग दायीं ओर स्ट्रिंग के साथ बाईं ओर शुरू होता है"? उनकी तुलना दाएं स्ट्रिंग की लंबाई तक की जाती है।

? "Bobby" = "B" && Bobby starts with B, so TRUE
? "Bobby" = "Bob" && Bobby starts with Bob, so TRUE
? "Bobby" = "Bob " && Bobby starts with Bob but there is a trailing space there, FALSE
? "Bobby" = "bob" && would be true with collation set to GENERAL

ध्यान दें कि नियमित तुलना के साथ, "बॉबी" = "बी" TRUE है, लेकिन "बी" = "बॉबी" FALSE है। दूसरे शब्दों में, ऑपरेंड्स का स्थान महत्वपूर्ण है।

सेट के साथ स्ट्रिंग्स पूरी तरह से मेल खाना चाहिए, लेकिन उनकी अनुगामी रिक्त स्थान की अनदेखी की जाती है (हम यहां सेट कोलाज की अनदेखी कर रहे हैं जो मामले को असंवेदनशील भी करेगा):

? "BOBBY" = "BOB" && FALSE 
? "BOBBY" = "BOBBY" && TRUE
? "BOBBY" = "BOBBY     " && TRUE 
? "BOBBY     " = "BOBBY" && TRUE

अब, SQL कमांड के साथ SET EXACT का कोई प्रभाव नहीं है और यह SET EXACT OFF की तरह व्यवहार करेगा।

Select * from Customers where Country = 'U'

'यू' से शुरू होने वाले किसी भी देश यूएसए, यूके के ग्राहकों का चयन करेगा।

एसक्यूएल में, हालांकि, परिचालनों के क्रम को बदलकर, उसी परिणाम को प्राप्त करना चाहिए। इस प्रकार:

Select * from Customers where 'U' = Country

यह भी उसी तरह काम करेगा (गैर-SQL कमांड से अंतर को नोट करें)।

जब आप सटीक मिलान करना चाहते हैं, तो एक विकल्प ANSI चालू करना है:

SET ANSI ON
Select * from Customers where Country = 'USA'

यूएसए से उन सभी ग्राहकों को लौटाता है। ध्यान दें, देश के क्षेत्र या सही अभिव्यक्ति पर अनुगामी रिक्त स्थान को नजरअंदाज किया जाता है। इससे कोई फर्क नहीं पड़ता है कि आपके पास दोनों तरफ कितने ट्रेलिंग हैं। आप तुलना इस तरह से करते हैं जैसे कि यह किया गया था: आरटीआरआईएम (देश) = आरटीआरआईएम ('यूएसए')।

यद्यपि इसका उल्लेख VFP में ऑपरेटर्स में नहीं किया गया है, लेकिन SQL ऑपरेटर LIKE है। जब आप LIKE का उपयोग करते हैं, तो आपको SET ANSI सेटिंग की परवाह किए बिना एक सटीक मिलान की तुलना मिलती है (LIKE ताकतों का उपयोग करके और मामले पर ANSI को निहित करना - यह एक ANSI ऑपरेटर है)। हालाँकि, व्यवहार में थोड़ा अंतर होना चाहिए। यह अनुगामी रिक्त स्थान की अनदेखी नहीं करेगा, जब तक कि ट्रेलरों के साथ कुल आकार फ़ील्ड आकार के बराबर या उससे कम न हो। उदाहरण के लिए यदि कंट्री फ़ील्ड C (10) है, तो देश = 'USA' या देश = 'USA__' काम करेगा, लेकिन Country = 'USA___________' विफल हो जाएगा ( अंडरस्कोर किसी स्थान को निरूपित करता है और अंतिम में 7 अनुगामी रिक्त स्थान होते हैं)।

अंत में हम अंतिम ऑपरेटर तक हैं, ==। इसका मतलब बिल्कुल बराबर है और तार के साथ उपयोग करने के लिए बनाता है। एक लाभ यह है कि, == आप हमेशा मतलब है कि आप सेट मैच या सेट ANSI सेटिंग्स की परवाह किए बिना सटीक मैच चाहते हैं। हालाँकि फिर से सावधान रहें, जब एसक्यूएल कमांड या नॉनएसक्यूएल रेगुलर कमांड होता है तो इसका व्यवहार अलग होता है।

SQL के साथ:

Select * from Customers where Country == 'USA'

ANSI और EXACT सेटिंग जो भी हो, हम सभी ग्राहकों को केवल यूएसए से चाहते हैं। दोनों तरफ ट्रेलिंग स्पेस की अनदेखी की जाती है।

गैर-SQL के साथ:

? m.lcString1 == m.lcString2

केवल तभी सच होगा जब वे बिल्कुल समान हों, उनके आवरण और लंबाई के बारे में (अनुगामी रिक्त स्थान की अनदेखी नहीं की जाती)। यह SET ANSI, EXACT या COLLATE सेटिंग्स से प्रभावित नहीं है।