osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/helpers/sqlite/domains/Sqlite__Cache__Requests__Patch.py

@@ -0,0 +1,63 @@
+import types
+
+from osbot_utils.helpers.sqlite.domains.Sqlite__Cache__Requests import Sqlite__Cache__Requests
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.utils.Misc import random_text
+
+
+class Sqlite__Cache__Requests__Patch(Sqlite__Cache__Requests):
+    db_name             : str                = random_text('requests_cache_')
+    table_name          : str                = random_text('requests_table_')
+    pickle_response     : bool               = True
+    target_function     : types.FunctionType
+    target_class        : object
+    target_function_name: str
+
+    def __init__(self, db_path=None):
+        super().__init__(db_path=db_path, db_name=self.db_name, table_name=self.table_name)
+
+    def __enter__(self):
+        self.patch_apply()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.patch_restore()
+        return
+
+    def delete(self):
+        return self.sqlite_requests.delete()
+
+    def proxy_method(self, *args, **kwargs):
+        request_data  = self.request_data (*args, **kwargs)
+        target_kwargs = self.target_kwargs(*args, **kwargs)
+        target_args   = self.target_args  (*args, **kwargs)
+
+        invoke_kwargs = dict(target       = self.target_function,
+                             target_args   = target_args        ,
+                             target_kwargs = target_kwargs      ,
+                             request_data  = request_data       )
+
+        return self.invoke_with_cache(**invoke_kwargs)
+
+    def patch_apply(self):
+        if (type(self.target_class)   is object or
+            self.target_function      is None   or
+            self.target_function_name  == ''     ):
+                raise ValueError('target_function, target_object and target_function_name must be set')
+        def proxy(*args, **kwargs):
+            return self.proxy_method(*args, **kwargs)
+        setattr(self.target_class, self.target_function_name, proxy)
+        return self
+
+    def patch_restore(self):
+        setattr(self.target_class, self.target_function_name, self.target_function)
+
+    def request_data(self, *args, **kwargs):
+        return {'args'  : args   ,
+                'kwargs': kwargs }
+
+    def target_args(self, *args, **kwargs):
+        return args
+
+    def target_kwargs(self, *args, **kwargs):
+        return kwargs

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Files.py

@@ -0,0 +1,23 @@
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local import Sqlite__DB__Local
+from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Files import Sqlite__Table__Files
+
+
+class Sqlite__DB__Files(Sqlite__DB__Local):
+
+    def __init__(self, db_path=None, db_name=None):
+        super().__init__(db_path=db_path, db_name=db_name)
+
+    def add_file(self, path, contents=None, metadata=None):
+        return self.table_files().add_file(path, contents, metadata)
+
+    @cache_on_self
+    def table_files(self):
+        return Sqlite__Table__Files(database=self).setup()
+
+    def files(self):
+        return self.table_files().files()
+
+    def setup(self):
+        self.table_files()
+        return self

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Graph.py

@@ -0,0 +1,47 @@
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local import Sqlite__DB__Local
+from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Edges import Sqlite__Table__Edges
+from osbot_utils.helpers.sqlite.tables.Sqlite__Table__Nodes import Sqlite__Table__Nodes
+
+
+class Sqlite__DB__Graph(Sqlite__DB__Local):
+
+    def __init__(self, db_path=None, db_name=None):
+        super().__init__(db_path=db_path, db_name=db_name)
+
+    def add_edge(self, source_key, target_key, value=None, properties=None):
+        new_edge = self.table_edges().add_edge(source_key, target_key, value, properties)
+        self.add_node(source_key)                                   # assuming node_table.allow_duplicate_keys is set to False
+        self.add_node(target_key)                                   # make sure there is a node for each part of the edge added
+        return new_edge
+
+
+    def add_node(self, key, value=None, properties=None):
+        return self.table_nodes().add_node(key, value, properties)
+
+    def clear(self):
+        self.table_edges().clear()
+        self.table_nodes().clear()
+
+    def edges(self):
+        return self.table_edges().edges()
+
+    def nodes(self):
+        return self.table_nodes().nodes()
+
+    def nodes_keys(self):
+        return self.table_nodes().keys()
+
+    @cache_on_self
+    def table_edges(self):
+        return Sqlite__Table__Edges(database=self).setup()
+
+    @cache_on_self
+    def table_nodes(self):
+        return Sqlite__Table__Nodes(database=self).setup()
+
+    def setup(self):
+        #self.table_config()                    # wire this up when I have a use case for it
+        self.table_nodes()
+        self.table_edges()
+        return self

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Json.py

@@ -0,0 +1,83 @@
+from osbot_utils.base_classes.Kwargs_To_Self                import Kwargs_To_Self
+from osbot_utils.helpers.sqlite.Sqlite__Database            import Sqlite__Database
+from osbot_utils.helpers.sqlite.Sqlite__Table__Create       import Sqlite__Table__Create
+from osbot_utils.helpers.sqlite.models.Sqlite__Field__Type  import Sqlite__Field__Type
+
+
+class Sqlite__DB__Json(Kwargs_To_Self):
+    database     : Sqlite__Database
+    table_create : Sqlite__Table__Create
+    table_name   : str                    = 'new_db_table'
+
+    def __init__(self):
+        super().__init__()
+        self.table_create = Sqlite__Table__Create(self.table_name)
+        self.table_create.table.database = self.database
+
+    def create_fields_from_json_data(self, json_data):
+        for key,value in json_data.items():
+            self.table_create.add_field_with_type(key, type(value))
+
+    def create_table_from_schema(self, table_name, schema):
+        table_create               = Sqlite__Table__Create(table_name)
+        table_create.table.database = self.database
+        for field_name,field_type in schema.items():
+            table_create.add_field_with_type(field_name, field_type)
+
+        if table_create.create_table():
+            return table_create.table
+
+    def create_table_from_json_data(self, json_data):
+        self.create_fields_from_json_data(json_data)
+        if self.table_create.create_table():
+            self.table_create.table.row_add_record(json_data)
+            return self.table_create.table
+
+    #def add_data_to_data_from_json_data(self, json_data):
+
+    def get_schema_from_json_data(self, json_data):
+        if type(json_data) is dict:
+            return self.get_schema_from_dict(json_data)
+        if type(json_data) is list:
+            return self.get_schema_from_list_of_dict(json_data)
+
+    def get_schema_from_list_of_dict(self, target):
+        if not isinstance(target, list):
+            raise ValueError("in get_schema_from_list_of_dict, the provided target is not a list")
+
+        overall_schema = {}
+
+        for item in target:
+            if not isinstance(item, dict):
+                continue  # or raise an exception, depending on your needs
+
+            current_schema = self.get_schema_from_dict(item)
+
+            for key, current_type in current_schema.items():
+                if (key                 in overall_schema              and                                   # Check if key exists in the overall schema
+                    overall_schema[key] != current_type                and                                   # Check if there's a type mismatch for the key
+                    current_type        != Sqlite__Field__Type.UNKNOWN and                                   # Ensure current type is not UNKNOWN
+                    overall_schema[key] != Sqlite__Field__Type.UNKNOWN    ):                                 # Ensure overall schema's type for the key is not UNKNOWN
+                        message = f"Type conflict for field '{key}': {overall_schema[key]} vs {current_type}"
+                        raise ValueError(message)
+                else:
+                    overall_schema[key] = current_type                                                        # Update or add the key with its type to the overall schema
+
+
+        return overall_schema
+
+    def get_schema_from_dict(self, target):
+        schema = {}
+        type_map  = Sqlite__Field__Type.type_map()
+        for key, value in target.items():
+            value_type = type(value)
+            field_type = type_map.get(value_type)
+            if field_type is None:
+                raise ValueError(f"in get_schema_from_dict, the value_type {value_type} from '{key} = {value}' is not supported by Sqlite__Field__Type")
+            schema[key] = field_type
+        return schema
+
+
+
+
+

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Local.py

@@ -0,0 +1,20 @@
+from os                                             import environ
+from osbot_utils.helpers.sqlite.Sqlite__Database    import Sqlite__Database
+from osbot_utils.utils.Files                        import current_temp_folder, path_combine
+from osbot_utils.utils.Misc                         import random_text
+from osbot_utils.utils.Str                          import str_safe
+
+ENV_NAME_PATH_LOCAL_DBS = 'PATH_LOCAL_DBS'
+
+class Sqlite__DB__Local(Sqlite__Database):
+    db_name: str
+
+    def __init__(self, db_path=None, db_name=None):
+        self.db_name = db_name or random_text('db_local') + '.sqlite'
+        super().__init__(db_path=db_path or self.path_local_db())
+
+    def path_db_folder(self):
+        return environ.get(ENV_NAME_PATH_LOCAL_DBS) or current_temp_folder()
+
+    def path_local_db(self):
+        return path_combine(self.path_db_folder(), str_safe(self.db_name))

osbot_utils/helpers/sqlite/domains/Sqlite__DB__Requests.py

@@ -0,0 +1,39 @@
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Local               import Sqlite__DB__Local
+from osbot_utils.helpers.sqlite.domains.schemas.Schema__Table__Requests import Schema__Table__Requests
+from osbot_utils.utils.Misc import random_text
+
+SQLITE_TABLE__REQUESTS = 'requests'
+
+class Sqlite__DB__Requests(Sqlite__DB__Local):
+    table_name  : str
+    table_schema: type
+
+    def __init__(self,db_path=None, db_name=None, table_name=None):
+        self.table_name   = table_name or SQLITE_TABLE__REQUESTS
+        self.table_schema = Schema__Table__Requests
+        super().__init__(db_path=db_path, db_name=db_name)
+        # if not self.table_name:
+        #     self.table_name = 'temp_table'
+        self.setup()
+
+    @cache_on_self
+    def table_requests(self):
+        return self.table(self.table_name)
+
+    def table_requests__create(self):
+        with self.table_requests() as _:
+            _.row_schema = self.table_schema                    # set the table_class
+            if _.exists() is False:
+                _.create()                                          # create if it doesn't exist
+                _.index_create('request_hash')                      # add index to the request_hash field
+                return True
+        return False
+
+    def table_requests__reset(self):
+        self.table_requests().delete()
+        return self.table_requests__create()
+
+    def setup(self):
+        self.table_requests__create()
+        return self

osbot_utils/helpers/sqlite/domains/schemas/Schema__Table__Requests.py

@@ -0,0 +1,12 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+class Schema__Table__Requests(Kwargs_To_Self):
+    request_hash  : str
+    request_data  : str
+    response_hash : str
+    response_data : str
+    response_bytes: bytes
+    cache_hits    : int                         # todo: to implement
+    timestamp     : int
+    latest        : bool                        # todo: add native bool support to sqlite
+    comments      : str

osbot_utils/helpers/sqlite/models/Sqlite__Field__Type.py

@@ -0,0 +1,37 @@
+from decimal import Decimal
+from enum import Enum, auto
+from types import NoneType
+
+from osbot_utils.decorators.methods.cache import cache
+
+
+class Sqlite__Field__Type(Enum):
+    BOOLEAN = bool
+    DECIMAL = Decimal
+    INTEGER = int
+    TEXT    = str
+    BLOB    = bytes
+    REAL    = float
+    NUMERIC = 'numeric'                         # special case to have some support for using NUMERIC in the Create Table
+    UNKNOWN = NoneType                          # special type to handle cases when the type is not known # todo: handle this on the table creation stage
+
+    def __repr__(self):
+        return f'Sqlite__Field__Type.{self.name}'
+
+    def __str__(self):
+        return self.name
+
+    @classmethod
+    @cache
+    def type_map(cls):
+        type_map = {}
+        for member in cls:
+            if member.value not in [auto()]:
+                type_map[member.value] = member
+        return type_map
+
+    @classmethod
+    @cache
+    def enum_map(cls):
+        return {member.name: member.value for member in cls}
+

osbot_utils/helpers/sqlite/sample_data/Sqlite__Sample_Data__Chinook.py

@@ -0,0 +1,116 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.helpers.sqlite.Sqlite__Database import Sqlite__Database
+from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table
+from osbot_utils.helpers.sqlite.Sqlite__Table__Create import Sqlite__Table__Create
+from osbot_utils.helpers.sqlite.domains.Sqlite__DB__Json import Sqlite__DB__Json
+from osbot_utils.testing.Duration import duration, Duration
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.utils.Files import current_temp_folder, path_combine, folder_create, file_exists, file_not_exists, \
+    file_contents
+from osbot_utils.utils.Http import GET, GET_to_file
+from osbot_utils.utils.Json import json_loads, json_from_file, json_dump, json_file_create, json_file_load
+from osbot_utils.utils.Objects import obj_info
+
+URL__CHINOOK_JSON                = 'https://github.com/lerocha/chinook-database/releases/download/v1.4.5/ChinookData.json'
+FILE_NAME__CHINOOK_DATA_JSON     = 'ChinookData.json'
+FILE_NAME__TABLES_SCHEMAS_FIELDS = 'chinook__tables_schemas_fields.json'
+FOLDER_NAME__CHINOOK_DATA        = 'chinook_data'
+FOLDER_NAME__SQLITE_DATA_SETS    = '_sqlite_data_sets'
+PATH__DB__TESTS                  = '/tmp/db-tests'
+PATH__DB__CHINOOK                = '/tmp/db-tests/test-chinook.db'
+TABLE_NAME__CHINOOK              = 'chinook_data'
+
+class Sqlite__Sample_Data__Chinook(Kwargs_To_Self):
+    url_chinook_database_json : str                 = URL__CHINOOK_JSON
+    path_local_db             : str                 = PATH__DB__CHINOOK
+    table_name                : str                 = TABLE_NAME__CHINOOK
+    json_db                   : Sqlite__DB__Json
+
+
+
+    def chinook_data_as_json(self):
+        path_chinook_data_as_json = self.path_chinook_data_as_json()
+        if file_not_exists(path_chinook_data_as_json):
+            GET_to_file(self.url_chinook_database_json, path_chinook_data_as_json)
+        return json_from_file(path_chinook_data_as_json)
+
+    # def create_table_from_data(self):
+    #     chinook_data = self.chinook_data_as_json()
+    #     table_creator = Sqlite__Table__Create(table_name=self.table_name)
+    #     table         = table_creator.table
+    #     table_creator.add_fields__text("name", "value").create_table()
+    #
+    #     cursor = table.cursor()
+    #     assert len(chinook_data) == 11
+    #     for key, items in chinook_data.items():
+    #         name = key
+    #         value = json_dump(items)
+    #         table.row_add(dict(name=name, value=value))
+    #
+    #     cursor.commit()
+    #     return table
+
+    def create_tables(self):
+        self.create_tables_from_schema()
+        chinook_data = self.chinook_data_as_json()
+        for table_name, rows in chinook_data.items():
+            table = self.json_db.database.table(table_name)
+            table.rows_add(rows)
+
+
+
+    def create_tables_from_schema(self):
+        schemas  = self.tables_schemas_fields_from_data()
+        for table_name, table_schema in schemas.items():
+            self.json_db.create_table_from_schema(table_name, table_schema)
+        return self
+
+    def database(self):                         # todo: need to refactor this code based from the creation of the database to the use of it
+        return self.json_db.database
+
+    @cache_on_self
+    def load_db_from_disk(self):
+        db_chinook = Sqlite__Database(db_path=PATH__DB__CHINOOK, auto_schema_row=True)          # set the auto_schema_row so that we have a row_schema defined for all tables
+        return db_chinook
+        # db_chinook.connect()
+        # return db_chinook.table(self.table_name)
+
+    def path_chinook_data_as_json(self):
+        return path_combine(self.path_chinook_data(), FILE_NAME__CHINOOK_DATA_JSON)
+
+    def path_chinook_data(self):
+        path_chinook_data = path_combine(self.path_sqlite_sample_data_sets(), FOLDER_NAME__CHINOOK_DATA)
+        return folder_create(path_chinook_data)
+
+    def path_sqlite_sample_data_sets(self):                     # todo: refactor to sqlite_sample_data_sets helper class
+        path_data_sets = path_combine(current_temp_folder(), FOLDER_NAME__SQLITE_DATA_SETS)
+        return folder_create(path_data_sets)
+
+    def path_tables_schemas_fields(self):
+        return path_combine(self.path_chinook_data(), FILE_NAME__TABLES_SCHEMAS_FIELDS)
+
+    def table__genre(self):
+        return self.load_db_from_disk().table('Genre')          # todo: refactor to sqlite_sample_data_sets helper class
+
+    def table__track(self):
+        return self.load_db_from_disk().table('Track')          # todo: refactor to sqlite_sample_data_sets helper class
+
+    # def tables(self):
+    #     return self.load_db_from_disk().tables()
+
+    def tables_schemas_fields_from_data(self):
+        path_tables_schemas_fields = self.path_tables_schemas_fields()
+        if file_not_exists(path_tables_schemas_fields):
+            tables_schemas = {}
+            for name, data  in self.chinook_data_as_json().items():
+                table_schema = self.json_db.get_schema_from_json_data(data)
+                tables_schemas[name] = table_schema
+            json_file_create(tables_schemas, path=path_tables_schemas_fields)
+
+        return json_file_load(path_tables_schemas_fields)
+
+    def save(self, path=PATH__DB__CHINOOK):
+        database = self.database()
+        database.save_to(path)
+        return True

osbot_utils/helpers/sqlite/sql_builder/SQL_Builder.py

@@ -0,0 +1,159 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.sqlite.Sqlite__Globals import ROW_BASE_CLASS
+from osbot_utils.helpers.sqlite.Sqlite__Table import Sqlite__Table
+
+
+class SQL_Builder(Kwargs_To_Self):
+    table      : Sqlite__Table
+    limit      : int            = None                  # set it to None to make it explict that the limit is not set
+
+    def validate_query_data(self):
+        if self.table.row_schema is None:
+            raise ValueError("in SQL_Builder, there was no row_schema defined in the mapped table")
+
+    def select_for_fields(self,  field_names: list = None):
+        valid_fields = self.table.fields_names__cached()
+        if field_names is None:
+            field_names = valid_fields
+        elif isinstance(field_names, list) is False:
+            raise ValueError(f"in sql_query_for_fields, field_names must be a list, it was :{field_names}")
+
+        invalid_field_names = [name for name in field_names if name not in valid_fields]    # If no valid field names are provided, raise an error or return a default query
+        if invalid_field_names:                                                             # If there are any invalid field names, raise an exception listing them
+            message = f"Invalid field names provided: {', '.join(invalid_field_names)}"
+            raise ValueError(message)
+
+        fields_str = ', '.join(field_names)                         # Construct the SQL query string
+        sql_query = f"SELECT {fields_str} FROM {self.table.table_name}{self.sql_limit()};"  # Join the valid field names with commas
+        return sql_query
+
+    def command__delete_table(self):
+        return f'DELETE FROM {self.table.table_name}'
+
+    def command__delete_where(self, query_conditions):
+        self.validator().validate_query_fields(self.table, [],query_conditions)      # todo: add method to validate_query_fields to handle just the query section (so that we don't need to provide a empty list for the return values)
+        target_table = self.table.table_name
+        where_fields = list(query_conditions.keys())
+        params       = list(query_conditions.values())
+        where_clause = ' AND '.join([f"{field}=?" for field in where_fields])                   # todo: refactor into method that just handle the WHERE statements
+        sql_query    = f"DELETE FROM {target_table} WHERE {where_clause}"                       # todo: refactor into a method that creates the final statement from a number of other objects (or strings)
+        return sql_query, params
+
+    def command_for_insert(self, record):
+        valid_field_names = self.table.fields_names__cached()
+        if type(record) is dict:
+            if record:
+                field_names   = record.keys()
+                params        =  list(record.values())
+                for field_name in field_names:
+                    if field_name not in valid_field_names:
+                        raise ValueError(f'in sql_command_for_insert, there was a field_name "{field_name}" that did exist in the current table')
+
+                columns       = ', '.join(field_names)                                                         # Construct column names and placeholders
+                placeholders  = ', '.join(['?' for _ in field_names])
+                sql_command   = f'INSERT INTO {self.table.table_name} ({columns}) VALUES ({placeholders})'    # Construct the SQL statement
+                return sql_command, params
+
+    def query_for_fields(self, field_names: list = None):
+        return self.select_for_fields(field_names)
+
+    def query_for_size(self):
+        return f'SELECT COUNT(*) as size FROM {self.table.table_name}'
+
+    def sql_limit(self):
+        if self.limit is not None:
+            return f" LIMIT {int(self.limit)}"
+        return ""
+
+    def query_select_fields_with_conditions(self, return_fields, query_conditions):
+        self.validator().validate_query_fields(self.table , return_fields, query_conditions)
+        target_table = self.table.table_name
+        if target_table and return_fields and query_conditions:
+            where_fields     = list(query_conditions.keys())
+            params           = list(query_conditions.values())
+            fields_to_return = ', '.join(return_fields)                                               # Join the select_fields list into a comma-separated string
+            where_clause     = ' AND '.join([f"{field}=?" for field in where_fields])                 # Dynamically construct the WHERE clause based on condition_fields
+            sql_query        = f"SELECT {fields_to_return} FROM {target_table} WHERE {where_clause}"  # Construct the full SQL query
+            return sql_query, params
+
+    def query_for_select_rows_where(self, **kwargs):
+        valid_fields  = self.table.fields__cached()                                                               # Get a list of valid field names from the cached schema
+        params        = []                                                                                  # Initialize an empty list to hold query parameters
+        where_clauses = []                                                                                  # Initialize an empty list to hold parts of the WHERE clause
+        for field_name, query_value in kwargs.items():                                                      # Iterate over each keyword argument and its value
+            if field_name not in valid_fields:                                                              # Check if the provided field name is valid
+                raise ValueError(f'in select_rows_where, the provided field is not valid: {field_name}')
+            params.append(query_value)                                                                      # Append the query value to the parameters list
+            where_clauses.append(f"{field_name} = ?")                                                       # Append the corresponding WHERE clause part, using a placeholder for the value
+        where_clause = ' AND '.join(where_clauses)                                                          # Join the individual parts of the WHERE clause with 'AND'
+
+        sql_query = f"SELECT * FROM {self.table.table_name} WHERE {where_clause}" # Construct the full SQL query
+        return sql_query, params
+
+    def sql_query_update_with_conditions(self, update_fields, query_conditions):
+        update_keys     = list(update_fields.keys())            # todo: refactor self.validate_query_fields to use a more generic value for these fields
+        condition_keys  = list(query_conditions.keys())
+        self.validator().validate_query_fields(self.table, update_keys, query_conditions)
+        target_table = self.table.table_name
+        if target_table and update_fields and query_conditions:
+            update_clause   = ', '.join([f"{key}=?" for key in update_keys])
+            where_clause    = ' AND '.join([f"{field}=?" for field in condition_keys])
+            sql_query       = f"UPDATE {target_table} SET {update_clause} WHERE {where_clause}"
+
+            # The parameters for the SQL execution must include both the update values and the condition values, in the correct order.
+            params = list(update_fields.values()) + list(query_conditions.values())
+            return sql_query, params
+
+    def validate_row_obj(self, row_obj):
+        field_types = self.table.fields_types__cached()
+        invalid_reason = ""
+        if self.table.row_schema:
+            if row_obj:
+                if issubclass(type(row_obj), ROW_BASE_CLASS):
+                    for field_name, field_type in row_obj.__annotations__.items():
+                        if field_name not in field_types:
+                            invalid_reason = f'provided row_obj has a field that is not part of the current table: {field_name}'
+                            break
+
+                        if field_type != field_types[field_name]:
+                            invalid_reason = f'provided row_obj has a field {field_name} that has a field type {field_type} that does not match the current tables type of that field: {field_types[field_name]}'
+                            break
+                    if invalid_reason  == '':
+                        for field_name, field_value in row_obj.__locals__().items():
+                            if field_name not in field_types:
+                                invalid_reason = f'provided row_obj has a field that is not part of the current table: {field_name}'
+                                break
+                            if type(field_value) != field_types.get(field_name):
+                                invalid_reason = f'provided row_obj has a field {field_name} that has a field value {field_value} value that has a type {type(field_value)} that does not match the current tables type of that field: {field_types.get(field_name)}'
+                                break
+                else:
+                    invalid_reason = f'provided row_obj ({type(row_obj)}) is not a subclass of {ROW_BASE_CLASS}'
+            else:
+                invalid_reason = f'provided row_obj was None'
+        else:
+            invalid_reason = f'there is no row_schema defined for this table {self.table.table_name}'
+        return invalid_reason
+
+    def validator(self):
+        return SQL_Query__Validator()
+
+class SQL_Query__Validator:
+
+    # todo: refactor this method to use a more generic value for these return_fields since it is already being used in two use cases: return fields and update fields
+    def validate_query_fields(self, table, return_fields, query_conditions):
+        target_table = table.table_name
+        valid_fields = table.fields_names__cached(include_star_field=True)
+        if target_table not in table.database.tables_names(include_sqlite_master=True):
+            raise ValueError(f'in validate_query_fields, invalid target_table name: "{target_table}"')
+        if type(return_fields) is not list:
+            raise ValueError(f'in validate_query_fields, return_fields value must be a list, and it was "{type(return_fields)}"')
+        for return_field in return_fields:
+            if return_field not in valid_fields:
+                raise ValueError(f'in validate_query_fields, invalid, invalid return_field: "{return_field}"')
+        if type(query_conditions) is not dict:
+            raise ValueError(f'in validate_query_fields, query_conditions value must be a dict, and it was "{type(query_conditions)}"')
+        for where_field in query_conditions.keys():
+            if where_field not in valid_fields:
+                raise ValueError(f'in validate_query_fields, invalid, invalid return_field: "{where_field}"')
+
+        return self

osbot_utils/helpers/sqlite/sql_builder/SQL_Builder__Select.py

@@ -0,0 +1,12 @@
+from osbot_utils.helpers.sqlite.sql_builder.SQL_Builder import SQL_Builder
+
+
+class SQL_Builder__Select(SQL_Builder):     # todo: to refactor SELECT methods into this class
+    pass
+    # def build(self):
+    #     self.validate_query_data()
+    #
+    #     return f"SELECT * FROM *"
+
+    # def validate_query_data(self):
+    #     super().validate_query_data()