def callPGLoadPayloadTuplesBlocking(dbSessionCreator: DbSessionCreator,
                                    sql: Select,
                                    sqlCoreLoadTupleClassmethod: Callable,
                                    payloadFilt: Optional[Dict] = None,
                                    fetchSize=50) -> LoadPayloadTupleResult:
    payloadFileJson = ujson.dumps(payloadFilt if payloadFilt else {})

    sqlStr = str(
        sql.compile(dialect=postgresql.dialect(),
                    compile_kwargs={"literal_binds": True}))

    loaderModuleClassMethodStr = '.'.join([
        sqlCoreLoadTupleClassmethod.__self__.__module__,
        sqlCoreLoadTupleClassmethod.__self__.__name__,
        sqlCoreLoadTupleClassmethod.__name__
    ])

    session = dbSessionCreator()
    try:
        sqlFunc = func.peek_storage.load_paylaod_tuples(
            sqlStr, payloadFileJson, loaderModuleClassMethodStr,
            __sysPathsJson, fetchSize)

        resultJsonStr: str = next(session.execute(sqlFunc))[0]

        resultJson: Dict = ujson.loads(resultJsonStr)
        if resultJson["encodedPayload"]:
            resultJson["encodedPayload"] = resultJson["encodedPayload"].encode(
            )

        return LoadPayloadTupleResult(**resultJson)

    finally:
        session.close()
Example #2
0
    def compile_sqla_query(self, qry: Select, schema: Optional[str] = None) -> str:
        engine = self.get_sqla_engine(schema=schema)

        sql = str(qry.compile(engine, compile_kwargs={"literal_binds": True}))

        # pylint: disable=protected-access
        if engine.dialect.identifier_preparer._double_percents:  # noqa
            sql = sql.replace("%%", "%")

        return sql
 def compile_sqla_query(qry: Select, schema: Optional[str] = None) -> str:
     return str(
         qry.compile(
             dialect=mssql.dialect(), compile_kwargs={"literal_binds": True}
         )
     )