sqlthon 0.0.6__tar.gz → 0.0.7__tar.gz

{sqlthon-0.0.6 → sqlthon-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlthon
-Version: 0.0.6
+Version: 0.0.7
 Summary: A simple package for SQLite3 operations
 Author-email: SAUMS <mohamnown@gmail.com>
 License: MIT

{sqlthon-0.0.6 → sqlthon-0.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlthon"
-version = '0.0.6'
+version = '0.0.7'
 description = "A simple package for SQLite3 operations"
 readme = "README.md"
 requires-python = ">=3.8"

{sqlthon-0.0.6 → sqlthon-0.0.7}/src/sqlthon/__init__.py

@@ -5,7 +5,7 @@ Sqlthon - A Simple Package For SQLite3 Operations.
 from .core import Connect, Field
 
 __all__ = ['Connect', 'Field']
-__version__ = '0.0.6'
+__version__ = '0.0.7'
 __author__ = "SAUMS"
 __email__ = "saums1391@gmail.com"
 __description__ = "Operate With SQLite3 Buy Simple"

{sqlthon-0.0.6 → sqlthon-0.0.7}/src/sqlthon/core.py

@@ -20,27 +20,40 @@ class _Expression:
         return _Expression(self, "AND", other)
     def __or__(self, other):
         return _Expression(self, "OR", other)
-       
-       
+
+
+class _Aggregate:
+    def __init__(self, func, column="*"):
+        self.func = func
+        self.column = column
+    
+    def __gt__(self, value): return _Expression(self, ">", value)
+    def __lt__(self, value): return _Expression(self, "<", value)
+    def __ge__(self, value): return _Expression(self, ">=", value)
+    def __le__(self, value): return _Expression(self, "<=", value)
+    def __eq__(self, value): return _Expression(self, "=", value)
+    def __ne__(self, value): return _Expression(self, "!=", value)
+    
+    def __str__(self):
+        return f"{self.func}({self.column})"
+
+
 def _compile(expr):
     if isinstance(expr.left, _Expression) or isinstance(expr.right, _Expression):
-        left_sql, left_params = compile(expr.left)
-        right_sql, right_params = compile(expr.right)
+        left_sql, left_params = _compile(expr.left)
+        right_sql, right_params = _compile(expr.right)
         sql = f"{left_sql} {expr.op} {right_sql}"
         params = left_params + right_params
         return sql, params
-    
+    elif isinstance(expr.left, _Aggregate):
+        sql = f"{expr.left} {expr.op} ?"
+        params = (expr.right,)
+        return sql, params
     else:
-        field_name = expr.left.name
-        sql = f'"{field_name}" {expr.op} ?'
+        sql = f'"{expr.left.name}" {expr.op} ?'
         params = (expr.right,)
         return sql, params
-
-
-
-
-
-
+        
 
 class Connect:
     __slots__ = ("_con", "_cur", "_changes")
@@ -48,7 +61,7 @@ class Connect:
         from sqlite3 import connect as _cn
         self._con = _cn(database_path)
         self._cur = self._con.cursor()
-        self._changes = []
+        self._changes: list = []
         del _cn
     
     # ____________| TABLE |____________
@@ -103,6 +116,39 @@ class Connect:
         return [i[1] for i in self.run_code(f"PRAGMA table_info({table_name})")]
     
     # ____________| RECORD |____________
+    def find_record(self, table_name: str, columns: None | tuple=None, compound: None | tuple=None, condition: None | _Expression=None, bundle: None | tuple=None, filter_bundle: None | tuple=None, sort: None | tuple=None, several: None | int=None, jump: int=0, unique: bool=False):
+        query = "SELECT "
+        param = ()
+        if unique:
+            query += "DISTINCT "
+        query += f"{', '.join(columns) if columns else '*'} FROM {table_name}"
+        if compound:
+            query += f" {compound[0]} JOIN \"{compound[1]}\" ON {compound[2]} = {compound[3]}"
+        if condition:
+            _: tuple = _compile(condition)
+            query += f" WHERE {_[0]}"
+            param += _[1]
+            del _
+        if bundle:
+            query += f" GROUP BY {", ".join(bundle)}"
+        if filter_bundle:
+            _: tuple = _compile(filter_bundle)
+            query += f" HAVING {_[0]}"
+            param += _[1]
+            del _
+            
+        if sort:
+            query += " ORDER BY "
+            if sort[-1].upper() == "ASC" or sort[-1].upper() == "DESC":
+               query += f"{", ".join(sort[:-1])} {sort[-1]}"
+            else:
+                query += ", ".join(sort)
+        if several is not None:
+            query += f" LIMIT {several}"
+            if jump:
+                query += f" OFFSET {jump}"
+        self._changes.append((query, param))
+        
     def add_record(self, table_name: str, record_info: tuple) -> None:
         self._changes.append((f"INSERT INTO {table_name} VALUES({', '.join(['?']*len(record_info))})", record_info))
         
@@ -134,7 +180,22 @@ class Connect:
     def count_record(self, table_name: str) -> int:
         return self.run_code(f"SELECT COUNT(*) FROM {table_name}")[0][0]
     
+    # ____________| INDEX |_________
+    def add_index(self, table_name: str, column_name: str, unique: bool=False) -> None:
+        self._changes.append((f"CREATE INDEX{" UNIQUE" if unique else ""} {table_name}_{column_name} ON {table_name} ({column_name})",))
+    
+    def delete_index(self, table_name: str, column_name: str) -> None:
+        self._changes.append((f"DROP INDEX {table_name}_{column_name}",))
+    
+    # ____________| VIEW |_________
+    def add_view(self, view_name: str, query: str) -> None:
+        self._changes.append((f"CREATE VIEW {view_name} AS {query}",))
+    
+    def delete_view(self, view_name: str) -> None:
+        self._changes.append((f"DROP VIEW {view_name}",))
     
+    def exist_view(self, view_name: str) -> bool:
+        return view_name in [i[0] for i in self.run_code("SELECT name FROM sqlite_master WHERE type='view'")]
     # ____________| OTHER |_________
 
     def run_code(self, code: str, parameters: tuple=()) -> list | None:
@@ -143,7 +204,7 @@ class Connect:
         try:
             return self._cur.fetchall()
         except:
-            pass
+            return None
     
     def close(self):
         self._con.close()

{sqlthon-0.0.6 → sqlthon-0.0.7}/src/sqlthon/keywords.py

@@ -11,6 +11,8 @@ NOT_NULL = "NOT NULL"
 PRIMARY_KEY = "PRIMARY KEY"
 AUTO_INCREMENT = "AUTOINCREMENT"
 
+LEFT = "LEFT"
+INNER = "INNER"
 
 
 def DEFAULT(value):
@@ -35,16 +37,16 @@ def DEFAULT_NOW():
 
 
 def COUNT(query="*"):
-    return f"COUNT({query})"
+    return _Aggregate("COUNT", query)
 
 def SUM(query):
-    return f"SUM({query})"
+    return _Aggregate("SUM", query)
 
 def AVG(query):
-    return f"AVG({query})"
+    return _Aggregate("AVG", query)
 
 def MIN(query):
-    return f"MIN({query})"
+    return _Aggregate("MIN", query)
 
 def MAX(query):
-    return f"MAX({query})"
+    return _Aggregate("MAX", query)

{sqlthon-0.0.6 → sqlthon-0.0.7}/src/sqlthon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlthon
-Version: 0.0.6
+Version: 0.0.7
 Summary: A simple package for SQLite3 operations
 Author-email: SAUMS <mohamnown@gmail.com>
 License: MIT