async def get(self, table, id):
"""
get
get only one row based on primary key or filtering, Get a document by primary key
-----
"""
error = None
if not id:
raise EmptyStatement("Rethink: Id for get cannot be empty")
if not table:
raise EmptyStatement("Rethink: Table name is an empty string")
if self._connection:
try:
data = await self._engine.table(table).get(id).run(self._connection)
if data:
self._result = data
else:
raise NoDataFound(message="Empty Result", code=404)
except ReqlNonExistenceError as err:
error = "Empty Result: {}".format(str(err))
raise NoDataFound(error)
except (ReqlRuntimeError, ReqlRuntimeError, ReqlError) as err:
error = "QueryRow Runtime Error: {}".format(str(err))
raise ProviderError(err)
return False
finally:
return [self._result, error]
async def fetch(self, **kwargs):
"""
Return a new single record based on filter criteria
"""
if not self.Meta.connection:
self.get_connection(self)
async with await self.Meta.connection.connection() as conn:
try:
result = await self.Meta.connection.fetch_one(
model=self, fields=self.columns(), **kwargs
)
if result:
return self.__class__(**dict(result))
else:
raise NoDataFound(
"{} object with condition {} Not Found!".format(
self.Meta.name, kwargs
)
)
except NoDataFound as err:
raise NoDataFound(err)
except AttributeError:
raise Exception("Error on get {}: {}".format(self.Meta.name, err))
except Exception as err:
print(traceback.format_exc())
raise Exception("Error on get {}: {}".format(self.Meta.name, err))
async def queryrow(self, table, filter={}, id=0):
"""
queryrow
get only one row
"""
error = None
if not table:
raise EmptyStatement("Rethink: Table name is an empty string")
if self._connection:
# startTime = datetime.now()
try:
data = (
await self._engine.table(table)
.filter(filter)
.nth(id)
.run(self._connection)
)
if data:
self._result = data
else:
raise NoDataFound(message="Empty Result", code=404)
except ReqlNonExistenceError as err:
error = "Empty Result: {}".format(str(err))
raise NoDataFound(error)
except (ReqlRuntimeError, ReqlRuntimeError, ReqlError) as err:
error = "QueryRow Runtime Error: {}".format(str(err))
raise ProviderError(err)
return False
finally:
return [self._result, error]
else:
return [None, "Not Connected"]
async def query(self, table, filter=None):
"""
query
get all rows from a table
-----
"""
error = None
if not table:
raise EmptyStatement("Rethink: Table name is an empty string")
if self._connection:
data = []
try:
# self._columns = await self._engine.table(table).get(1).keys().run(self._connection)
self._columns = (
await self._engine.table(table)
.nth(0)
.default(None)
.keys()
.run(self._connection)
)
# print(self._columns)
if not filter:
cursor = (
await self._engine.db(self._db)
.table(table)
.run(self._connection)
)
else:
cursor = (
await self._engine.db(self._db)
.table(table)
.filter(filter)
.run(self._connection)
)
while await cursor.fetch_next():
row = await cursor.next()
data.append(row)
if data:
self._result = data
else:
raise NoDataFound(message="Empty Result", code=404)
except ReqlNonExistenceError as err:
error = "Query Runtime Error: {}".format(str(err))
raise ReqlNonExistenceError(error)
except ReqlRuntimeError as err:
error = "Query Runtime Error: {}".format(str(err))
raise NoDataFound(error)
except ReqlResourceLimitError as error:
error = "Query Runtime Error: {}".format(str(err))
raise ReqlResourceLimitError(error)
except ReqlOpIndeterminateError as error:
error = "Query Runtime Error: {}".format(str(err))
raise ReqlOpIndeterminateError(error)
finally:
# self._generated = datetime.now() - startTime
return [self._result, error]
async def query(self, sentence="", params: list = None):
"""
Making a Query and return result
"""
error = None
self._result = None
if not sentence:
raise EmptyStatement("Error: Empty Sentence")
if not self._connection:
await self.connection()
if isinstance(sentence, str):
sentence = sentence.encode(self._charset)
try:
startTime = datetime.now()
self._cursor = self._connection.cursor()
self._cursor.execute(sentence, params)
self._result = self._cursor.fetchall()
if not self._result:
raise NoDataFound("SQL Server: No Data was Found")
return [None, "SQL Server: No Data was Found"]
except (pymssql.StandardError, pymssql.Error) as err:
error = "SQL Server Error: {}".format(str(err))
raise ProviderError(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]
async def query(
self,
sentence: Union[str, SimpleStatement, PreparedStatement],
params: list = [],
):
error = None
self._result = None
if not sentence:
raise EmptyStatement("Sentence is an empty string")
if not self._connection:
await self.connection()
try:
startTime = datetime.now()
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"]
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]
async def queryrow(self, sentence="", **kwargs):
# self._logger.debug("Start Query function")
error = None
if not sentence:
raise EmptyStatement("Sentence is an empty string")
if not self._connection:
await self.connection()
try:
startTime = datetime.now()
print(startTime)
params = {"chunked": True, "chunk_size": 1}
fn = partial(self._connection.query, sentence, **params, **kwargs)
self._result = await asyncio.get_running_loop().run_in_executor(
None, fn)
if not self._result:
raise NoDataFound("InfluxDB: No Data was Found")
return [None, "InfluxDB: 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:
return [self._result, error]
async def filter(cls, **kwargs):
"""
Need to return a ***collection*** of nested DataClasses
"""
if not cls.Meta.connection:
cls.get_connection(cls)
async with await cls.Meta.connection.connection() as conn:
try:
result = await cls.Meta.connection.filter(model=cls, **kwargs)
if result:
return [cls(**dict(r)) for r in result]
else:
raise NoDataFound(
"No Data on {} with condition {}".format(cls.Meta.name, kwargs)
)
except NoDataFound as err:
raise NoDataFound(err)
except Exception as err:
print(traceback.format_exc())
raise Exception("Error on filter {}: {}".format(cls.Meta.name, err))
async def get(cls, **kwargs):
"""
Return a new single record based on filter criteria
"""
if not cls.Meta.connection:
cls.get_connection(cls)
async with await cls.Meta.connection.connection() as conn:
try:
result = await cls.Meta.connection.get_one(model=cls, **kwargs)
if result:
return cls(**dict(result))
else:
raise NoDataFound(message=f"Data not found over {cls.Meta.name!s}")
except NoDataFound:
raise NoDataFound(message=f"Data not found over {cls.Meta.name!s}")
except AttributeError as err:
raise Exception("Error on get {}: {}".format(cls.Meta.name, err))
except Exception as err:
print(traceback.format_exc())
raise Exception("Error on get {}: {}".format(cls.Meta.name, err))
async def select(self, **kwargs):
"""
Need to return a ***collection*** of nested DataClasses
"""
if not self.Meta.connection:
self.get_connection(self)
async with await self.Meta.connection.connection() as conn:
try:
result = await self.Meta.connection.select(
model=self, fields=self.columns(), **kwargs
)
if result:
return [self.__class__(**dict(r)) for r in result]
else:
raise NoDataFound(
"No Data on {} with condition {}".format(self.Meta.name, kwargs)
)
except NoDataFound as err:
raise NoDataFound(err)
except Exception as err:
print(traceback.format_exc())
raise Exception("Error on filter {}: {}".format(self.Meta.name, err))
async def between(self, table, min=None, max=None, idx=""):
"""
between
Get all documents between two keys
-----
"""
if not table:
raise EmptyStatement("Rethink: Table name is an empty string")
if self._connection:
error = None
if min:
m = min
else:
m = self._engine.minval
if max:
mx = max
else:
mx = self._engine.maxval
try:
if idx:
cursor = (
await self._engine.table(table)
.order_by(index=idx)
.between(m, mx, index=idx)
.run(self._connection)
)
else:
cursor = (
await self._engine.table(table)
.between(m, mx)
.run(self._connection)
)
data = []
while await cursor.fetch_next():
item = await cursor.next()
data.append(item)
if data:
self._result = data
else:
raise NoDataFound(message="Empty Result", code=404)
except (ReqlRuntimeError, ReqlRuntimeError, ReqlError) as err:
error = str(err)
raise ProviderError(err)
return False
finally:
return [self._result, error]
else:
return None
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]
async def query(self, sentence="", size=100000000000):
# self._logger.debug("Start Query function")
error = None
if not sentence:
raise EmptyStatement("Sentence is an empty string")
if not self._connection:
await self.connection()
try:
startTime = datetime.now()
await self._cursor.execute(sentence)
self._result = await self.fetchmany(size)
if not self._result:
raise NoDataFound("Mysql: No Data was Found")
return [None, "Mysql: 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
# await self.close()
return [self._result, error]
async def match(self, table, field="id", regexp="(?i)^[a-z]+$"):
"""
match
get all rows where the given value matches with a regular expression
-----
"""
if not table:
raise EmptyStatement("Rethink: Table name is an empty string")
if self._connection:
try:
data = (
await self._engine.table(table)
.filter(lambda doc: doc[field].match(regexp))
.run(self._connection)
)
if data:
self._result = data
else:
raise NoDataFound(message="Empty Result", code=404)
return self._result
except ReqlRuntimeError as err:
error = "Query Get All Runtime Error: {}".format(str(err))
raise ProviderError(error)
return False
async def get_all(self, table, filter=[], index=""):
"""
get_all
get all rows where the given value matches the value of the requested index
-----
"""
if not table:
raise EmptyStatement("Rethink: Table name is an empty string")
if self._connection:
try:
if index:
cursor = (
await self._engine.table(table)
.get_all(filter, index=index)
.run(self._connection)
)
else:
cursor = (
await self._engine.table(table)
.get_all(filter)
.run(self._connection)
)
data = []
while await cursor.fetch_next():
item = await cursor.next()
data.append(item)
if data:
self._result = data
else:
raise NoDataFound(message="Empty Result", code=404)
return self._result
except ReqlRuntimeError as err:
error = "Query Get All Runtime Error: {}".format(str(err))
raise ProviderError(error)
return False
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]
