async def executemany(self, sentence: str, *args): error = None await self.valid_operation(sentence) try: self._cursor = await self._connection.cursor() result = await self._cursor.executemany(sentence, *args) if result: await self._connection.commit() except Exception as err: error = "Error on Query: {}".format(str(err)) raise ProviderError(error) finally: await self._cursor.close() return [result, error] async def fetch(self, sentence: str, parameters: Iterable[Any] = None) -> Iterable: """Helper to create a cursor and execute the given query, returns a Native Cursor""" if parameters is None: parameters = [] await self.valid_operation(sentence) self._cursor = await self._connection.cursor() await self._cursor.execute(sentence, parameters) return self._cursor # Registering this Provider registerProvider(odbc)
raise ProviderError(error) finally: return [self._result, error] async def execute(self, sentence): """Execute a transaction get a SQL sentence and execute returns: results of the execution """ error = None if not self._connection: self.connection() try: self._logger.debug("Execute Sentence {}".format(sentence)) result = await self._engine.execute(sentence) self._result = result except (DatabaseError, OperationalError) as err: error = "Execute Error: {}".format(str(err)) raise ProviderError(error) except Exception as err: error = "Exception Error on Execute: {}".format(str(err)) raise ProviderError(error) finally: return [self._result, error] """ Registering this Provider """ registerProvider(sa)
async def hexists(self, key, field, value): """ Determine if hash field exists on redis dict """ try: await self._connection.hexists(key, field) except (aredis.exceptions.RedisError) as err: raise ProviderError("Redis hash exists Error: {}".format(str(err))) except Exception as err: raise ProviderError("Redis hash exists Unknown Error: {}".format( str(err))) async def hdel(self, key, field, *fields): """ Delete one or more hash fields """ try: await self._connection.hdel(key, field, *fields) except (aredis.exceptions.RedisError) as err: raise ProviderError("Redis Hset Error: {}".format(str(err))) except Exception as err: raise ProviderError("Redis Hset Unknown Error: {}".format( str(err))) """ Registering this Provider """ registerProvider(asyncredis)
def insert(self, table, data, **kwargs): """ insert insert the result onto a table """ sql = "INSERT INTO {table} ({fields}) VALUES ({values})" sql = sql.format_map(SafeDict(table=table)) # set columns sql = sql.format_map(SafeDict(fields=",".join(data.keys()))) values = ",".join(str(v) for v in data.values()) sql = sql.format_map(SafeDict(values=values)) try: result = self._loop.run_until_complete(self._connection.execute(sql)) if not result: print(result) return False else: return result except Exception as err: # print(sql) print(err) return False """ Registering this Provider """ registerProvider(mysql)
async def multiget(self, *kwargs): try: ky = [bytes(key, "utf-8") for key in kwargs] print(ky) result = await self._connection.multi_get(*ky) print(result) return [k.decode("utf-8") for k in result] except (aiomcache.exceptions.ClientException) as err: raise ProviderError("Get Memcache Error: {}".format(str(err))) except Exception as err: raise ProviderError("Memcache Unknown Error: {}".format(str(err))) async def test_connection(self, optional=1): result = None error = None try: await self.set("test_123", optional) result = await self.get("test_123") except Exception as err: error = err finally: await self.delete("test_123") return [result, error] """ Registering this Provider """ registerProvider(memcache)
async def fetch(self, sentence="", size: int = 1, params: list = []): error = None self._result = None if not sentence: raise EmptyStatement("Error: Empty Sentence") if not self._connection: await self.connection() try: startTime = datetime.now() self._cursor = self._connection.cursor() self._cursor.execute(sentence, *params) self._result = self._cursor.fetchmany(size) if not self._result: raise NoDataFound("SQL Server: No Data was Found") return [None, "SQL Server: No Data was Found"] except RuntimeError as err: error = "Runtime Error: {}".format(str(err)) raise ProviderError(error) except Exception as err: error = "Error on Query: {}".format(str(err)) raise Exception(error) finally: self._generated = datetime.now() - startTime return [self._result, error] """ Registering this Provider """ registerProvider(sqlserver)
except (redis.exceptions.RedisError, redis.exceptions.ResponseError) as err: raise ProviderError("Redis hash exists Error: {}".format(str(err))) except Exception as err: raise ProviderError("Redis hash exists Unknown Error: {}".format( str(err))) def hdel(self, key, field, *fields): """ Delete one or more hash fields """ try: if fields: return self._connection.hdel(key, *fields) else: return self._connection.hdel(key, field) except (redis.exceptions.ReadOnlyError) as err: raise ProviderError("Redis is Read Only: {}".format(str(err))) except (redis.exceptions.RedisError, redis.exceptions.ResponseError) as err: raise ProviderError("Redis Hset Error: {}".format(str(err))) except Exception as err: raise ProviderError("Redis Hset Unknown Error: {}".format( str(err))) """ Registering this Provider """ registerProvider(mredis)
async def execute(self, sentence, params: List = []): """Execute a transaction get a CQL sentence and execute returns: results of the execution """ error = None self._result = None if not sentence: raise EmptyStatement("Sentence is an empty string") if not self._connection: await self.connection() try: self._result = self._connection.execute(sentence, params) if not self._result: raise NoDataFound("Cassandra: No Data was Found") return [None, "Cassandra: No Data was Found"] return [self._result, None] except Exception as err: error = "Error on Execute: {}".format(str(err)) raise [None, error] finally: return [self._result, error] """ Registering this Provider """ registerProvider(cassandra)
async def column_info(self, tablename): """Column Info. Get Meta information about a table (column name, data type and PK). Useful to build a DataModel from Querying database. Parameters: @tablename: str The name of the table (including schema). """ sql = f"SELECT a.attname AS column_name, a.atttypid::regtype AS data_type, \ format_type(a.atttypid, a.atttypmod) as format_type, a.attnotnull::boolean as notnull, \ coalesce((SELECT true FROM pg_index i WHERE i.indrelid = a.attrelid \ AND i.indrelid = a.attrelid AND a.attnum = any(i.indkey) \ AND i.indisprimary), false) as is_primary \ FROM pg_attribute a WHERE a.attrelid = '{tablename!s}'::regclass \ AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum" if not self._connection: await self.connection() try: colinfo = await self._connection.fetch(sql) return colinfo except Exception as err: self._logger.exception(f"Wrong Table information {tablename!s}") """ Registering this Provider """ registerProvider(pg)
await self._cursor.close() return [result, error] async def executemany(self, sentence: str, *args): error = None await self.valid_operation(sentence) try: result = await self._connection.executemany(sentence, *args) if result: await self._connection.commit() except Exception as err: error = "Error on Query: {}".format(str(err)) raise ProviderError(error) finally: await self._cursor.close() return [result, error] async def fetch(self, sentence: str, parameters: Iterable[Any] = None) -> Iterable: """Helper to create a cursor and execute the given query.""" await self.valid_operation(sentence) if parameters is None: parameters = [] result = await self._connection.execute(sentence, parameters) return result # Registering this Provider registerProvider(sqlite)
async def fetch_scalar(self, sentence="", params: list = []): error = None if not sentence: raise EmptyStatement("Error: Empty Sentence") if not self._connection: await self.connection() try: startTime = datetime.now() self._result = self._connection.execute_scalar(sentence, params) if not self._result: raise NoDataFound("SQL Server: No Data was Found") return [None, "SQL Server: No Data was Found"] except _mssql.MSSQLDatabaseException as err: error = "Error on Query: {}".format(str(err)) raise Exception(error) except RuntimeError as err: error = "Runtime Error: {}".format(str(err)) raise ProviderError(error) except Exception as err: error = "Error on Query: {}".format(str(err)) raise Exception(error) finally: self._generated = datetime.now() - startTime return [self._result, error] """ Registering this Provider """ registerProvider(mssql)
def insert(self, table, data, **kwargs): """ insert insert the result onto a table """ sql = "INSERT INTO {table} ({fields}) VALUES ({values})" sql = sql.format_map(SafeDict(table=table)) # set columns sql = sql.format_map(SafeDict(fields=",".join(data.keys()))) values = ",".join(str(v) for v in data.values()) sql = sql.format_map(SafeDict(values=values)) try: result = self._loop.run_until_complete( self._connection.execute(sql)) if not result: print(result) return False else: return result except Exception as err: # print(sql) print(err) return False """ Registering this Provider """ registerProvider(influx)
if self._transaction: self._transaction.rollback() def close_transaction(self): if self._transaction: try: self._transaction.commit() self._transaction.close() except (SQLAlchemyError, DatabaseError, OperationalError) as err: print(err) error = "Exception Error on Transaction: {}".format(str(err)) raise ProviderError(error) """ Context magic Methods """ def __enter__(self): return self def __exit__(self, exc_type, exc, tb): if self._transaction: self.close_transaction() self.release() """ Registering this Provider """ registerProvider(sql_alchemy)
except Exception as err: self._error = "Error on Query: {}".format(str(err)) raise Exception(error) finally: return [self._result, self._error] def fetchone(self, sentence): self.start(target=self._fetchone, args=(sentence, )) self.join(timeout=self._timeout) return [self._result, self._error] def _fetchone(self, sentence): self._error = None self._result = None try: row = self._loop.run_until_complete( self._connection.fetchrow(sentence)) if row: self._result = asyncRecord(dict(row)) except Exception as err: self._error = "Error on Query Row: {}".format(str(err)) raise Exception(self._error) finally: return [self._result, self._error] """ Registering this Provider """ registerProvider(postgres)