flask sqlalchemy 报错 ORA-01000 maximum open cursors exceeded

def fetchone(self):

        """Fetch one row, just like DB-API ``cursor.fetchone()``.

        After all rows have been exhausted, the underlying DBAPI

        cursor resource is released, and the object may be safely

        discarded.

        Calls to :meth:`.ResultProxy.fetchone` after all rows have

        been exhausted will return ``None``.

        After the :meth:`.ResultProxy.close` method is

        called, the method will raise :class:`.ResourceClosedError`.

        .. versionchanged:: 1.0.0 - Added "soft close" behavior which

           allows the result to be used in an "exhausted" state prior to

           calling the :meth:`.ResultProxy.close` method.

        """

        try:

            row = self._fetchone_impl()

            if row is not None:

                return self.process_rows([row])[0]

            else:

                self._soft_close()

                return None

        except BaseException as e:

            self.connection._handle_dbapi_exception(

                e, None, None,

                self.cursor, self.context)

def first(self):

        """Return the first result of this ``Query`` or

        None if the result doesn't contain any row.

        first() applies a limit of one within the generated SQL, so that

        only one primary entity row is generated on the server side

        (note this may consist of multiple result rows if join-loaded

        collections are present).

        Calling :meth:`.Query.first` results in an execution of the underlying query.

        .. seealso::

            :meth:`.Query.one`

            :meth:`.Query.one_or_none`

        """

        if self._statement is not None:

            ret = list(self)[0:1]

        else:

            ret = list(self[0:1])

        if len(ret) > 0:

            return ret[0]

        else:

            return None

def test_cursor():

    """

    first(): Returns the first record if there is one and closes the connection.

    fetchone(): Returns one row, and leaves the cursor open for you to make additional fetch calls.

    scalar(): Returns a single value if a query results in a single record with one column.

    """

    # 测试 fetchone (), 当我们获取到 execute_1 对象时，可以重复使用该对象的 fetchone () 方法去获取结果（每次获取的结果不同）

    # 此时 cursor 会一直存在，第一次调用 fetchone () 方法时 cursor 在第一行，返回第一个结果，

    # 再次调用方法时 cursor 会移动到第二行，以此类推，cursor 一直向最后一行移动，直到取不到行数时，cursor 才会释放

    sql = text("SELECT * FROM STUDENT")  # 该表返回多条学生记录

    execute_1 = engine.execute(sql)

    for item in range(30):

        result_1 = execute_1.fetchone()

        print(result_1)

    # 测试 first ()，当获取到 execute_2 对象时，仅可以对该对象执行一次 first () 方法，重复执行 first () 方法会抛异常

    # 异常信息：ResourceClosedError: This result object is closed.

    # 说明 first () 方法在获取一次结果后该连接已经关闭，不再提供持续的连接

    sql = text("SELECT * FROM STUDENT")

    execute_2 = engine.execute(sql)

    for item in range(30):

        result_2 = execute_2.first()

        print(result_2)