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)