diff --git a/samples/app_context.py b/samples/app_context.py index 4bae790..41c411f 100644 --- a/samples/app_context.py +++ b/samples/app_context.py @@ -16,7 +16,7 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env # define constants used throughout the script; adjust as desired @@ -27,8 +27,8 @@ APP_CTX_ENTRIES = [ ( APP_CTX_NAMESPACE, "ATTR3", "VALUE3" ) ] -connection = cx_Oracle.connect(sample_env.get_main_connect_string(), - appcontext=APP_CTX_ENTRIES) +connection = oracledb.connect(sample_env.get_main_connect_string(), + appcontext=APP_CTX_ENTRIES) cursor = connection.cursor() for namespace, name, value in APP_CTX_ENTRIES: cursor.execute("select sys_context(:1, :2) from dual", (namespace, name)) diff --git a/samples/aq_notification.py b/samples/aq_notification.py index a505c6a..728d5b2 100644 --- a/samples/aq_notification.py +++ b/samples/aq_notification.py @@ -12,27 +12,27 @@ # This script requires cx_Oracle 6.4 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env -import threading import time +import cx_Oracle as oracledb +import sample_env + registered = True -def ProcessMessages(message): +def process_messages(message): global registered print("Message type:", message.type) - if message.type == cx_Oracle.EVENT_DEREG: + if message.type == oracledb.EVENT_DEREG: print("Deregistration has taken place...") registered = False return print("Queue name:", message.queueName) print("Consumer name:", message.consumerName) -connection = cx_Oracle.connect(sample_env.get_main_connect_string(), - events=True) -sub = connection.subscribe(namespace=cx_Oracle.SUBSCR_NAMESPACE_AQ, - name="DEMO_BOOK_QUEUE", callback=ProcessMessages, +connection = oracledb.connect(sample_env.get_main_connect_string(), + events=True) +sub = connection.subscribe(namespace=oracledb.SUBSCR_NAMESPACE_AQ, + name="DEMO_BOOK_QUEUE", callback=process_messages, timeout=300) print("Subscription:", sub) print("--> Connection:", sub.connection) diff --git a/samples/array_dml_rowcounts.py b/samples/array_dml_rowcounts.py index 405ac2e..335d46c 100644 --- a/samples/array_dml_rowcounts.py +++ b/samples/array_dml_rowcounts.py @@ -13,10 +13,10 @@ # This script requires cx_Oracle 5.2 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # show the number of rows for each parent ID as a means of verifying the diff --git a/samples/batch_errors.py b/samples/batch_errors.py index 1637a8c..8d093bd 100644 --- a/samples/batch_errors.py +++ b/samples/batch_errors.py @@ -15,10 +15,10 @@ # This script requires cx_Oracle 5.2 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # define data to insert @@ -47,7 +47,7 @@ print("number of rows to insert:", len(data_to_insert)) try: cursor.executemany("insert into ChildTable values (:1, :2, :3)", data_to_insert) -except cx_Oracle.DatabaseError as e: +except oracledb.DatabaseError as e: error, = e.args print("FAILED with error:", error.message) print("number of rows which succeeded:", cursor.rowcount) diff --git a/samples/bind_insert.py b/samples/bind_insert.py index ab1d794..fef635b 100644 --- a/samples/bind_insert.py +++ b/samples/bind_insert.py @@ -8,10 +8,10 @@ # Demonstrate how to insert a row into a table using bind variables. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) #------------------------------------------------------------------------------ # "Bind by position" diff --git a/samples/bind_query.py b/samples/bind_query.py index f54f9e9..5b09bc7 100644 --- a/samples/bind_query.py +++ b/samples/bind_query.py @@ -12,10 +12,10 @@ # special characters or SQL injection attacks. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() sql = 'select * from SampleQueryTab where id = :bvid' diff --git a/samples/bulk_aq.py b/samples/bulk_aq.py index 9623695..e2a76ac 100644 --- a/samples/bulk_aq.py +++ b/samples/bulk_aq.py @@ -16,7 +16,7 @@ # This script requires cx_Oracle 7.2 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env QUEUE_NAME = "DEMO_RAW_QUEUE" @@ -36,13 +36,13 @@ PAYLOAD_DATA = [ ] # connect to database -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # create queue queue = connection.queue(QUEUE_NAME) -queue.deqOptions.wait = cx_Oracle.DEQ_NO_WAIT -queue.deqOptions.navigation = cx_Oracle.DEQ_FIRST_MSG +queue.deqOptions.wait = oracledb.DEQ_NO_WAIT +queue.deqOptions.navigation = oracledb.DEQ_FIRST_MSG # dequeue all existing messages to ensure the queue is empty, just so that # the results are consistent diff --git a/samples/call_timeout.py b/samples/call_timeout.py index e52d0f7..b665d9f 100644 --- a/samples/call_timeout.py +++ b/samples/call_timeout.py @@ -13,10 +13,10 @@ # higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) connection.call_timeout = 2000 print("Call timeout set at", connection.call_timeout, "milliseconds...") @@ -33,7 +33,7 @@ sleep_proc_name = "dbms_session.sleep" \ print("Sleeping...should time out...") try: cursor.callproc(sleep_proc_name, (3,)) -except cx_Oracle.DatabaseError as e: +except oracledb.DatabaseError as e: print("ERROR:", e) cursor.execute("select sysdate from dual") diff --git a/samples/connection_pool.py b/samples/connection_pool.py index 132905e..512d3e1 100644 --- a/samples/connection_pool.py +++ b/samples/connection_pool.py @@ -20,27 +20,22 @@ # #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import threading +import cx_Oracle as oracledb +import sample_env + # Create a Connection Pool -pool = cx_Oracle.SessionPool(user=sample_env.get_main_user(), - password=sample_env.get_main_password(), - dsn=sample_env.get_connect_string(), min=2, - max=5, increment=1, threaded=True) +pool = oracledb.SessionPool(user=sample_env.get_main_user(), + password=sample_env.get_main_password(), + dsn=sample_env.get_connect_string(), min=2, + max=5, increment=1, threaded=True) -# dbms_session.sleep() replaces dbms_lock.sleep() from Oracle Database 18c -with pool.acquire() as conn: - sleep_proc_name = "dbms_session.sleep" \ - if int(conn.version.split(".")[0]) >= 18 \ - else "dbms_lock.sleep" - -def TheLongQuery(): +def the_long_query(): with pool.acquire() as conn: cursor = conn.cursor() cursor.arraysize = 25000 - print("TheLongQuery(): beginning execute...") + print("the_long_query(): beginning execute...") cursor.execute(""" select * from @@ -50,27 +45,32 @@ def TheLongQuery(): cross join TestNumbers cross join TestNumbers cross join TestNumbers""") - print("TheLongQuery(): done execute...") + print("the_long_query(): done execute...") while True: rows = cursor.fetchmany() if not rows: break - print("TheLongQuery(): fetched", len(rows), "rows...") - print("TheLongQuery(): all done!") + print("the_long_query(): fetched", len(rows), "rows...") + print("the_long_query(): all done!") -def DoALock(): +def do_a_lock(): with pool.acquire() as conn: + # dbms_session.sleep() replaces dbms_lock.sleep() + # from Oracle Database 18c + sleep_proc_name = "dbms_session.sleep" \ + if int(conn.version.split(".")[0]) >= 18 \ + else "dbms_lock.sleep" cursor = conn.cursor() - print("DoALock(): beginning execute...") + print("do_a_lock(): beginning execute...") cursor.callproc(sleep_proc_name, (5,)) - print("DoALock(): done execute...") + print("do_a_lock(): done execute...") -thread1 = threading.Thread(None, TheLongQuery) +thread1 = threading.Thread(target=the_long_query) thread1.start() -thread2 = threading.Thread(None, DoALock) +thread2 = threading.Thread(target=do_a_lock) thread2.start() thread1.join() diff --git a/samples/cqn.py b/samples/cqn.py index e2668c6..f85dbe1 100644 --- a/samples/cqn.py +++ b/samples/cqn.py @@ -17,10 +17,11 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import time +import cx_Oracle as oracledb +import sample_env + registered = True def callback(message): @@ -47,10 +48,10 @@ def callback(message): print("-" * 60) print("=" * 60) -connection = cx_Oracle.connect(sample_env.get_main_connect_string(), - events=True) -sub = connection.subscribe(callback = callback, timeout = 1800, - qos = cx_Oracle.SUBSCR_QOS_QUERY | cx_Oracle.SUBSCR_QOS_ROWIDS) +connection = oracledb.connect(sample_env.get_main_connect_string(), + events=True) +qos = oracledb.SUBSCR_QOS_QUERY | oracledb.SUBSCR_QOS_ROWIDS +sub = connection.subscribe(callback=callback, timeout=1800, qos=qos) print("Subscription:", sub) print("--> Connection:", sub.connection) print("--> Callback:", sub.callback) @@ -58,7 +59,7 @@ print("--> Namespace:", sub.namespace) print("--> Protocol:", sub.protocol) print("--> Timeout:", sub.timeout) print("--> Operations:", sub.operations) -print("--> Rowids?:", bool(sub.qos & cx_Oracle.SUBSCR_QOS_ROWIDS)) +print("--> Rowids?:", bool(sub.qos & oracledb.SUBSCR_QOS_ROWIDS)) queryId = sub.registerquery("select * from TestTempTable") print("Registered query:", queryId) diff --git a/samples/cqn2.py b/samples/cqn2.py index 1205fdb..4536364 100644 --- a/samples/cqn2.py +++ b/samples/cqn2.py @@ -7,7 +7,7 @@ # This script demonstrates using continuous query notification in Python, a # feature that is available in Oracle 11g and later. Once this script is # running, use another session to insert, update or delete rows from the table -# cx_Oracle.TestTempTable and you will see the notification of that change. +# TestTempTable and you will see the notification of that change. # # This script differs from cqn.py in that it shows how a connection can be # acquired from a session pool and used to query the changes that have been @@ -16,10 +16,11 @@ # This script requires cx_Oracle 7 or higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import time +import cx_Oracle as oracledb +import sample_env + registered = True def callback(message): @@ -37,13 +38,13 @@ def callback(message): num_rows_deleted = 0 print(len(table.rows), "row changes detected in table", table.name) for row in table.rows: - if row.operation & cx_Oracle.OPCODE_DELETE: + if row.operation & oracledb.OPCODE_DELETE: num_rows_deleted += 1 continue ops = [] - if row.operation & cx_Oracle.OPCODE_INSERT: + if row.operation & oracledb.OPCODE_INSERT: ops.append("inserted") - if row.operation & cx_Oracle.OPCODE_UPDATE: + if row.operation & oracledb.OPCODE_UPDATE: ops.append("updated") cursor = connection.cursor() cursor.execute(""" @@ -57,13 +58,13 @@ def callback(message): print(" ", num_rows_deleted, "rows deleted") print("=" * 60) -pool = cx_Oracle.SessionPool(user=sample_env.get_main_user(), - password=sample_env.get_main_password(), - dsn=sample_env.get_connect_string(), min=2, - max=5, increment=1, events=True, threaded=True) +pool = oracledb.SessionPool(user=sample_env.get_main_user(), + password=sample_env.get_main_password(), + dsn=sample_env.get_connect_string(), min=2, max=5, + increment=1, events=True, threaded=True) with pool.acquire() as connection: - sub = connection.subscribe(callback=callback, timeout=1800, - qos=cx_Oracle.SUBSCR_QOS_QUERY | cx_Oracle.SUBSCR_QOS_ROWIDS) + qos = oracledb.SUBSCR_QOS_QUERY | oracledb.SUBSCR_QOS_ROWIDS + sub = connection.subscribe(callback=callback, timeout=1800, qos=qos) print("Subscription created with ID:", sub.id) query_id = sub.registerquery("select * from TestTempTable") print("Registered query with ID:", query_id) diff --git a/samples/database_change_notification.py b/samples/database_change_notification.py index 871d1ad..db404bd 100644 --- a/samples/database_change_notification.py +++ b/samples/database_change_notification.py @@ -17,10 +17,11 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import time +import cx_Oracle as oracledb +import sample_env + registered = True def callback(message): @@ -44,10 +45,10 @@ def callback(message): print("-" * 60) print("=" * 60) -connection = cx_Oracle.connect(sample_env.get_main_connect_string(), - events=True) -sub = connection.subscribe(callback = callback, timeout = 1800, - qos = cx_Oracle.SUBSCR_QOS_ROWIDS) +connection = oracledb.connect(sample_env.get_main_connect_string(), + events=True) +sub = connection.subscribe(callback=callback, timeout=1800, + qos=oracledb.SUBSCR_QOS_ROWIDS) print("Subscription:", sub) print("--> Connection:", sub.connection) print("--> ID:", sub.id) @@ -56,7 +57,7 @@ print("--> Namespace:", sub.namespace) print("--> Protocol:", sub.protocol) print("--> Timeout:", sub.timeout) print("--> Operations:", sub.operations) -print("--> Rowids?:", bool(sub.qos & cx_Oracle.SUBSCR_QOS_ROWIDS)) +print("--> Rowids?:", bool(sub.qos & oracledb.SUBSCR_QOS_ROWIDS)) sub.registerquery("select * from TestTempTable") while registered: diff --git a/samples/database_shutdown.py b/samples/database_shutdown.py index d31592e..63210b5 100644 --- a/samples/database_shutdown.py +++ b/samples/database_shutdown.py @@ -16,14 +16,14 @@ # This script requires cx_Oracle 4.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb # need to connect as SYSDBA or SYSOPER -connection = cx_Oracle.connect(mode=cx_Oracle.SYSDBA) +connection = oracledb.connect(mode=oracledb.SYSDBA) # first shutdown() call must specify the mode, if DBSHUTDOWN_ABORT is used, # there is no need for any of the other steps -connection.shutdown(mode=cx_Oracle.DBSHUTDOWN_IMMEDIATE) +connection.shutdown(mode=oracledb.DBSHUTDOWN_IMMEDIATE) # now close and dismount the database cursor = connection.cursor() @@ -31,4 +31,4 @@ cursor.execute("alter database close normal") cursor.execute("alter database dismount") # perform the final shutdown call -connection.shutdown(mode=cx_Oracle.DBSHUTDOWN_FINAL) +connection.shutdown(mode=oracledb.DBSHUTDOWN_FINAL) diff --git a/samples/database_startup.py b/samples/database_startup.py index 1ca98b1..e036458 100644 --- a/samples/database_startup.py +++ b/samples/database_startup.py @@ -16,14 +16,14 @@ # This script requires cx_Oracle 4.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb # the connection must be in PRELIM_AUTH mode -connection = cx_Oracle.connect(mode=cx_Oracle.SYSDBA | cx_Oracle.PRELIM_AUTH) +connection = oracledb.connect(mode=oracledb.SYSDBA | oracledb.PRELIM_AUTH) connection.startup() # the following statements must be issued in normal SYSDBA mode -connection = cx_Oracle.connect("/", mode=cx_Oracle.SYSDBA) +connection = oracledb.connect("/", mode=oracledb.SYSDBA) cursor = connection.cursor() cursor.execute("alter database mount") cursor.execute("alter database open") diff --git a/samples/dbms_output.py b/samples/dbms_output.py index 3e5a60d..e16ad0d 100644 --- a/samples/dbms_output.py +++ b/samples/dbms_output.py @@ -8,10 +8,10 @@ # the DBMS_OUTPUT package. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # enable DBMS_OUTPUT diff --git a/samples/dml_returning_multiple_rows.py b/samples/dml_returning_multiple_rows.py index 2347eef..cd11c2d 100644 --- a/samples/dml_returning_multiple_rows.py +++ b/samples/dml_returning_multiple_rows.py @@ -15,12 +15,11 @@ # This script requires cx_Oracle 6.0 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import datetime +import cx_Oracle as oracledb import sample_env # truncate table first so that script can be rerun -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() print("Truncating table...") cursor.execute("truncate table TestTempTable") diff --git a/samples/drcp.py b/samples/drcp.py index 0c138b6..289b856 100644 --- a/samples/drcp.py +++ b/samples/drcp.py @@ -32,11 +32,11 @@ # #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -conn = cx_Oracle.connect(sample_env.get_drcp_connect_string(), - cclass="PYCLASS", purity=cx_Oracle.ATTR_PURITY_SELF) +conn = oracledb.connect(sample_env.get_drcp_connect_string(), + cclass="PYCLASS", purity=oracledb.ATTR_PURITY_SELF) cursor = conn.cursor() print("Performing query using DRCP...") for row in cursor.execute("select * from TestNumbers order by IntCol"): diff --git a/samples/drop_samples.py b/samples/drop_samples.py index a41fb9b..d3d51c7 100644 --- a/samples/drop_samples.py +++ b/samples/drop_samples.py @@ -8,7 +8,7 @@ # Drops the database objects used for the cx_Oracle samples. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env def drop_samples(conn): @@ -19,6 +19,6 @@ def drop_samples(conn): edition_name=sample_env.get_edition_name()) if __name__ == "__main__": - conn = cx_Oracle.connect(sample_env.get_admin_connect_string()) + conn = oracledb.connect(sample_env.get_admin_connect_string()) drop_samples(conn) print("Done.") diff --git a/samples/editioning.py b/samples/editioning.py index 349cd64..6492c7d 100644 --- a/samples/editioning.py +++ b/samples/editioning.py @@ -17,14 +17,15 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import os +import cx_Oracle as oracledb +import sample_env + # connect to the editions user and create a procedure edition_connect_string = sample_env.get_edition_connect_string() edition_name = sample_env.get_edition_name() -connection = cx_Oracle.connect(edition_connect_string) +connection = oracledb.connect(edition_connect_string) print("Edition should be None, actual value is:", repr(connection.edition)) cursor = connection.cursor() cursor.execute(""" @@ -57,8 +58,8 @@ print("Function should return 'Base Procedure', actually returns:", repr(result)) # the edition can be set upon connection -connection = cx_Oracle.connect(edition_connect_string, - edition=edition_name.upper()) +connection = oracledb.connect(edition_connect_string, + edition=edition_name.upper()) cursor = connection.cursor() result = cursor.callfunc("TestEditions", str) print("Function should return 'Edition 1 Procedure', actually returns:", @@ -66,7 +67,7 @@ print("Function should return 'Edition 1 Procedure', actually returns:", # it can also be set via the environment variable ORA_EDITION os.environ["ORA_EDITION"] = edition_name.upper() -connection = cx_Oracle.connect(edition_connect_string) +connection = oracledb.connect(edition_connect_string) print("Edition should be", repr(edition_name.upper()), "actual value is:", repr(connection.edition)) cursor = connection.cursor() diff --git a/samples/generic_row_factory.py b/samples/generic_row_factory.py index 01a9a50..1ada24b 100644 --- a/samples/generic_row_factory.py +++ b/samples/generic_row_factory.py @@ -10,23 +10,23 @@ #------------------------------------------------------------------------------ import collections -import cx_Oracle +import cx_Oracle as oracledb import sample_env -class Connection(cx_Oracle.Connection): +class Connection(oracledb.Connection): def cursor(self): return Cursor(self) -class Cursor(cx_Oracle.Cursor): +class Cursor(oracledb.Cursor): def execute(self, statement, args = None): prepare_needed = (self.statement != statement) - result = super(Cursor, self).execute(statement, args or []) + result = super().execute(statement, args or []) if prepare_needed: description = self.description - if description: + if description is not None: names = [d[0] for d in description] self.rowfactory = collections.namedtuple("GenericQuery", names) return result diff --git a/samples/implicit_results.py b/samples/implicit_results.py index 84da502..78b7009 100644 --- a/samples/implicit_results.py +++ b/samples/implicit_results.py @@ -16,10 +16,10 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # use PL/SQL block to return two cursors diff --git a/samples/insert_geometry.py b/samples/insert_geometry.py index 7b63ead..9df612f 100644 --- a/samples/insert_geometry.py +++ b/samples/insert_geometry.py @@ -15,11 +15,11 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env # create and populate Oracle objects -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) type_obj = connection.gettype("MDSYS.SDO_GEOMETRY") element_info_type_obj = connection.gettype("MDSYS.SDO_ELEM_INFO_ARRAY") ordinate_type_obj = connection.gettype("MDSYS.SDO_ORDINATE_ARRAY") diff --git a/samples/json_blob.py b/samples/json_blob.py index 061bad1..213acc5 100644 --- a/samples/json_blob.py +++ b/samples/json_blob.py @@ -17,12 +17,12 @@ import sys import json -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) -client_version = cx_Oracle.clientversion()[0] +client_version = oracledb.clientversion()[0] db_version = int(connection.version.split(".")[0]) # Minimum database vesion is 12 @@ -52,7 +52,7 @@ data = dict(name="Rod", dept="Sales", location="Germany") inssql = "insert into customers values (:1, :2)" if client_version >= 21 and db_version >= 21: # Take advantage of direct binding - cursor.setinputsizes(None, cx_Oracle.DB_TYPE_JSON) + cursor.setinputsizes(None, oracledb.DB_TYPE_JSON) cursor.execute(inssql, [1, data]) else: # Insert the data as a JSON string diff --git a/samples/json_direct.py b/samples/json_direct.py index b405fe8..891b6d8 100644 --- a/samples/json_direct.py +++ b/samples/json_direct.py @@ -12,12 +12,12 @@ import sys import json -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) -client_version = cx_Oracle.clientversion()[0] +client_version = oracledb.clientversion()[0] db_version = int(connection.version.split(".")[0]) # this script only works with Oracle Database 21 @@ -49,7 +49,7 @@ data = dict(name="Rod", dept="Sales", location="Germany") inssql = "insert into customers values (:1, :2)" if client_version >= 21: # Take advantage of direct binding - cursor.setinputsizes(None, cx_Oracle.DB_TYPE_JSON) + cursor.setinputsizes(None, oracledb.DB_TYPE_JSON) cursor.execute(inssql, [1, data]) else: # Insert the data as a JSON string diff --git a/samples/last_rowid.py b/samples/last_rowid.py index b60c801..948166b 100644 --- a/samples/last_rowid.py +++ b/samples/last_rowid.py @@ -9,10 +9,10 @@ # This script requires cx_Oracle 7.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) row1 = [1, "First"] row2 = [2, "Second"] diff --git a/samples/multi_consumer_aq.py b/samples/multi_consumer_aq.py index ad68ce7..8e72ada 100644 --- a/samples/multi_consumer_aq.py +++ b/samples/multi_consumer_aq.py @@ -15,7 +15,7 @@ # This script requires cx_Oracle 8.2 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env QUEUE_NAME = "DEMO_RAW_QUEUE_MULTI" @@ -27,13 +27,13 @@ PAYLOAD_DATA = [ ] # connect to database -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # create queue queue = connection.queue(QUEUE_NAME) -queue.deqoptions.wait = cx_Oracle.DEQ_NO_WAIT -queue.deqoptions.navigation = cx_Oracle.DEQ_FIRST_MSG +queue.deqoptions.wait = oracledb.DEQ_NO_WAIT +queue.deqoptions.navigation = oracledb.DEQ_FIRST_MSG # enqueue a few messages print("Enqueuing messages...") diff --git a/samples/object_aq.py b/samples/object_aq.py index 890d1d2..a8205c6 100644 --- a/samples/object_aq.py +++ b/samples/object_aq.py @@ -16,10 +16,11 @@ # This script requires cx_Oracle 8.2 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import decimal +import cx_Oracle as oracledb +import sample_env + BOOK_TYPE_NAME = "UDT_BOOK" QUEUE_NAME = "DEMO_BOOK_QUEUE" BOOK_DATA = [ @@ -30,14 +31,14 @@ BOOK_DATA = [ ] # connect to database -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # create queue books_type = connection.gettype(BOOK_TYPE_NAME) queue = connection.queue(QUEUE_NAME, payload_type=books_type) -queue.deqoptions.wait = cx_Oracle.DEQ_NO_WAIT -queue.deqoptions.navigation = cx_Oracle.DEQ_FIRST_MSG +queue.deqoptions.wait = oracledb.DEQ_NO_WAIT +queue.deqoptions.navigation = oracledb.DEQ_FIRST_MSG # dequeue all existing messages to ensure the queue is empty, just so that # the results are consistent diff --git a/samples/plsql_collection.py b/samples/plsql_collection.py index cde3ee4..4699720 100644 --- a/samples/plsql_collection.py +++ b/samples/plsql_collection.py @@ -13,10 +13,10 @@ # is new in cx_Oracle 7.0. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) # create new empty object of the correct type # note the use of a PL/SQL type defined in a package diff --git a/samples/plsql_function.py b/samples/plsql_function.py index c8d3140..b67cf4f 100644 --- a/samples/plsql_function.py +++ b/samples/plsql_function.py @@ -8,10 +8,10 @@ # Demonstrate how to call a PL/SQL function and get its return value. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() res = cursor.callfunc('myfunc', int, ('abc', 2)) diff --git a/samples/plsql_procedure.py b/samples/plsql_procedure.py index 22d52ab..113d880 100644 --- a/samples/plsql_procedure.py +++ b/samples/plsql_procedure.py @@ -9,10 +9,10 @@ # OUT variable. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() myvar = cursor.var(int) diff --git a/samples/plsql_record.py b/samples/plsql_record.py index 5a5d1bd..9e8779e 100644 --- a/samples/plsql_record.py +++ b/samples/plsql_record.py @@ -11,11 +11,12 @@ # Database 12.1 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import datetime -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +import cx_Oracle as oracledb +import sample_env + +connection = oracledb.connect(sample_env.get_main_connect_string()) # create new object of the correct type # note the use of a PL/SQL record defined in a package diff --git a/samples/query.py b/samples/query.py index 9443e5b..d96299c 100644 --- a/samples/query.py +++ b/samples/query.py @@ -8,10 +8,10 @@ # Demonstrate how to perform a query in different ways. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) sql = """ select * from SampleQueryTab diff --git a/samples/query_arraysize.py b/samples/query_arraysize.py index b6fd572..661ddbf 100644 --- a/samples/query_arraysize.py +++ b/samples/query_arraysize.py @@ -11,10 +11,11 @@ #------------------------------------------------------------------------------ import time -import cx_Oracle + +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) start = time.time() diff --git a/samples/raw_aq.py b/samples/raw_aq.py index 93b17bb..3f94c70 100644 --- a/samples/raw_aq.py +++ b/samples/raw_aq.py @@ -15,7 +15,7 @@ # This script requires cx_Oracle 8.2 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env QUEUE_NAME = "DEMO_RAW_QUEUE" @@ -27,13 +27,13 @@ PAYLOAD_DATA = [ ] # connect to database -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # create queue queue = connection.queue(QUEUE_NAME) -queue.deqoptions.wait = cx_Oracle.DEQ_NO_WAIT -queue.deqoptions.navigation = cx_Oracle.DEQ_FIRST_MSG +queue.deqoptions.wait = oracledb.DEQ_NO_WAIT +queue.deqoptions.navigation = oracledb.DEQ_FIRST_MSG # dequeue all existing messages to ensure the queue is empty, just so that # the results are consistent diff --git a/samples/ref_cursor.py b/samples/ref_cursor.py index 7f675a8..ffb2ad2 100644 --- a/samples/ref_cursor.py +++ b/samples/ref_cursor.py @@ -7,10 +7,10 @@ # Demonstrates the use of REF cursors with cx_Oracle. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() ref_cursor = connection.cursor() diff --git a/samples/return_lobs_as_strings.py b/samples/return_lobs_as_strings.py index d403d37..1c42069 100644 --- a/samples/return_lobs_as_strings.py +++ b/samples/return_lobs_as_strings.py @@ -18,16 +18,16 @@ # This script requires cx_Oracle 5.0 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env def output_type_handler(cursor, name, default_type, size, precision, scale): - if default_type == cx_Oracle.CLOB: - return cursor.var(cx_Oracle.LONG_STRING, arraysize=cursor.arraysize) - if default_type == cx_Oracle.BLOB: - return cursor.var(cx_Oracle.LONG_BINARY, arraysize=cursor.arraysize) + if default_type == oracledb.CLOB: + return cursor.var(oracledb.LONG_STRING, arraysize=cursor.arraysize) + if default_type == oracledb.BLOB: + return cursor.var(oracledb.LONG_BINARY, arraysize=cursor.arraysize) -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) connection.outputtypehandler = output_type_handler cursor = connection.cursor() @@ -40,11 +40,11 @@ for i in range(10): char = chr(ord('A') + i) long_string += char * 25000 # uncomment the line below for cx_Oracle 5.3 and earlier - # cursor.setinputsizes(None, cx_Oracle.LONG_STRING) + # cursor.setinputsizes(None, oracledb.LONG_STRING) cursor.execute("insert into TestClobs values (:1, :2)", (i + 1, "STRING " + long_string)) # uncomment the line below for cx_Oracle 5.3 and earlier - # cursor.setinputsizes(None, cx_Oracle.LONG_BINARY) + # cursor.setinputsizes(None, oracledb.LONG_BINARY) cursor.execute("insert into TestBlobs values (:1, :2)", (i + 1, long_string.encode("ascii"))) connection.commit() diff --git a/samples/return_numbers_as_decimals.py b/samples/return_numbers_as_decimals.py index ab7396a..becb972 100644 --- a/samples/return_numbers_as_decimals.py +++ b/samples/return_numbers_as_decimals.py @@ -14,15 +14,16 @@ # This script requires cx_Oracle 5.0 and higher. #------------------------------------------------------------------------------ -import cx_Oracle import decimal + +import cx_Oracle as oracledb import sample_env -def output_type_handler(cursor, name, defaultType, size, precision, scale): - if defaultType == cx_Oracle.NUMBER: - return cursor.var(decimal.Decimal, arraysize = cursor.arraysize) +def output_type_handler(cursor, name, default_type, size, precision, scale): + if default_type == oracledb.NUMBER: + return cursor.var(decimal.Decimal, arraysize=cursor.arraysize) -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) connection.outputtypehandler = output_type_handler cursor = connection.cursor() cursor.execute("select * from TestNumbers") diff --git a/samples/rows_as_instance.py b/samples/rows_as_instance.py index 30c1605..1ab1c63 100644 --- a/samples/rows_as_instance.py +++ b/samples/rows_as_instance.py @@ -16,17 +16,17 @@ # This script requires cx_Oracle 4.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -class Test(object): +class Test: def __init__(self, a, b, c): self.a = a self.b = b self.c = c -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # change this to False if you want to create the table yourself using SQL*Plus diff --git a/samples/scrollable_cursors.py b/samples/scrollable_cursors.py index 7042c8a..3fb855b 100644 --- a/samples/scrollable_cursors.py +++ b/samples/scrollable_cursors.py @@ -16,10 +16,10 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) # show all of the rows available in the table cursor = connection.cursor() diff --git a/samples/session_callback.py b/samples/session_callback.py index c91c7cf..0964a1f 100644 --- a/samples/session_callback.py +++ b/samples/session_callback.py @@ -20,7 +20,7 @@ # #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env # define a dictionary of NLS_DATE_FORMAT formats supported by this sample @@ -52,22 +52,22 @@ def init_session(conn, requested_tag): # in this example, they are used to set NLS parameters and the tag is # parsed to validate it if requested_tag is not None: - stateParts = [] + state_parts = [] for directive in requested_tag.split(";"): parts = directive.split("=") if len(parts) != 2: raise ValueError("Tag must contain key=value pairs") key, value = parts - valueDict = SUPPORTED_KEYS.get(key) - if valueDict is None: + value_dict = SUPPORTED_KEYS.get(key) + if value_dict is None: raise ValueError("Tag only supports keys: %s" % \ (", ".join(SUPPORTED_KEYS))) - actualValue = valueDict.get(value) - if actualValue is None: + actual_value = value_dict.get(value) + if actual_value is None: raise ValueError("Key %s only supports values: %s" % \ - (key, ", ".join(valueDict))) - stateParts.append("%s = %s" % (key, actualValue)) - sql = "alter session set %s" % " ".join(stateParts) + (key, ", ".join(value_dict))) + state_parts.append("%s = %s" % (key, actual_value)) + sql = "alter session set %s" % " ".join(state_parts) cursor = conn.cursor() cursor.execute(sql) @@ -78,11 +78,11 @@ def init_session(conn, requested_tag): # create pool with session callback defined -pool = cx_Oracle.SessionPool(user=sample_env.get_main_user(), - password=sample_env.get_main_password(), - dsn=sample_env.get_connect_string(), min=2, max=5, - increment=1, threaded=True, - session_callback=init_session) +pool = oracledb.SessionPool(user=sample_env.get_main_user(), + password=sample_env.get_main_password(), + dsn=sample_env.get_connect_string(), min=2, max=5, + increment=1, threaded=True, + session_callback=init_session) # acquire session without specifying a tag; since the session returned is # newly created, the callback will be invoked but since there is no tag diff --git a/samples/session_callback_plsql.py b/samples/session_callback_plsql.py index 539a86d..1656698 100644 --- a/samples/session_callback_plsql.py +++ b/samples/session_callback_plsql.py @@ -22,15 +22,15 @@ # #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env # create pool with session callback defined -pool = cx_Oracle.SessionPool(user=sample_env.get_main_user(), - password=sample_env.get_main_password(), - dsn=sample_env.get_connect_string(), min=2, max=5, - increment=1, threaded=True, - session_callback="pkg_SessionCallback.TheCallback") +pool = oracledb.SessionPool(user=sample_env.get_main_user(), + password=sample_env.get_main_password(), + dsn=sample_env.get_connect_string(), min=2, max=5, + increment=1, threaded=True, + session_callback="pkg_SessionCallback.TheCallback") # truncate table logging calls to PL/SQL session callback with pool.acquire() as conn: diff --git a/samples/setup_samples.py b/samples/setup_samples.py index c0ee4a7..6baa4e9 100644 --- a/samples/setup_samples.py +++ b/samples/setup_samples.py @@ -10,13 +10,13 @@ # demonstration of PL/SQL editioning. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env import drop_samples # connect as administrative user (usually SYSTEM or ADMIN) -conn = cx_Oracle.connect(sample_env.get_admin_connect_string()) +conn = oracledb.connect(sample_env.get_admin_connect_string()) # drop existing users and editions, if applicable drop_samples.drop_samples(conn) diff --git a/samples/sharding_number_key.py b/samples/sharding_number_key.py index 76821c3..a71ac1a 100644 --- a/samples/sharding_number_key.py +++ b/samples/sharding_number_key.py @@ -15,13 +15,13 @@ # sharding capabilities. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -pool = cx_Oracle.SessionPool(user=sample_env.get_main_user(), - password=sample_env.get_main_password(), - dsn=sample_env.get_connect_string(), min=1, max=5, - increment=1) +pool = oracledb.SessionPool(user=sample_env.get_main_user(), + password=sample_env.get_main_password(), + dsn=sample_env.get_connect_string(), min=1, max=5, + increment=1) def connect_and_display(sharding_key): print("Connecting with sharding key:", sharding_key) diff --git a/samples/soda_basic.py b/samples/soda_basic.py index 1ef0db5..a04713a 100644 --- a/samples/soda_basic.py +++ b/samples/soda_basic.py @@ -12,10 +12,10 @@ # The user must have been granted the SODA_APP privilege. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) # The general recommendation for simple SODA usage is to enable autocommit connection.autocommit = True diff --git a/samples/soda_bulk_insert.py b/samples/soda_bulk_insert.py index 01b3ff1..714276a 100644 --- a/samples/soda_bulk_insert.py +++ b/samples/soda_bulk_insert.py @@ -12,10 +12,10 @@ # The user must have been granted the SODA_APP privilege. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) # the general recommendation for simple SODA usage is to enable autocommit connection.autocommit = True diff --git a/samples/spatial_to_geopandas.py b/samples/spatial_to_geopandas.py index efe0b80..1652e12 100644 --- a/samples/spatial_to_geopandas.py +++ b/samples/spatial_to_geopandas.py @@ -22,13 +22,14 @@ # dependencies (see http://geopandas.org/install.html). #------------------------------------------------------------------------------ -import sample_env -import cx_Oracle from shapely.wkb import loads import geopandas as gpd +import cx_Oracle as oracledb +import sample_env + # create Oracle connection and cursor objects -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() # enable autocommit to avoid the additional round trip to the database to @@ -39,8 +40,8 @@ connection.autocommit = True # define output type handler to fetch LOBs, avoiding the second round trip to # the database to read the LOB contents def output_type_handler(cursor, name, default_type, size, precision, scale): - if default_type == cx_Oracle.BLOB: - return cursor.var(cx_Oracle.LONG_BINARY, arraysize=cursor.arraysize) + if default_type == oracledb.BLOB: + return cursor.var(oracledb.LONG_BINARY, arraysize=cursor.arraysize) connection.outputtypehandler = output_type_handler # drop and create table diff --git a/samples/subclassing.py b/samples/subclassing.py index 6d74516..13288bc 100644 --- a/samples/subclassing.py +++ b/samples/subclassing.py @@ -10,18 +10,18 @@ # for paticular applications. #------------------------------------------------------------------------------ -import cx_Oracle +import cx_Oracle as oracledb import sample_env # sample subclassed connection which overrides the constructor (so no # parameters are required) and the cursor() method (so that the subclassed # cursor is returned instead of the default cursor implementation) -class Connection(cx_Oracle.Connection): +class Connection(oracledb.Connection): def __init__(self): connect_string = sample_env.get_main_connect_string() print("CONNECT to database") - return super(Connection, self).__init__(connect_string) + super().__init__(connect_string) def cursor(self): return Cursor(self) @@ -29,18 +29,18 @@ class Connection(cx_Oracle.Connection): # sample subclassed cursor which overrides the execute() and fetchone() # methods in order to perform some simple logging -class Cursor(cx_Oracle.Cursor): +class Cursor(oracledb.Cursor): def execute(self, statement, args): print("EXECUTE", statement) print("ARGS:") for arg_index, arg in enumerate(args): print(" ", arg_index + 1, "=>", repr(arg)) - return super(Cursor, self).execute(statement, args) + return super().execute(statement, args) def fetchone(self): print("FETCH ONE") - return super(Cursor, self).fetchone() + return super().fetchone() # create instances of the subclassed connection and cursor diff --git a/samples/transaction_guard.py b/samples/transaction_guard.py index 822c399..a9c8d36 100644 --- a/samples/transaction_guard.py +++ b/samples/transaction_guard.py @@ -33,17 +33,18 @@ # This script requires cx_Oracle 5.3 and higher. #------------------------------------------------------------------------------ -import cx_Oracle -import sample_env import sys +import cx_Oracle as oracledb +import sample_env + # constants CONNECT_STRING = "localhost/orcl-tg" # create transaction and generate a recoverable error -pool = cx_Oracle.SessionPool(user=sample_env.get_main_user(), - password=sample_env.get_main_password(), - dsn=CONNECT_STRING, min=1, max=9, increment=2) +pool = oracledb.SessionPool(user=sample_env.get_main_user(), + password=sample_env.get_main_password(), + dsn=CONNECT_STRING, min=1, max=9, increment=2) connection = pool.acquire() cursor = connection.cursor() cursor.execute(""" @@ -57,7 +58,7 @@ input("Please kill %s session now. Press ENTER when complete." % \ try: connection.commit() # this should fail sys.exit("Session was not killed. Terminating.") -except cx_Oracle.DatabaseError as e: +except oracledb.DatabaseError as e: errorObj, = e.args if not errorObj.isrecoverable: sys.exit("Session is not recoverable. Terminating.") @@ -69,7 +70,7 @@ pool.drop(connection) # check if previous transaction completed connection = pool.acquire() cursor = connection.cursor() -args = (cx_Oracle.Binary(ltxid), cursor.var(bool), cursor.var(bool)) +args = (oracledb.Binary(ltxid), cursor.var(bool), cursor.var(bool)) _, committed, completed = cursor.callproc("dbms_app_cont.get_ltxid_outcome", args) print("Failed transaction was committed:", committed) diff --git a/samples/type_handlers.py b/samples/type_handlers.py index 830fc01..e14ec0b 100644 --- a/samples/type_handlers.py +++ b/samples/type_handlers.py @@ -17,20 +17,21 @@ # This script requires cx_Oracle 5.0 and higher. #------------------------------------------------------------------------------ -import cx_Oracle import datetime + +import cx_Oracle as oracledb import sample_env -con = cx_Oracle.connect(sample_env.get_main_connect_string()) +con = oracledb.connect(sample_env.get_main_connect_string()) obj_type = con.gettype("UDT_BUILDING") -class Building(object): +class Building: - def __init__(self, building_id, description, num_floors, dateBuilt): + def __init__(self, building_id, description, num_floors, date_built): self.building_id = building_id self.description = description self.num_floors = num_floors - self.dateBuilt = dateBuilt + self.date_built = date_built def __repr__(self): return "" % (self.building_id, self.description) @@ -41,7 +42,7 @@ def building_in_converter(value): obj.BUILDINGID = value.building_id obj.DESCRIPTION = value.description obj.NUMFLOORS = value.num_floors - obj.DATEBUILT = value.dateBuilt + obj.DATEBUILT = value.date_built return obj @@ -50,14 +51,14 @@ def building_out_converter(obj): obj.DATEBUILT) -def input_type_handler(cursor, value, numElements): +def input_type_handler(cursor, value, num_elements): if isinstance(value, Building): - return cursor.var(cx_Oracle.OBJECT, arraysize=numElements, + return cursor.var(oracledb.OBJECT, arraysize=num_elements, inconverter=building_in_converter, typename=obj_type.name) def output_type_handler(cursor, name, default_type, size, precision, scale): - if default_type == cx_Oracle.OBJECT: - return cursor.var(cx_Oracle.OBJECT, arraysize=cursor.arraysize, + if default_type == oracledb.OBJECT: + return cursor.var(oracledb.OBJECT, arraysize=cursor.arraysize, outconverter=building_out_converter, typename=obj_type.name) @@ -73,7 +74,7 @@ for building in buildings: try: cur.execute("insert into TestBuildings values (:1, :2)", (building.building_id, building)) - except cx_Oracle.DatabaseError as e: + except oracledb.DatabaseError as e: error, = e.args print("CONTEXT:", error.context) print("MESSAGE:", error.message) diff --git a/samples/universal_rowids.py b/samples/universal_rowids.py index 4546362..f8c5d0e 100644 --- a/samples/universal_rowids.py +++ b/samples/universal_rowids.py @@ -15,8 +15,9 @@ # This script requires cx_Oracle 6.0 and higher. #------------------------------------------------------------------------------ -import cx_Oracle import datetime + +import cx_Oracle as oracledb import sample_env DATA = [ @@ -26,7 +27,7 @@ DATA = [ ] # truncate table so sample can be rerun -connection = cx_Oracle.connect(sample_env.get_main_connect_string()) +connection = oracledb.connect(sample_env.get_main_connect_string()) cursor = connection.cursor() print("Truncating table...") cursor.execute("truncate table TestUniversalRowids")