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]