כתיבה מחדש של _get_schema_info - הכרה מעמיקה של כל השדות עם משמעות עסקית ודוגמאות אמיתיות

app/sql_service.py

@@ -116,119 +116,206 @@ class SQLFeedbackService:
     
     def _get_schema_info(self) -> str:
         """
-        Generate schema information string for the feedback table.
+        Generate comprehensive schema information for the feedback table.
         
-        This information is provided to the LLM when generating SQL queries
-        to help it understand the data structure and available columns.
+        This function analyzes the actual CSV file structure and provides
+        detailed information about each field including business meaning,
+        data types, examples, and usage patterns.
         
         Returns:
-            A formatted string describing the table schema, column types,
-            and basic statistics. Used in prompts for SQL query generation.
-        
-        Note:
-            The function includes all available columns in the schema info.
+            A detailed formatted string describing the table schema with
+            business context, examples, and statistics.
         """
         if self.df is None:
             return "No data available"
         
-        # Build compact schema info with all fields, examples, and usage
-        all_columns_info = ""
-        
-        # Get sample values for each column
-        def get_sample_values(col_name, n=3):
+        # Helper function to get sample values
+        def get_sample_values(col_name, n=5):
             try:
                 samples = self.df[col_name].dropna().head(n).tolist()
                 return [str(s) for s in samples]
             except:
                 return []
         
-        # ID
-        samples = get_sample_values('ID', 2)
-        all_columns_info += f"• ID (UUID): מזהה ייחודי. דוגמאות: {', '.join(samples[:2])}\n"
-        
-        # ServiceName
-        samples = get_sample_values('ServiceName', 3)
-        unique_services = self.df['ServiceName'].nunique() if 'ServiceName' in self.df.columns else 0
-        all_columns_info += f"• ServiceName (טקסט): שם השירות. דוגמאות: {', '.join(samples[:2])}. יש {unique_services} שירותים ייחודיים\n"
+        # Helper function to get unique values if not too many
+        def get_unique_values(col_name, max_show=10):
+            try:
+                unique_vals = self.df[col_name].dropna().unique().tolist()
+                if len(unique_vals) <= max_show:
+                    return unique_vals
+                return unique_vals[:max_show]
+            except:
+                return []
         
-        # Level
-        all_columns_info += "• Level (מספר 1-5): דירוג שביעות רצון. 1=גרוע מאוד, 5=מעולה. דוגמאות: 1, 2, 3, 4, 5\n"
+        all_columns_info = ""
         
-        # Text
-        samples = get_sample_values('Text', 1)
-        if samples:
-            sample_text = samples[0][:50] + "..." if len(samples[0]) > 50 else samples[0]
-            all_columns_info += f"• Text (טקסט ארוך): תוכן המשוב. דוגמה: '{sample_text}'\n"
-        else:
-            all_columns_info += "• Text (טקסט ארוך): תוכן המשוב - ביקורות, תלונות, מחמאות\n"
-        
-        # ReferenceNumber
-        if 'ReferenceNumber' in self.df.columns:
-            samples = get_sample_values('ReferenceNumber', 3)
-            all_columns_info += f"• ReferenceNumber (מספר, יכול להיות NULL): מספר הפניה. דוגמאות: {', '.join([str(s) for s in samples[:2]])}\n"
-        
-        # RequestID
-        if 'RequestID' in self.df.columns:
-            samples = get_sample_values('RequestID', 2)
-            all_columns_info += f"• RequestID (UUID, יכול להיות NULL): מזהה בקשה. דוגמאות: {samples[0][:20]}...\n"
-        
-        # ProcessID
-        if 'ProcessID' in self.df.columns:
-            all_columns_info += "• ProcessID (UUID, יכול להיות NULL): מזהה תהליך\n"
-        
-        # Date/Time fields - check what actually exists in the dataframe
-        date_time_cols = []
-        for col in ['Year', 'year', 'שנה', 'Month', 'month', 'חודש', 'DayOfWeek', 'day_of_week', 'יום_בשבוע', 
-                    'Hour', 'hour', 'שעה', 'DayNight', 'day_night', 'יום_לילה', 'DayOfMonth', 'day_of_month', 'יום_בחודש']:
-            if col in self.df.columns:
-                date_time_cols.append(col)
-        
-        if date_time_cols:
-            all_columns_info += "\nשדות תאריך/זמן מחושבים (מוכנים לשימוש - השתמש בהם לשאילתות זמן!):\n"
+        # Analyze each column that exists in the dataframe
+        for col in self.df.columns:
+            col_info = ""
+            
+            # Get column statistics
+            dtype = str(self.df[col].dtype)
+            non_null_count = self.df[col].notna().sum()
+            null_count = self.df[col].isna().sum()
+            samples = get_sample_values(col, 3)
+            
+            # ID field
+            if col == 'ID':
+                col_info = f"• {col} (UUID/טקסט): מזהה ייחודי גלובלי של כל משוב\n"
+                col_info += f"  - משמעות עסקית: מזהה ייחודי לכל משוב במערכת, מאפשר מעקב, קישור בין משובים, ומניעת כפילויות\n"
+                col_info += f"  - דוגמאות: {', '.join(samples[:2])}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE ID = '...', COUNT(DISTINCT ID), GROUP BY ID\n"
+            
+            # ServiceName field
+            elif col == 'ServiceName':
+                unique_services = self.df[col].nunique()
+                unique_samples = get_unique_values(col, 5)
+                col_info = f"• {col} (טקסט): שם השירות הדיגיטלי הממשלתי\n"
+                col_info += f"  - משמעות עסקית: מזהה את השירות שעליו ניתן המשוב. מאפשר ניתוח לפי שירות, השוואה בין שירותים, זיהוי שירותים בעייתיים או מצטיינים\n"
+                col_info += f"  - יש {unique_services} שירותים ייחודיים במערכת\n"
+                col_info += f"  - דוגמאות: {', '.join(unique_samples[:3])}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE ServiceName = '...', GROUP BY ServiceName, COUNT(*) GROUP BY ServiceName\n"
             
-            # Year
-            for year_col in ['Year', 'year', 'שנה']:
-                if year_col in self.df.columns:
-                    try:
-                        year_min = int(self.df[year_col].min())
-                        year_max = int(self.df[year_col].max())
-                        all_columns_info += f"• {year_col} (מספר): שנה. טווח: {year_min}-{year_max}. דוגמאות: {year_min}, {year_max}\n"
-                    except:
-                        all_columns_info += f"• {year_col} (מספר): שנה. דוגמאות: 2020, 2021\n"
-                    break
+            # Level field
+            elif col == 'Level':
+                level_dist = self.df[col].value_counts().sort_index().to_dict()
+                avg_level = self.df[col].mean()
+                col_info = f"• {col} (מספר שלם 1-5): דירוג שביעות רצון המשתמש מהשירות\n"
+                col_info += f"  - משמעות עסקית: מדד שביעות רצון. 1=גרוע מאוד, 2=גרוע, 3=בינוני, 4=טוב, 5=מעולה. מאפשר מדידת שביעות רצון, זיהוי בעיות, ומעקב אחר שיפורים\n"
+                col_info += f"  - דירוג ממוצע: {avg_level:.2f}\n"
+                col_info += f"  - חלוקה: {level_dist}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE Level >= 4 (משובים חיוביים), WHERE Level <= 2 (משובים שליליים), AVG(Level), GROUP BY Level\n"
             
-            # Month
-            for month_col in ['Month', 'month', 'חודש']:
-                if month_col in self.df.columns:
-                    all_columns_info += f"• {month_col} (מספר 1-12): חודש. 1=ינואר, 12=דצמבר. דוגמאות: 1, 6, 12\n"
-                    break
+            # Text field
+            elif col == 'Text':
+                sample_text = samples[0][:80] + "..." if samples and len(samples[0]) > 80 else (samples[0] if samples else "")
+                avg_length = self.df[col].str.len().mean() if self.df[col].dtype == 'object' else 0
+                col_info = f"• {col} (טקסט ארוך): התוכן החופשי של המשוב מהמשתמש\n"
+                col_info += f"  - משמעות עסקית: ביקורות, הצעות לשיפור, תלונות, מחמאות. מאפשר ניתוח איכותי, זיהוי נושאים חוזרים, וקבלת תובנות עסקיות\n"
+                col_info += f"  - אורך ממוצע: {avg_length:.0f} תווים\n"
+                col_info += f"  - דוגמה: '{sample_text}'\n"
+                col_info += f"  - שימוש בשאילתות: WHERE Text LIKE '%מילה%', WHERE Text LIKE '%בעיה%', LENGTH(Text), COUNT(*) WHERE Text IS NOT NULL\n"
             
-            # DayOfWeek
-            for dow_col in ['DayOfWeek', 'day_of_week', 'יום_בשבוע']:
-                if dow_col in self.df.columns:
-                    samples = get_sample_values(dow_col, 3)
-                    all_columns_info += f"• {dow_col} (טקסט): יום בשבוע. ערכים: Monday-Sunday. דוגמאות: {', '.join(samples[:3])}\n"
-                    break
+            # ReferenceNumber field
+            elif col == 'ReferenceNumber':
+                if non_null_count > 0:
+                    ref_min = int(self.df[col].min())
+                    ref_max = int(self.df[col].max())
+                    col_info = f"• {col} (מספר שלם): מספר הפניה פנימי של המשוב\n"
+                    col_info += f"  - משמעות עסקית: מספר הפניה במערכת. מאפשר קישור למסמכים או בקשות קשורות, מעקב אחר תהליכים, וניהול בקשות\n"
+                    col_info += f"  - טווח: {ref_min} - {ref_max}\n"
+                    col_info += f"  - דוגמאות: {', '.join([str(s) for s in samples[:2]])}\n"
+                    col_info += f"  - NULL: {null_count} רשומות ({null_count/len(self.df)*100:.1f}%)\n"
+                    col_info += f"  - שימוש בשאילתות: WHERE ReferenceNumber = 6928, WHERE ReferenceNumber IS NOT NULL\n"
             
-            # Hour
-            for hour_col in ['Hour', 'hour', 'שעה']:
-                if hour_col in self.df.columns:
-                    all_columns_info += f"• {hour_col} (מספר 0-23): שעה ביום. 0=חצות, 12=צהריים, 23=23:00. דוגמאות: 0, 9, 14, 18, 23\n"
-                    break
+            # RequestID field
+            elif col == 'RequestID':
+                if non_null_count > 0:
+                    col_info = f"• {col} (UUID/טקסט): מזהה ייחודי של הבקשה המקורית שקשורה למשוב\n"
+                    col_info += f"  - משמעות עסקית: מאפשר קישור בין בקשות למשובים, מעקב אחר תהליכים, וניתוח הקשר בין בקשה למשוב\n"
+                    col_info += f"  - דוגמאות: {samples[0][:30]}...\n"
+                    col_info += f"  - NULL: {null_count} רשומות ({null_count/len(self.df)*100:.1f}%)\n"
+                    col_info += f"  - שימוש בשאילתות: WHERE RequestID = '...', COUNT(DISTINCT RequestID)\n"
             
-            # DayNight
-            for dn_col in ['DayNight', 'day_night', 'יום_לילה']:
-                if dn_col in self.df.columns:
-                    samples = get_sample_values(dn_col, 2)
-                    all_columns_info += f"• {dn_col} (טקסט): 'יום' או 'לילה'. יום=6:00-18:00, לילה=18:00-6:00. דוגמאות: {', '.join(samples[:2])}\n"
-                    break
+            # ProcessID field
+            elif col == 'ProcessID':
+                col_info = f"• {col} (UUID/טקסט): מזהה ייחודי של התהליך העסקי שקשור למשוב\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח לפי תהליכים, זיהוי תהליכים בעייתיים, ומעקב אחר ביצועים\n"
+                col_info += f"  - NULL: {null_count} רשומות ({null_count/len(self.df)*100:.1f}%)\n"
+                col_info += f"  - שימוש בשאילתות: WHERE ProcessID = '...', COUNT(DISTINCT ProcessID)\n"
+            
+            # Year field
+            elif col == 'Year':
+                year_min = int(self.df[col].min())
+                year_max = int(self.df[col].max())
+                year_dist = self.df[col].value_counts().sort_index().to_dict()
+                col_info = f"• {col} (מספר שלם): שנה שבה ניתן המשוב\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח מגמות לאורך שנים, השוואה בין שנים, זיהוי שיפורים או הידרדרות, ותכנון אסטרטגי\n"
+                col_info += f"  - טווח: {year_min} - {year_max}\n"
+                col_info += f"  - חלוקה: {year_dist}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE Year = 2020, GROUP BY Year, SELECT Year, COUNT(*) GROUP BY Year\n"
+            
+            # Month field
+            elif col == 'Month':
+                month_min = int(self.df[col].min())
+                month_max = int(self.df[col].max())
+                month_names = {1: 'ינואר', 2: 'פברואר', 3: 'מרץ', 4: 'אפריל', 5: 'מאי', 6: 'יוני',
+                              7: 'יולי', 8: 'אוגוסט', 9: 'ספטמבר', 10: 'אוקטובר', 11: 'נובמבר', 12: 'דצמבר'}
+                col_info = f"• {col} (מספר שלם 1-12): חודש בשנה שבו ניתן המשוב\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח עונתי, זיהוי חודשים בעייתיים או מצטיינים, תכנון משאבים לפי עונות\n"
+                col_info += f"  - טווח: {month_min} - {month_max} ({month_names.get(month_min, '')} - {month_names.get(month_max, '')})\n"
+                col_info += f"  - דוגמאות: {', '.join([str(s) for s in samples[:3]])}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE Month = 1, GROUP BY Month, SELECT Month, COUNT(*) GROUP BY Month ORDER BY Month\n"
+            
+            # DayInMonth field
+            elif col == 'DayInMonth':
+                day_min = int(self.df[col].min())
+                day_max = int(self.df[col].max())
+                col_info = f"• {col} (מספר שלם 1-31): יום בחודש שבו ניתן המשוב\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח לפי ימים בחודש, זיהוי ימים בעייתיים (למשל סוף חודש), וניתוח דפוסים יומיים\n"
+                col_info += f"  - טווח: {day_min} - {day_max}\n"
+                col_info += f"  - דוגמאות: {', '.join([str(s) for s in samples[:3]])}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE DayInMonth = 1, GROUP BY DayInMonth, SELECT DayInMonth, COUNT(*) GROUP BY DayInMonth\n"
+            
+            # DayOfWeek field
+            elif col == 'DayOfWeek':
+                unique_days = get_unique_values(col, 10)
+                day_names_he = {'Monday': 'שני', 'Tuesday': 'שלישי', 'Wednesday': 'רביעי', 'Thursday': 'חמישי',
+                               'Friday': 'שישי', 'Saturday': 'שבת', 'Sunday': 'ראשון'}
+                col_info = f"• {col} (טקסט): יום בשבוע שבו ניתן המשוב (באנגלית)\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח לפי ימי השבוע, זיהוי ימים בעייתיים, תכנון כוח אדם, וזיהוי דפוסים שבועיים\n"
+                col_info += f"  - ערכים אפשריים: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday\n"
+                col_info += f"  - דוגמאות: {', '.join(unique_days[:3])}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE DayOfWeek = 'Monday', GROUP BY DayOfWeek, SELECT DayOfWeek, COUNT(*) GROUP BY DayOfWeek\n"
+            
+            # Hour field
+            elif col == 'Hour':
+                hour_min = int(self.df[col].min())
+                hour_max = int(self.df[col].max())
+                col_info = f"• {col} (מספר שלם 0-23): שעה ביום שבה ניתן המשוב\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח לפי שעות היום, זיהוי שעות שיא, תכנון זמינות שירות, וזיהוי דפוסים יומיים\n"
+                col_info += f"  - טווח: {hour_min} - {hour_max} (0=חצות, 12=צהריים, 23=23:00)\n"
+                col_info += f"  - דוגמאות: {', '.join([str(s) for s in samples[:3]])}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE Hour >= 9 AND Hour <= 17 (שעות עבודה), GROUP BY Hour, SELECT Hour, COUNT(*) GROUP BY Hour ORDER BY Hour\n"
+            
+            # DayOrNight field
+            elif col == 'DayOrNight':
+                unique_values = get_unique_values(col, 5)
+                col_info = f"• {col} (טקסט): האם המשוב ניתן בשעות היום או הלילה\n"
+                col_info += f"  - משמעות עסקית: מאפשר ניתוח לפי שעות פעילות, זיהוי הבדלים בין יום ללילה, תכנון זמינות שירות\n"
+                col_info += f"  - ערכים אפשריים: 'יום' או 'לילה' (יום=6:00-18:00, לילה=18:00-6:00)\n"
+                col_info += f"  - דוגמאות: {', '.join(unique_values)}\n"
+                col_info += f"  - שימוש בשאילתות: WHERE DayOrNight = 'יום', GROUP BY DayOrNight, SELECT DayOrNight, COUNT(*) GROUP BY DayOrNight\n"
+            
+            # Default for any other columns
+            else:
+                if dtype in ['int64', 'float64']:
+                    val_min = self.df[col].min()
+                    val_max = self.df[col].max()
+                    col_info = f"• {col} ({dtype}): מספר. טווח: {val_min} - {val_max}\n"
+                else:
+                    unique_count = self.df[col].nunique()
+                    col_info = f"• {col} ({dtype}): טקסט. {unique_count} ערכים ייחודיים\n"
+                col_info += f"  - דוגמאות: {', '.join(samples[:2])}\n"
+            
+            all_columns_info += col_info + "\n"
         
-        schema_info = f"""שם הטבלה: Feedback_transformed (עם אות גדולה F)
+        # Build final schema info
+        total_records = len(self.df)
+        unique_services = self.df['ServiceName'].nunique() if 'ServiceName' in self.df.columns else 0
+        avg_level = self.df['Level'].mean() if 'Level' in self.df.columns else 0
+        
+        schema_info = f"""שם הטבלה: Feedback_transformed (עם אות גדולה F - חובה!)
+
+סטטיסטיקות כלליות:
+- סך הכל משובים: {total_records}
+- מספר שירותים ייחודיים: {unique_services}
+- דירוג ממוצע: {avg_level:.2f}
 
 שדות בטבלה:
 {all_columns_info}
 
-סטטיסטיקות: {len(self.df)} משובים, {self.df['ServiceName'].nunique()} שירותים, דירוג ממוצע: {self.df['Level'].mean():.2f}
+⚠️ חשוב: כל שאילתה חייבת להתחיל ב-SELECT ולהשתמש ב-FROM Feedback_transformed!
 """
         return schema_info