save_in_memory

DB/NEW_KT_DB/DataAccess/DBManager.py

@@ -8,25 +8,22 @@ def __init__(self, db_file: str):
         '''Initialize the database connection and create tables if they do not exist.'''
         self.connection = sqlite3.connect(db_file)
 
-
     # rachel-8511, ShaniStrassProg
     def close(self):
-    '''Close the database connection.'''
-    self.connection.close()
-
+        '''Close the database connection.'''
+        self.connection.close()
 
     # saraNoigershel
     def execute_query_with_multiple_results(self, query: str) -> Optional[List[Tuple]]:
-    '''Execute a given query and return the results.'''
-    try:
-        c = self.connection.cursor()
-        c.execute(query)
-        results = c.fetchall()
-        # self.connection.commit() ???
-        return results if results else None
-    except OperationalError as e:
-        raise Exception(f'Error executing query {query}: {e}')
-
+        '''Execute a given query and return the results.'''
+        try:
+            c = self.connection.cursor()
+            c.execute(query)
+            results = c.fetchall()
+            # self.connection.commit() ???
+            return results if results else None
+        except OperationalError as e:
+            raise Exception(f'Error executing query {query}: {e}')
 
     # ShaniStrassProg 
     def execute_query_with_single_result(self, query: str) -> Optional[Tuple]:
@@ -40,7 +37,6 @@ def execute_query_with_single_result(self, query: str) -> Optional[Tuple]:
         except OperationalError as e:
             raise Exception(f'Error executing query {query}: {e}')
 
-
     # Riki7649255
     def execute_query_without_results(self, query: str):
         '''Execute a given query without waiting for any result.'''
@@ -50,49 +46,54 @@ def execute_query_without_results(self, query: str):
             self.connection.commit()
         except OperationalError as e:
             raise Exception(f'Error executing query {query}: {e}')
-
 
     # Yael, Riki7649255
     def create_table(self, table_name, table_structure):
         '''create a table in a given db by given table_structure'''
         create_statement = f'''CREATE TABLE IF NOT EXISTS {table_name} ({table_structure})'''
-        execute_query_without_results(create_statement)
-
+        self.execute_query_without_results(create_statement)
 
     # Riki7649255  based on rachel-8511, ShaniStrassProg 
     def insert_data_into_table(self, table_name, data):
         insert_statement = f'''INSERT INTO {table_name} VALUES {data}'''
-        execute_query_without_results(insert_statement)
+        self.execute_query_without_results(insert_statement)
 
+    # # Riki7649255 based on rachel-8511, Shani
+    # def update_records_in_table(self, table_name: str, updates: Dict[str, Any], criteria: str) -> None:
+    #     '''Update records in the specified table based on criteria.'''
+
+    #     # add documentation here
+    #     set_clause = ', '.join([f'{k} = ?' for k in updates.keys()])
+    #     values = list(updates.values())
+
+    #     update_statement = f'''
+    #         UPDATE {table_name}
+    #         SET {set_clause}
+    #         WHERE {criteria}
+    #     '''
+
+    #     self.execute_query_without_results(update_statement)
 
-    # Riki7649255 based on rachel-8511, Shani
     def update_records_in_table(self, table_name: str, updates: Dict[str, Any], criteria: str) -> None:
-    '''Update records in the specified table based on criteria.'''
-
-    # add documentation here
-    set_clause = ', '.join([f'{k} = ?' for k in updates.keys()])
-    values = list(updates.values())
-
-    update_statement = f'''
-        UPDATE {table_name}
-        SET {set_clause}
-        WHERE {criteria}
-    '''
-
-    execute_query_without_results(update_statement)
-
+        '''Update records in the specified table based on criteria.'''
+        set_clause = '(' + ', '.join([f'{k}' for k in updates.keys()]) + ') = (' + ', '.join([f'"{v}"' for v in updates.values()]) + ')'
+        update_statement = f'''
+            UPDATE {table_name}
+            SET {set_clause}
+            WHERE {criteria}
+        '''
+        self.execute_query_without_results(update_statement)
 
     # Riki7649255 based on rachel-8511
     def delete_data_from_table(self, table_name: str, criteria: str) -> None:
-    '''Delete a record from the specified table based on criteria.'''
-
-    delete_statement = f'''
-        DELETE FROM {table_name}
-        WHERE {criteria}
-    ''')
-
-    execute_query_without_results(delete_statement)
-
+        '''Delete a record from the specified table based on criteria.'''
+
+        delete_statement = f'''
+            DELETE FROM {table_name}
+            WHERE {criteria}
+        '''
+
+        self.execute_query_without_results(delete_statement)
 
     # rachel-8511, Riki7649255
     def select_and_return_records_from_table(self, table_name: str, columns: List[str] = ['*'], criteria: str = '') -> Dict[int, Dict[str, Any]]:
@@ -109,23 +110,21 @@ def select_and_return_records_from_table(self, table_name: str, columns: List[st
         if criteria:
             query += f' WHERE {criteria}'
         try:
-            results = execute_query_with_multiple_results(query)
+            results = self.execute_query_with_multiple_results(query)
             return {result[0]: dict(zip(columns, result[1:])) for result in results}
         except OperationalError as e:
             raise Exception(f'Error selecting from {table_name}: {e}')
-
 
     # rachel-8511, ShaniStrassProg, Riki7649255
     def describe_table(self, table_name: str) -> Dict[str, str]:
         '''Describe table structure.'''
         try:
             desc_statement = f'PRAGMA table_info({table_name})'
-            columns = execute_query_with_multiple_results(desc_statement)
+            columns = self.execute_query_with_multiple_results(desc_statement)
             return {col[1]: col[2] for col in columns}
         except OperationalError as e:
             raise Exception(f'Error describing table {table_name}: {e}')
-
-
+
     # ShaniStrassProg
     # should be in ObjectManager and send the query to one of the execute_query functions
     # def is_json_column_contains_key_and_value(self, table_name: str, key: str, value: str) -> bool:
@@ -144,7 +143,6 @@ def describe_table(self, table_name: str) -> Dict[str, str]:
     #         print(f'Error: {e}')
     #         return False
 
-
     # Yael, ShaniStrassProg
     # should be in ObjectManager and send the query to one of the execute_query functions
     # def is_identifier_exist(self, table_name: str, value: str) -> bool:
@@ -158,7 +156,6 @@ def describe_table(self, table_name: str) -> Dict[str, str]:
     #         return c.fetchone()[0] > 0
     #     except sqlite3.OperationalError as e:
     #         print(f'Error: {e}')
-
 
     # sara-lea
     # should be in ObjectManager and send the query to one of the execute_query functions

DB/NEW_KT_DB/DataAccess/ObjectManager.py

@@ -1,7 +1,10 @@
 from typing import Dict, Any
 import json
 import sqlite3
-from DBManager import DBManager
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from DataAccess.DBManager import DBManager
 
 class ObjectManager:
     def __init__(self, db_file: str):
@@ -12,7 +15,7 @@ def __init__(self, db_file: str):
     # for internal use only:
 
     # Riki7649255 based on rachel-8511
-    def create_management_table(self, table_name, table_structure='object_id INTEGER PRIMARY KEY AUTOINCREMENT,type_object TEXT NOT NULL,metadata TEXT NOT NULL')
+    def create_management_table(self, table_name, table_structure):
         self.db_manager.create_table(table_name, table_structure)
 
 
@@ -42,13 +45,13 @@ def delete_object_from_management_table(self, table_name, criteria) -> None:
         self.db_manager.delete_data_from_table(table_name, criteria)
 
 
-    # rachel-8511, ShaniStrassProg is it needed?
+    # # rachel-8511, ShaniStrassProg is it needed?
     # def get_all_objects(self) -> Dict[int, Dict[str, Any]]:
     #     '''Retrieve all objects from the database.'''
     #     return self.db_manager.select(self.table_name, ['object_id', 'type_object', 'metadata'])
 
 
-    # rachel-8511 is it needed?
+    # # rachel-8511 is it needed?
     # def describe_table(self) -> Dict[str, str]:
     #     '''Describe the schema of the table.'''
     #     return self.db_manager.describe(self.table_name)
@@ -58,9 +61,11 @@ def convert_object_name_to_management_table_name(object_name):
         return f'mng_{object_name}s'
 
 
-    def is_management_table_exist(table_name):
-        # check if table exists using single result query
-        return db_manager.execute_query_with_single_result(f'desc table {table_name}')
+
+    def is_management_table_exist(self, table_name):
+        query = f"SELECT name FROM sqlite_master WHERE type='table' AND name='{table_name}'"
+        result = self.db_manager.execute_query_with_single_result(query)
+        return result is not None
 
 
     # for outer use:

Storage/NEW_KT_Storage/DataAccess/MultipartUploadManager.py

@@ -0,0 +1,114 @@
+import sqlite3
+import uuid
+import os
+import sys
+import json
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) 
+from Models.MultipartUploadModel import MultipartUploadModel 
+"""
+Imports the ObjectManager class from the KT_Cloud.DB.NEW_KT_DB.DataAccess module.
+
+The ObjectManager class is responsible for managing the storage and retrieval of objects in the database.
+"""
+from DataAccess.ObjectManager import ObjectManager
+
+class MultipartUploadManager:
+    def __init__(self, db_file: str, storage_path: str = None):
+        self.storage_path = storage_path
+        self.object_manager = ObjectManager(db_file)
+        self.db_manager = self.object_manager.object_manager
+        self.create_table()
+
+    def create_table(self):
+        table_schema = 'upload_id TEXT PRIMARY KEY, bucket_name TEXT NOT NULL, object_name TEXT NOT NULL, parts TEXT NOT NULL'
+        self.db_manager.create_management_table('MultipartUploadModel', table_schema)
+
+
+
+    def create_multipart_upload(self, multipart_upload: MultipartUploadModel) -> str:
+        """יוצר תהליך העלאת חלקים ומחזיר UploadId ייחודי"""
+        if not isinstance(multipart_upload, MultipartUploadModel):
+            raise TypeError('Expected an instance of MultipartUploadModel')
+        self.object_manager.save_in_memory(multipart_upload)
+        return multipart_upload.upload_id
+
+    # def create_multipart_upload(self, multipart_upload: MultipartUploadModel) -> str:
+    #     """יוצר תהליך העלאת חלקים ומחזיר UploadId ייחודי"""
+    #     # multipart_upload.upload_id = str(uuid.uuid4())
+    #     multipart_dict = multipart_upload.to_dict()
+    #     multipart_dict['parts'] = json.dumps(multipart_dict['parts'])
+    #     self.db_manager.insert_object_to_management_table(self.table_name, multipart_dict)
+    #     return multipart_upload.upload_id
+    # def upload_part(self, bucket_name: str, object_key: str, upload_id: str, new_part: PartModel) -> str:
+    #     """מעלה חלק מסוים עבור bucket ואובייקט"""
+    #     part_file_path = os.path.join(self.storage_path, f'{bucket_name}/{object_key}_part_{new_part.part_number}')
+    #     self.object_manager.create_file(part_file_path, new_part.body)
+
+    #     # עדכון אובייקט ההעלאה עם החלק החדש
+    #     obj_parts = self.db_manager.get_object_from_management_table(upload_id)
+    #     multipart_upload = MultipartUploadModel(obj_parts['bucket_name'], obj_parts['object_key'])
+    #     multipart_upload.parts = obj_parts['parts']
+    #     multipart_upload.parts.append({
+    #         'PartNumber': new_part.part_number,
+    #         'FilePath': part_file_path
+    #     })
+
+    #     # עדכון במסד הנתונים
+    #     self.db_manager.update_object_in_management_table_by_criteria(self.table_name, multipart_upload, upload_id)
+
+    #     # Generate a fake ETag for the example
+    #     return f'etag_{new_part.part_number}'
+
+    # def complete_multipart_upload(self, bucket_name: str, object_key: str, upload_id: str):
+    #     """משלים את ההעלאה, מאחד את כל החלקים לקובץ אחד"""
+    #     obj_parts = self.db_manager.get_object_from_management_table(upload_id)
+    #     complete_file_path = os.path.join(self.storage_path, f'{bucket_name}/{object_key}_complete')
+
+    #     with open(complete_file_path, 'wb') as complete_file:
+    #         for part in sorted(obj_parts.parts, key=lambda x: x['PartNumber']):
+    #             part_file_path = part['FilePath']
+    #             with open(part_file_path, 'rb') as part_file:
+    #                 complete_file.write(part_file.read())
+
+    #     # setObject(bucket_name, key, complete_file_path)
+
+    #     # מחיקת חלקי הקבצים
+    #     for part in obj_parts.parts:
+    #         os.remove(part['FilePath'])
+    import sqlite3
+
+def select_all_from_table(db_file: str, table_name: str):
+    """Selects all data from a specified table in the database."""
+    try:
+        # יצירת חיבור למסד הנתונים
+        conn = sqlite3.connect(db_file)
+        cursor = conn.cursor()
+
+        # הרצת שאילתת SELECT
+        query = f"SELECT * FROM {table_name}"
+        cursor.execute(query)
+
+        # שליפת כל התוצאות
+        rows = cursor.fetchall()
+
+        # סגירת החיבור למסד הנתונים
+        cursor.close()
+        conn.close()
+
+        return rows
+    except sqlite3.Error as e:
+        print(f"An error occurred: {e}")
+        return None
+
+MultipartUploadModel_new = MultipartUploadModel("my_bucket", "my_object")
+print(MultipartUploadModel_new.__class__.__name__)
+
+MultipartUploadManager_new = MultipartUploadManager("my_db.db", "my_storage_path")
+MultipartUploadModel_new.upload_id = MultipartUploadManager_new.create_multipart_upload(MultipartUploadModel_new)
+db_file = "my_db.db"
+table_name = "MultipartUploadModel"
+# select_and_return_records_from_table# קריאה לפונקציה
+all_data = select_all_from_table(db_file, table_name)
+
+# הדפסת התוצאות
+print(all_data)