SWISH-LIBRARY - אונליין בענן

תָכְנִית:

שֵׁם

SWISH-LIBRARY - ממשק לספריית Swish-e C

סקירה כללית

ספריית C בממשק לקוד החיפוש Swish-e. היא מספקת דרך להטמיע
Swish-e לתוך האפליקציות שלך. ממשק API זה מבוסס על Swish-e גרסה 2.3.

הערה: זהו ממשק API חדש החל מגרסה 2.3 של Swish-e. ממשק שפת C השתנה.
כמו גם ממשק ה-perl של Swish-e. ממשק ה-perl החדש הוא מודול SWISH::API ו-
כלול בהפצת Swish-e. מודול הפרל הישן של SWISHE נכתב מחדש
לעבוד עם ממשק ה-API החדש. מודול ה-perl SWISHE אינו כלול עוד ב-Swish-e.
הפצה, אך ניתן להוריד אותה מאתר האינטרנט של Swish-e.

היתרון של הספרייה הוא שניתן לפתוח את קבצי האינדקס או הקבצים פעם אחת ו...
שאילתות רבות שבוצעו על האינדקס הפתוח. זה חוסך את זמן האתחול הנדרש לפיצול והרצה
קובץ הבינארי swish-e, והזמן היקר של פתיחת קובץ האינדקס. כמה מדדי ביצועים
הראו עלייה של פי שלושה במהירות.

החיסרון הוא שעכשיו יש יותר קוד ונתונים בתוכנית שלך (טבלאות האינדקס יכולות
(משתמשים בכמות לא מבוטלת של זיכרון), ואם מתרחשת שגיאה חמורה ב-swish היא תפיל את ה-
תוכנית. אלו דברים שכדאי לחשוב עליהם, במיוחד אם מטמיעים את swish בשרת אינטרנט.
כמו אפאצ'י שבו ישנם תהליכים רבים המשרתים בקשות.

הדרך הטובה ביותר ללמוד על הספרייה היא להסתכל על שני קבצים הכלולים ב-Swish-e
הפצה שעושה שימוש בספרייה.

src/libtest.c
קובץ זה נותן סקירה בסיסית של קישור תוכנית C עם ספריית Swish-e. לא
כל הפונקציות הזמינות משמשות בדוגמה זו, אך היא אמורה לתת לך תמונה טובה
סקירה כללית של בניית תוכנית C עם swish-e.

כדי לבנות ולהריץ את libtest chdir לתיקיית src ולהריץ את הפקודות:

$ הפוך את libtest
$ ./libtest [שם אופציונלי של קובץ אינדקס]

תתבקשו להזין את מילות החיפוש. האינדקס המוגדר כברירת מחדל הוא index.swish-e.
ניתן לעקוף זאת על ידי הצבת רשימה של קבצי אינדקס במחרוזת מוגנת במרכאות.

$ ./libtest 'index1 index2 index3'

perl/API.xs
השמיים API.xs הקובץ הוא ממשק "xsub" של Perl לספריית C והוא חלק מ-
מודול SWISH::API Perl. זהו ממשק מונחה עצמים לספריית Swish-e.
ומדגים כיצד "אובייקטי" החיפוש השונים נוצרים על ידי קריאות C וכיצד הם
נהרסים כאשר אינם נחוצים עוד.

התקנה מה היא סוויש-ה ספריה

ספריית Swish-e מותקנת בעת הפעלת "make install" בעת בניית Swish-e. לא
נדרשים שלבי התקנה נוספים.

הספרייה מורכבת מקובץ כותרת "swish-eh" וספרייה "libswish-e.*" שיכולה
תהיה ספרייה סטטית או משותפת, בהתאם לפלטפורמה שלך.

סִפְרִיָה סקירה כללית

כאשר אתה מצרף לראשונה לקובץ אינדקס (או קבצי אינדקס), מוחזר לך "handle" (ידית סוויש).
מהידית אתה יוצר "אובייקט חיפוש" אחד או יותר אשר מחזיק את הפרמטרים ל
שאילתת האינדקס, כגון מחרוזת שאילתה, סדר מיון, מפריד ביטויי חיפוש, הגבלה
פרמטרים וסיביות מבנה HTML. ה"אובייקט" הוא למעשה רק מצביע לקובץ C
מבנה, אבל כדאי לחשוב עליו כאובייקט שנתונים ופונקציונליות
הקשורים אליו.

אובייקט החיפוש משמש לשאילתה על האינדקס. שאילתה מחזירה "אובייקט תוצאות". ה-
אובייקט results מכיל את מספר ההתאמות, את השאילתה שנותחה לכל אינדקס ואת קבוצת התוצאות.
אובייקט התוצאות עוקב אחר המיקום הנוכחי בקבוצת התוצאות. ניתן "לחפש"
לרשומה ספציפית בתוך קבוצת התוצאות (שימושי להצגת דף תוצאות).

לבסוף, אובייקט תוצאה מייצג תוצאה אחת מרשימת התוצאות.
מספק גישה למאפייני התוצאה (כגון שם קובץ, דירוג וכו').

בנוסף לתוצאות, קיימות פונקציות זמינות לגישה לערכי הכותרת המאוחסנים
בקובץ האינדקס, פונקציות לבדיקה ודיווח על שגיאות, וכמה פונקציות כלי עזר.

זמין פונקציות

להלן רשימת הפונקציות הזמינות הכלולות בממשק ה-API של שפת C של Swish-e.

פונקציות אלו (והגדרות סוג) מוגדרות ב- סוויש-אה קובץ כותרת. הקובץ המשותף
חפצים (למשל מבנים) בהם נעשה שימוש הם:

SW_HANDLE - ידית סוויש (swish handle) המשויכת לקובץ אינדקס
SW_SEARCH - חיפוש "אובייקט" המכיל פרמטרי חיפוש
SW_RESULTS - אובייקט תוצאות המכיל קבוצת תוצאות
SW_RESULT - תוצאה יחידה המשמשת לגישה למאפייני התוצאה
SW_FUZZYWORD - משמש להמרת מילים מעורפלות (נגזרות)

חיפוש

SW_HANDLE SwishInit(char *IndexFiles);
פונקציה זו פותחת וקוראת את פרטי הכותרת של קבצי האינדקס הכלולים ב
מחרוזת IndexFiles. המחרוזת צריכה להכיל רשימה של קבצי אינדקס מופרדים ברווחים.

SW_HANDLE ידית שלי;
myhandle = SwishInit("file1.idx");

בדרך כלל תפתחו ידית (handle) בתחילת התוכנית ותשתמשו בה כדי ליצור
שאילתות מרובות על אינדקס.

פונקציה זו תמיד תחזיר handle מסוג swish. עליך לבדוק אם יש שגיאות, ובהמשך
שחרר שגיאות מהזיכרון בו משתמש ה-handle, או בטל.

הנה דוגמה להפסקת ניתוח:

SW_HANDLE ידית_סוויש;
swish_handle = SwishInit("file1.idx file2.idx");
אם (SwishError(swish_handle))
SwishAbortLastError( swish_handle );

והנה דוגמה לאיתור השגיאה:

SW_HANDLE ידית_סוויש;
swish_handle = SwishInit("file1.idx file2.idx");
אם (SwishError(swish_handle))
{
printf("ההתחברות ל-swish נכשלה. %s\n", SwishErrorString(swish_handle));
SwishClose( swish_handle ); /* פנה את הזיכרון שנעשה בו שימוש */
0 לחזור;
}

ייתכן שיהיה לך יותר מ-handle אחד פעיל בו זמנית.

Swish-e לא יודיע לך אם קובץ האינדקס משתנה בדיסק (כגון לאחר
אינדקס מחדש). בסביבה מתמשכת (למשל mod_perl) התוכנית הקוראת צריכה
בדוק אם קובץ האינדקס השתנה בדיסק. דרך נפוצה לעשות זאת היא
אחסן את מספר ה-inode לפני פתיחת קובץ/קבצי האינדקס, ולאחר מכן ציין את שם הקובץ
מדי פעם ולפתוח מחדש את קבצי האינדקס אם מספר ה-inode משתנה.

void SwishClose(ידית SW_HANDLE);
פונקציה זו סוגרת ומפנה את הזיכרון של handle סוויש. כל handle סוויש
יש לשחרר את הקובץ לאחר סיום החיפוש באינדקס. אי סגירת ה-handle תגרום...
לגרום לדליפת זיכרון.

SW_SEARCH אובייקט_חיפוש_חדש(ידית SW_HANDLE, const char *שאילתה);
מחזירה "אובייקט" חדש לחיפוש. אובייקט החיפוש מכיל את הפרמטרים ששימשו עבור
חיפוש באינדקס. ניתן להשתמש באובייקט חיפוש יחיד כדי לבצע שאילתה על האינדקס במספר מקומות.
פעמים. ההגדרות הזמינות המפורטות להלן הן "דביקות" בכך שהן נשארות במצב פעיל
אובייקט החיפוש עד לשינוי.

int SwishGetStructure(SW_SEARCH חיפוש);
מחזירה את דגל ה"מבנה" של אובייקט החיפוש שהועבר או 0 אם אובייקט החיפוש הוא
ריק.

void SwishPhraseDelimiter( SW_SEARCH חיפוש, תו מפריד);
קובע את תו המפריד של הביטוי. ברירת המחדל היא מירכאות כפולות.

char SwishGetPhraseDelimiter(SW_SEARCH חיפוש);
מחזירה את תו המפריד של הביטוי בו נעשה שימוש באובייקט החיפוש או 0 אם החיפוש
האובייקט הוא NULL.

void SwishSetStructure( SW_SEARCH חיפוש, int מבנה );
מגדיר את דגל ה"מבנה" באובייקט החיפוש. דגל המבנה משמש להגבלת
מחפש חלקים מקבצי HTML (כגון כותרת או כותרות). ברירת המחדל היא
אין הגבלה. זה מספק את הפונקציונליות של בורר שורת הפקודה -H.

void SwishPhraseDelimiter( SW_SEARCH חיפוש, תו מפריד);
קובע את תו המפריד של הביטוי. ברירת המחדל היא מירכאות כפולות.

void SwishSetSort( SW_SEARCH חיפוש, char *sort );
קובע את סדר המיון של התוצאות. זהה לבורר -s המשמש עם
קובץ בינארי swish-e.

void SwishSetQuery( SW_SEARCH חיפוש, char *שאילתה);
מגדיר את מחרוזת השאילתה באובייקט החיפוש. זה בדרך כלל לא נחוץ מכיוון שזה יכול
יוגדר בעת יצירת אובייקט החיפוש או בעת ביצוע שאילתה.

void SwishSetSearchLimit( SW_SEARCH srch, char *שם מאפיין, char *נמוך, char *הגבוה);
קובע את פרמטרי המגבלה לחיפוש. מספק את אותה פונקציונליות כמו -L
מתג שורת פקודה. ניתן לציין טווח של ערכי מאפיינים שיחפשו בתוצאות
חייב להיות בפנים. אתה יכול להתקשר SwishSetSearchLimit() פעם אחת בלבד לכל נכס
(אך ניתן לקבוע מגבלות על יותר מנכס אחד בו זמנית).

שלא כמו הגדרות אחרות באובייקט החיפוש, לאחר הפעלת שאילתה בחיפוש
אובייקט שאתה חייב לקרוא לו איפוס חיפוש () כדי לשנות או לנקות את פרמטרי המגבלה.

חלל SwishResetSearchLimit( SW_SEARCH srch );
מאפס את המגבלות שהוגדרו על אובייקט חיפוש שנקבע על ידי SwishSetSearchLimit().

void Free_Search_Object( חיפוש SW_SEARCH );
משחרר את אובייקט החיפוש. יש לקרוא לזה לאחר סיום החיפוש.
באופן כללי, ניתן לעשות שימוש חוזר באובייקט חיפוש עבור שאילתות מרובות, כך שבדרך כלל היית
תתקשרו לזה רגע לפני שתתקשרו סוויש סגור ().

באפשרותך לשחרר את אובייקט החיפוש לפני שחרור ואובייקטי תוצאות שנוצרו.

SW_RESULTS SwishExecute( SW_SEARCH חיפוש, const char *שאילתה);
מחפש את האינדקס או האינדקסים בהתבסס על הפרמטרים באובייקט החיפוש. מחזירה א
אובייקט תוצאות. ראה להלן פונקציות לגישה לנתונים המאוחסנים בתוצאות
אובייקט.

עליך תמיד לבדוק שגיאות לאחר שיחה SwishExecute().

SW_RESULTS SwishQuery(SW_HANDLE, const char *מילים);
זוהי פונקציה קיצור דרך שעוקפת את יצירת אובייקט חיפוש (למעשה,
עוקף את הצורך ליצור ולשחרר אובייקט חיפוש). זה מאפשר רק העברת
מחרוזת שאילתה; לא ניתן להגדיר פרמטרים אחרים לחיפוש. התוצאות ממוינות לפי דירוג.

עליך תמיד לבדוק שגיאות לאחר שיחה SwishQuery().

קריאה תוצאות שימוש

int SwishHits(תוצאות SW_RESULTS);
מחזירה את מספר התוצאות באובייקט results.

SWISH_HEADER_VALUE SwishParsedWords( SW_RESULTS, const char *index_name );
מחזירה את השאילתה שעברה אסימון. מילים מפוצלות לפי WordCharters ומילות עצירה מפוצלות לפי
הוסרו. המילים המעובדות שימושיות להדגשת מונחי חיפוש בתוכנית שלך.

"שם_האינדקס" הוא שם האינדקס שסופק ב- SwishInit() קריאה לפונקציה.

מחזירה איחוד SWISH_HEADER_VALUE מסוג SWISH_LIST שהוא תו **. ראה
src/libtest.c לדוגמה לגישה למחרוזות ברשימה זו, אבל באופן כללי אתה
עשוי להעביר את זה ל-(char **).

SWISH_HEADER_VALUE מילות עצירה שהוסרו מהסוויש (SW_RESULTS, const char *index_name);
מחזירה רשימה של מילות עצירה שהוסרו משאילתת הקלט.

מחזירה איחוד SWISH_HEADER_VALUE מסוג SWISH_LIST שהוא תו **. ראה
src/libtest.c לדוגמה לגישה למחרוזות ברשימה זו, אבל באופן כללי אתה
עשוי להעביר את זה ל-(char **).

int SwishSeekResult(SW_RESULTS, int position);
קובע את מיקום החיפוש הנוכחי ברשימת התוצאות, כאשר מיקום אפס הוא ה
רשומה ראשונה (בניגוד ל- -b כאשר one היא התוצאה הראשונה).

מחזירה את המיקום או מספר שלילי במקרה של שגיאה.

SW_RESULT סוויש הבאתוצאה( SW_RESULTS );
מחזירה את התוצאה הבאה, או NULL אם לא קיימות תוצאות נוספות.

אין צורך לשחרר את אובייקט התוצאה המוחזר לאחר השימוש (בניגוד ל-swish).
זיהוי, אובייקט חיפוש ואובייקט תוצאות).

const char *SwishResultPropertyStr(SW_RESULT, char *שם נכס);
פונקציה זו שימושית בעיקר לבדיקות מכיוון שהיא מחזירה תוצאות מוזרות על שגיאות.

בוטל אם נקרא עם אובייקט NULL SW_RESULT

מחזירה ערך מחרוזת של המאפיין שצוין.

מחזירה את המחרוזת הריקה "" אם לתוצאה הנוכחית אין את המאפיין שצוין
שהוקצה.

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

אין צורך לשחרר את המחרוזת המוחזרת, אלא היא תקפה רק עבור הפעולה הנוכחית.
תוצאה. אם ברצונך לשמור את המחרוזת עליך להעתיק אותה באופן מקומי.

תאריכים מעוצבים באמצעות מחרוזת הפורמט המקודדת בקידוד קשיח: "%Y-%m-%d %H:%M:%S" ב
זמן מקומי.

SwishResultPropertyULong (SW_RESULT r, char * שם המאפיין);
מחזירה מאפיין מספרי כקובץ ארוך ללא סימן. מאפיינים מספריים משמשים לשניהם.
מאפיינים מסוג PropertyNamesNumeric ו-PropertyNamesDate. תאריכים מוחזרים כ-
חותמת זמן של יוניקס כפי שדווחה על ידי המערכת בעת יצירת האינדקס.

Swish-e יבטל אם ייקרא עם אובייקט NULL SW_RESULT. ללא ה-SW_RESULT
לאובייקט swish-e אין אפשרות להגדיר קודי שגיאה.

במקרה של שגיאה, הפונקציה מחזירה UMAX_LONG. הגדרה זו מוגדרת בדרך כלל ב- limits.h. בדיקה שגיאת סוויש ()
(ראה להלן) עבור סוג השגיאה.

If שגיאת סוויש () מחזירה false (אפס) אז זה פשוט אומר שהתוצאה הזו לא
יש נתונים כלשהם עבור הנכס שצוין.

If שגיאת סוויש () מחזירה אמת (לא אפס) אז או ששם המאפיין שצוין הוא
לא חוקי, או שהמאפיין המבוקש אינו מאפיין מספרי (או תאריך) (לדוגמה, זהו מאפיין
מאפיין מחרוזת).

ראה להלן כיצד לאחזר את הודעת השגיאה הספציפית כאשר שגיאת סוויש () נכון.

PropValue *getResultPropValue (SW_RESULT r, char *שם מאפיין, int ID);
זוהי פונקציה ברמה נמוכה שמטרתה להביא מאפיין ללא קשר לסוגו. סביר להניח שזה
הפונקציה הטובה ביותר לגישה לנכסים.

Swish-e יבטל אם ייקרא עם אובייקט NULL SW_RESULT. שם התכונה הוא השם.
של הנכס. מספר הזיהוי הוא מספר הזיהוי של הנכס, אם ידוע. בדרך כלל לא
משמש ב-API, אך מטרתו היא להימנע מחיפוש מזהה הנכס עבור כל
תוצאה מוצגת.

ערך PropValue המוחזר הוא מבנה המכיל דגל המציין את הסוג, ו-
איגוד שמחזיק בערך הנכס. הדגלים והמבנה שלהם מוגדרים ב
סוויש-אה

יש להעתיק את המאפיין באופן מקומי ויש לשחרר את הערך המוחזר "PropValue".
על ידי שיחה ערךResultPropValue() כדי למנוע דליפת זיכרון.

במקרה של שגיאה מחזירה NULL. בדיקה שגיאת סוויש () (ראה להלן) עבור סוג השגיאה.

אם מחזירה NULL אבל שגיאת סוויש () מחזירה false (אפס) אז זה פשוט אומר שזו
לתוצאה אין נתונים עבור המאפיין שצוין.

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

ראה להלן כיצד לאחזר את הודעת השגיאה הספציפית כאשר שגיאת סוויש () נכון.

ראה perl/API.xs לדוגמה לשימוש בפונקציה זו.

ערך תוצאה חופשית (void)
משחרר את ה-"PropValue" שהוחזר לאחר הקריאה getResultPropValue().

void Free_Results_Object( תוצאות SW_RESULTS );
משחרר את אובייקט התוצאות (משחרר את קבוצת התוצאות). יש לקרוא לזה לאחר סיום
קריאת התוצאות ולפני השיחה סוויש סגור ().

גישה מה היא מדד כותרת ערכים

לכל קובץ אינדקס יש ערכי כותרת משויכים המתארים את האינדקס. פונקציות אלו
לספק גישה לנתונים אלה. נתוני הכותרת מוחזרים כאיחוד SWISH_HEADER_VALUE,
ומצביע ל- SWISH_HEADER_TYPE מועבר פנימה והערך המוחזר מציין את
סוג הנתונים המוחזרים. ראה src/libtest.c ו- perl/API.xs לדוגמאות.

const char **שמות כותרת סוויש( SW_HANDLE );
מחזירה את רשימת שמות הכותרות האפשריים. רשימה זו זהה עבור כל קבצי האינדקס
של גרסה נתונה של Swish-e. זה מספק דרך לקבל גישה לכל הכותרות
בלי צורך לרשום אותם בתוכנית שלך.

const char **SwishIndexNames( SW_HANDLE );
מחזירה רשימה של קבצי אינדקס שנפתחו. זוהי רק רשימת קבצי האינדקס שצוינו
ב SwishInit() שיחה. אתה צריך את שם קובץ האינדקס כדי לגשת לקובץ ספציפי
ערכי הכותרת של האינדקס.

SWISH_HEADER_VALUE ערך_הכותרת_סוויש( SW_HANDLE, const char *שם_אינדקס, const char
*כותרת_נוכחית, SWISH_HEADER_TYPE *סוג);
מביא את ערך הכותרת עבור קובץ האינדקס הנתון ואת שם הכותרת. ערכות הקריאה
ה-"type" שהועבר לסוג הערך המוחזר.

ראו src/libtest.c ו- perl/API.xs לדוגמאות.

SWISH_HEADER_VALUE ערך אינדקס תוצאה של סוויש (SW_RESULT, const char *name, SWISH_HEADER_TYPE)
*סוג);
זה כמו ערך כותרת סוויש () לעיל, אך במקום לספק שם קובץ אינדקס ו
ידית סוויש, ספק אובייקט תוצאה וערך הכותרת נלקח מה-
קובץ האינדקס הקשור לתוצאה.

גישה נכס meta נתונים

בנוסף למאפייני הסטנדרט המוגדרים מראש, יש לך אפשרות להוסיף
מאפייני "מטא" נוספים שיוסיפו לאינדקס ו/או יתווספו לרשימת המאפיינים המוחזרים
עם כל תוצאה. עיין בסעיפים על הנחיות MetaNames ו-PropertyNames ב
עיין בקובץ התצורה לקבלת הסבר כיצד לעשות זאת.

פונקציות אלו מספקות גישה למטא-נתונים המאוחסנים באינדקס. ניתן להשתמש בהן כדי
לקבוע איזה מידע מטא/מאפיינים זמין עבור אינדקס, כולל כל המידע המקדים
מאפיינים סטנדרטיים מוגדרים. ראה libtest.c לדוגמה.

SWISH_META_LIST SwishMetaList( SW_HANDLE, const char *שם_אינדקס );
מחזירה את רשימת ערכי המטא עבור קובץ האינדקס הנתון כמערך בעל סיום ריק
של אובייקטי SW_META. השתמש בפונקציות שלהלן כדי לחלץ שדות ספציפיים מה-
מבנה SW_META. מטא נבדלים ממאפיינים.

SWISH_META_LIST רשימת מאפיינים של Swish( SW_HANDLE, const char *שם_אינדקס );
פונקציה זו זהה ל- SwishMetaList() אבל זה מחזיר מערך של מאפיינים כ-
בניגוד לאובייקטי מטא. ניתן לחלץ תכונות באותו אופן כמו אובייקטי מטא.
אובייקטים באמצעות הפונקציות שלהלן.

SWISH_META_LIST רשימת מטא-תוצאות של סוויש( SW_RESULT );
זה כמו SwishMetaList() למעלה אך קובע את האינדקס שיש להשתמש בו מהתוצאה
אובייקט.

SWISH_META_LIST רשימת מאפייני תוצאות סוויש (SW_RESULT);
זה כמו רשימת מאפיינים של Swish() למעלה אבל כמו רשימת מטא-תוצאות של SwishResult() משתמש בתוצאה
אובייקט במקום שם אינדקס.

const char *שם_המטה_Swish( SW_META );
בהינתן אובייקט SW_META המוחזר על ידי אחת מהפעולות הנ"ל, פונקציה זו תחזיר את
שם המטא/נכס. ניתן להשתמש בשם זה כדי לגשת לערך של נכס עבור נתון
כמתואר לעיל.

int SwishMetaType( SW_META );
קבל את סוג הנתונים עבור המטא/מאפיין הנתון. סוגים ידועים מופיעים ב-swish-eh

SwishMetaID( SW_META );
קבל את מספר הזיהוי הפנימי עבור המטא/נכס הנתון. מזהים אלה ייחודיים לכל
קובץ אינדקס אך אינם ייחודיים לכל תוצאה.

בדיקה ל שגיאות

עליך לבדוק שגיאות לאחר כל הקריאות. השגיאה האחרונה נשמרת ב-swish handle
אובייקט, והוא תקף רק עד הפעולה הבאה (אשר מאפסת את דגלי השגיאה).

נכון לעכשיו, חלק מהשגיאות מסומנות כשגיאות "קריטיות". במקרים אלה עליך
להרוס (על ידי קריאה ל- סוויש סגור () פונקציה) ידית הסוויש הנוכחית. אם יש לך
אובייקטים אחרים בהיקף (למשל אובייקט חיפוש או אובייקט תוצאות) משמידים אותם תחילה.

ניתן לראות את סוגי השגיאות הקריטיות ב-src/error.c. נכון לעכשיו, הרשימה
כולל:

לא ניתן היה לפתוח את קובץ האינדקס
פורמט קובץ אינדקס לא ידוע
קובץ/קבצי האינדקס ריקים
שגיאת קובץ אינדקס
ידית סוויש לא חוקית
אובייקט תוצאות לא חוקי

int שגיאת שוויש(SW_HANDLE);
מחזירה אמת אם קיים תנאי שגיאה. מחזירה את מספר השגיאה, שהוא
מספר שלם קטן מאפס במקרה של שגיאה. יש לבדוק זאת לפני קריאה לאחת מהאפשרויות.
פונקציות שגיאה אחרות להלן.

const char *SwishErrorString( SW_HANDLE );
פעולה זו מחזירה תיאור טקסטואלי כללי של השגיאה הנוכחית.

const char *SwishLastErrorMsg(SW_HANDLE);
במקרים מסוימים, פעולה זו תחזיר מחרוזת עם פרטים ספציפיים על השגיאה הנוכחית.
דוגמא, SwishErrorString() עשוי להחזיר "מטא-שם לא ידוע", אבל הודעת שגיאת סוויש ()
יחזיר מחרוזת עם שם המטא-שם הלא ידוע.

int שגיאת SwishCriticalError(SW_HANDLE);
מחזירה אמת אם מצב השגיאה הנוכחי הוא שגיאה קריטית.
עליך לפנות את כל האובייקטים הנוכחיים ולקרוא סוויש סגור () כמו שסוויש עשוי להיות ב
מצב לא יציב.

void SwishAbortLastError(SW_HANDLE);
זוהי פונקציית נוחות שתעצב ותדפיס את הודעת השגיאה האחרונה, ו
לאחר מכן לבטל את התוכנית.

חלל set_error_handle(קובץ *כאשר);
קובע היכן מודפסות שגיאות ואזהרות (כאשר מודפסים באמצעות סוויש). עבור היסטוריות
סיבות, כאשר swish-e מופעל לראשונה נשלחות שגיאות ואזהרות ל-stdout.

חלל SwishErrorsToStderr( חלל );
שיטה נוחה לשליחת שגיאות ל-stderr במקום ל-stdout.

שירות פונקציות

const char *SwishWordsByLetter(SWISH * sw, char *indexname, char c);
מחזירה את כל המילים באינדקס "indexname" שמתחילות באות שהועברה.
מחזירה NULL אם שם קובץ האינדקס אינו חוקי.

פונקציה זו עשויה להשתנות בעתיד מכיוון שכרגע ניתן להשתמש רק בתווים של 8 סיביות.

char * SwsishStemWord( SW_HANDLE sw, char *in_word );
לא מומלץ לשימוש

ניתן להשתמש בזה כדי להמיר מילה לשורש שלה. זה משתמש רק בפורטר המקורי
סטמר.

SW_FUZZYWORD SwishFuzzyWord( SW_RESULT r, char *word );
גבעולים "מילה" בהתבסס על מצב מטושטש שנבחר במהלך האינדוקס.

מצב ה"מטושטש" בו נעשה שימוש במהלך האינדוקס נשמר בקובץ האינדקס. מכיוון שכל תוצאה היא
מקושר לקובץ אינדקס נתון, שיטה זו מאפשרת הגדרת שורשי מילה על סמך האינדקס שלה.
קובץ.

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

ניתן להשתמש בשיטות הבאות כדי לגשת לנתונים המוחזרים. אובייקט SW_FUZZYWORD
יש לשחרר אותו לאחר סיום הפעולה כדי למנוע דליפת זיכרון.

const char **SwishFuzzyWordList( SW_FUZZYWORD fw );
מחזירה רשימה ריק של מחרוזות שהוחזרו על ידי ה-stemmer. ברוב המקרים זה
יהיה מחרוזת אחת.

הנה דוגמה:

SW_FYZZYWORD fuzzy_word = SwishFuzzyWord(תוצאה);
const char **רשימת_מילים = רשימת_מילים_fuzzy של Swish(מילה_fuzzy);
בעוד ש ( *רשימת_מילים)
{
printf("%s\n", *רשימת_מילים);
רשימת_מילים++;
}
SwishFuzzyWordFree(fuzzy_word);

אם ה-stemmer לא ממיר את המחרוזת (לדוגמה, ניסיון מספרי של stem)
נתונים) רשימת המילה תכיל את המילה המקורית. כדי לדעת אם המילה הגורמת לגיבוי אכן
נגזרה המילה בדוק את הערך המוחזר עם שגיאת מילהSwishFuzzy().

int שגיאת מילהFuzzyWord( SW_FUZZYWORD fw );
פונקציה זו מחזירה אפס אם פעולת ה-stemming הייתה מוצלחת, אחרת היא מחזירה
ערך המציין את הסיבה לכך שהמילה לא נגזרה. ערכי ההחזרה מוגדרים
בקובץ swish-e src/stemmer.h.

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

int SwishFuzzyWordCount( SW_FUZZYWORD fw );
מחזירה את ספירת המחרוזות ברשימת המילים הזמינות על ידי קריאה
רשימת מילים סוויש פאזי ().

בדרך כלל זה רק אחד, אבל במקרה של DoubleMetaphone זה יכול להיות אחד או שניים.
(כלומר, DoubleMetaphone יכול להחזיר מחרוזת אחת או שתיים).

const char *SwishFuzzyMode( SW_RESULT r );
מחזירה את שם ה-stemmer בו נעשה שימוש עבור התוצאה הנתונה (אשר קשור ל-
מַדָד).

חלל SwishFuzzyWordFree( SW_FUZZYWORD fw );
מפנה את הזיכרון המשמש את SW_FUZZYWORD.

דוחות באגים

אנא דווחו על באגים לקבוצת הדיון של Swish-e. אתם מוזמנים גם לשפר או
לשפר תכונה זו.

מְחַבֵּר

ממשק מקורי: אוגוסט 2000 חוסה רואיז jmruiz@boe.es

עודכן: 22 באוגוסט, 2002 - ביל מוסלי

ממשק שעוצב מחדש עבור Swish-e גרסה 2.3 17 באוקטובר, 2002 - ביל מוסלי

מסמך מידע

מזהה $: SWISH-LIBRARY.pod 1906 2007-02-07 19:25:16Z moseley $

.

השתמשו ב-SWISH-LIBRARY באופן מקוון באמצעות שירותי onworks.net