def test_1122_connection_attributes(self):
"1122 - test connection attribute values"
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
encoding="ASCII")
self.assertEqual(connection.maxBytesPerCharacter, 1)
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
encoding="UTF-8")
self.assertEqual(connection.maxBytesPerCharacter, 4)
if test_env.get_client_version() >= (12, 1):
self.assertEqual(connection.ltxid, b'')
self.assertEqual(connection.current_schema, None)
connection.current_schema = "test_schema"
self.assertEqual(connection.current_schema, "test_schema")
self.assertEqual(connection.edition, None)
connection.external_name = "test_external"
self.assertEqual(connection.external_name, "test_external")
connection.internal_name = "test_internal"
self.assertEqual(connection.internal_name, "test_internal")
connection.stmtcachesize = 30
self.assertEqual(connection.stmtcachesize, 30)
self.assertRaises(TypeError, connection.stmtcachesize, 20.5)
self.assertRaises(TypeError, connection.stmtcachesize, "value")
def test_2412_tagging_invalid_key(self):
"2412 - testTagging with Invalid key"
pool = test_env.get_pool(getmode=oracledb.SPOOL_ATTRVAL_NOWAIT)
conn = pool.acquire()
self.assertRaises(TypeError, pool.release, conn, tag=12345)
if test_env.get_client_version() >= (12, 2):
self.assertRaises(oracledb.DatabaseError, pool.release, conn,
tag="INVALID_TAG")
def test_2400_pool(self):
"2400 - test that the pool is created and has the right attributes"
pool = test_env.get_pool(min=2, max=8, increment=3,
getmode=oracledb.SPOOL_ATTRVAL_WAIT)
self.assertEqual(pool.username, test_env.get_main_user(),
"user name differs")
self.assertEqual(pool.tnsentry, test_env.get_connect_string(),
"tnsentry differs")
self.assertEqual(pool.dsn, test_env.get_connect_string(),
"dsn differs")
self.assertEqual(pool.max, 8, "max differs")
self.assertEqual(pool.min, 2, "min differs")
self.assertEqual(pool.increment, 3, "increment differs")
self.assertEqual(pool.opened, 2, "opened differs")
self.assertEqual(pool.busy, 0, "busy not 0 at start")
connection_1 = pool.acquire()
self.assertEqual(pool.busy, 1, "busy not 1 after acquire")
self.assertEqual(pool.opened, 2, "opened not unchanged (1)")
connection_2 = pool.acquire()
self.assertEqual(pool.busy, 2, "busy not 2 after acquire")
self.assertEqual(pool.opened, 2, "opened not unchanged (2)")
connection_3 = pool.acquire()
self.assertEqual(pool.busy, 3, "busy not 3 after acquire")
self.assertEqual(pool.opened, 5, "opened not changed (3)")
pool.release(connection_3)
self.assertEqual(pool.busy, 2, "busy not 2 after release")
del connection_2
self.assertEqual(pool.busy, 1, "busy not 1 after del")
pool.getmode = oracledb.SPOOL_ATTRVAL_NOWAIT
self.assertEqual(pool.getmode, oracledb.SPOOL_ATTRVAL_NOWAIT)
if test_env.get_client_version() >= (12, 2):
pool.getmode = oracledb.SPOOL_ATTRVAL_TIMEDWAIT
self.assertEqual(pool.getmode, oracledb.SPOOL_ATTRVAL_TIMEDWAIT)
pool.stmtcachesize = 50
self.assertEqual(pool.stmtcachesize, 50)
pool.timeout = 10
self.assertEqual(pool.timeout, 10)
if test_env.get_client_version() >= (12, 1):
pool.max_lifetime_session = 10
self.assertEqual(pool.max_lifetime_session, 10)
def test_1123_closed_connection_attributes(self):
"1123 - test closed connection attribute values"
connection = test_env.get_connection()
connection.close()
attr_names = [
"current_schema", "edition", "external_name", "internal_name",
"stmtcachesize"
]
if test_env.get_client_version() >= (12, 1):
attr_names.append("ltxid")
for name in attr_names:
self.assertRaises(oracledb.InterfaceError, getattr, connection,
name)
def test_1103_attributes(self):
"1103 - test connection end-to-end tracing attributes"
connection = test_env.get_connection()
if test_env.get_client_version() >= (12, 1) \
and not self.is_on_oracle_cloud(connection):
sql = "select dbop_name from v$sql_monitor " \
"where sid = sys_context('userenv', 'sid')" \
"and status = 'EXECUTING'"
self.__verify_attributes(connection, "dbop", "oracledb_dbop", sql)
sql = "select sys_context('userenv', 'action') from dual"
self.__verify_attributes(connection, "action", "oracledb_Action", sql)
sql = "select sys_context('userenv', 'module') from dual"
self.__verify_attributes(connection, "module", "oracledb_Module", sql)
sql = "select sys_context('userenv', 'client_info') from dual"
self.__verify_attributes(connection, "clientinfo", "oracledb_cinfo",
sql)
sql = "select sys_context('userenv', 'client_identifier') from dual"
self.__verify_attributes(connection, "client_identifier",
"oracledb_cid", sql)
def test_2411_plsql_session_callbacks(self):
"2411 - test PL/SQL session callbacks"
if test_env.get_client_version() < (12, 2):
self.skipTest("PL/SQL session callbacks not supported before 12.2")
callback = "pkg_SessionCallback.TheCallback"
pool = test_env.get_pool(min=2,
max=8,
increment=3,
getmode=oracledb.SPOOL_ATTRVAL_NOWAIT,
session_callback=callback)
tags = [
"NLS_DATE_FORMAT=SIMPLE", "NLS_DATE_FORMAT=FULL;TIME_ZONE=UTC",
"NLS_DATE_FORMAT=FULL;TIME_ZONE=MST"
]
actual_tags = [None, None, "NLS_DATE_FORMAT=FULL;TIME_ZONE=UTC"]
# truncate PL/SQL session callback log
conn = pool.acquire()
cursor = conn.cursor()
cursor.execute("truncate table PLSQLSessionCallbacks")
conn.close()
# request sessions with each of the first two tags
for tag in tags[:2]:
conn = pool.acquire(tag=tag)
conn.close()
# for the last tag, use the matchanytag flag
conn = pool.acquire(tag=tags[2], matchanytag=True)
conn.close()
# verify the PL/SQL session callback log is accurate
conn = pool.acquire()
cursor = conn.cursor()
cursor.execute("""
select RequestedTag, ActualTag
from PLSQLSessionCallbacks
order by FixupTimestamp""")
results = cursor.fetchall()
expected_results = list(zip(tags, actual_tags))
self.assertEqual(results, expected_results)
conn.close()
class TestCase(test_env.BaseTestCase):
def __test_skip(self, coll, num_to_skip, expected_content):
filter_spec = {'$orderby': [{'path': 'name', 'order': 'desc'}]}
doc = coll.find().filter(filter_spec).skip(num_to_skip).getOne()
content = doc.getContent() if doc is not None else None
self.assertEqual(content, expected_content)
def test_3400_invalid_json(self):
"3400 - test inserting invalid JSON value into SODA collection"
invalid_json = "{testKey:testValue}"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("InvalidJSON")
doc = soda_db.createDocument(invalid_json)
self.assertRaises(oracledb.DatabaseError, coll.insertOne, doc)
coll.drop()
def test_3401_insert_documents(self):
"3401 - test inserting documents into a SODA collection"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoInsertDocs")
coll.find().remove()
values_to_insert = [
{"name": "George", "age": 47},
{"name": "Susan", "age": 39},
{"name": "John", "age": 50},
{"name": "Jill", "age": 54}
]
inserted_keys = []
for value in values_to_insert:
doc = coll.insertOneAndGet(value)
inserted_keys.append(doc.key)
self.connection.commit()
self.assertEqual(coll.find().count(), len(values_to_insert))
for key, value in zip(inserted_keys, values_to_insert):
doc = coll.find().key(key).getOne()
self.assertEqual(doc.getContent(), value)
coll.drop()
def test_3402_skip_documents(self):
"3402 - test skipping documents in a SODA collection"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoSkipDocs")
coll.find().remove()
values_to_insert = [
{"name": "Anna", "age": 62},
{"name": "Mark", "age": 37},
{"name": "Martha", "age": 43},
{"name": "Matthew", "age": 28}
]
for value in values_to_insert:
coll.insertOne(value)
self.connection.commit()
self.__test_skip(coll, 0, values_to_insert[3])
self.__test_skip(coll, 1, values_to_insert[2])
self.__test_skip(coll, 3, values_to_insert[0])
self.__test_skip(coll, 4, None)
self.__test_skip(coll, 125, None)
def test_3403_replace_document(self):
"3403 - test replace documents in SODA collection"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoReplaceDoc")
coll.find().remove()
content = {'name': 'John', 'address': {'city': 'Sydney'}}
doc = coll.insertOneAndGet(content)
new_content = {'name': 'John', 'address': {'city':'Melbourne'}}
coll.find().key(doc.key).replaceOne(new_content)
self.connection.commit()
self.assertEqual(coll.find().key(doc.key).getOne().getContent(),
new_content)
coll.drop()
def test_3404_search_documents_with_content(self):
"3404 - test search documents with content using $like and $regex"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoSearchDocContent")
coll.find().remove()
data = [
{'name': 'John', 'address': {'city': 'Bangalore'}},
{'name': 'Johnson', 'address': {'city': 'Banaras'}},
{'name': 'Joseph', 'address': {'city': 'Bangalore'}},
{'name': 'Jibin', 'address': {'city': 'Secunderabad'}},
{'name': 'Andrew', 'address': {'city': 'Hyderabad'}},
{'name': 'Matthew', 'address': {'city': 'Mumbai'}}
]
for value in data:
coll.insertOne(value)
self.connection.commit()
filter_specs = [
({'name': {'$like': 'And%'}}, 1),
({'name': {'$like': 'J%n'}}, 3),
({'name': {'$like': '%hn%'}}, 2),
({'address.city': {'$like': 'Ban%'}}, 3),
({'address.city': {'$like': '%bad'}}, 2),
({'address.city': {'$like': 'Hyderabad'}}, 1),
({'address.city': {'$like': 'China%'}}, 0),
({'name': {'$regex': 'Jo.*'}}, 3),
({'name': {'$regex': '.*[ho]n'}}, 2),
({'name': {'$regex': 'J.*h'}}, 1),
({'address.city': {'$regex': 'Ba.*'}}, 3),
({'address.city': {'$regex': '.*bad'}}, 2),
({'address.city': {'$regex': 'Hyderabad'}}, 1),
({'name': {'$regex': 'Js.*n'}}, 0)
]
for filter_spec, expected_count in filter_specs:
self.assertEqual(coll.find().filter(filter_spec).count(),
expected_count, filter_spec)
coll.drop()
def test_3405_document_remove(self):
"3405 - test removing documents"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoRemoveDocs")
coll.find().remove()
data = [
{'name': 'John', 'address': {'city': 'Bangalore'}},
{'name': 'Johnson', 'address': {'city': 'Banaras'}},
{'name': 'Joseph', 'address': {'city': 'Mangalore'}},
{'name': 'Jibin', 'address': {'city': 'Secunderabad'}},
{'name': 'Andrew', 'address': {'city': 'Hyderabad'}},
{'name': 'Matthew', 'address': {'city': 'Mumbai'}}
]
docs = [coll.insertOneAndGet(v) for v in data]
coll.find().key(docs[3].key).remove()
self.assertEqual(coll.find().count(), len(data) - 1)
searchResults = coll.find().filter({'name': {'$like': 'Jibin'}})
self.assertEqual(searchResults.count(), 0)
coll.find().filter({'name': {'$like': 'John%'}}).remove()
self.assertEqual(coll.find().count(), len(data) - 3)
coll.find().filter({'name': {'$regex': 'J.*'}}).remove()
self.assertEqual(coll.find().count(), len(data) - 4)
self.connection.commit()
coll.drop()
def test_3406_create_and_drop_index(self):
"3406 - test create and drop Index"
index_name = "cxoTestIndexes_ix_1"
index_spec = {
'name': index_name,
'fields': [
{
'path': 'address.city',
'datatype': 'string',
'order': 'asc'
}
]
}
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("TestIndexes")
coll.find().remove()
self.connection.commit()
coll.dropIndex(index_name)
coll.createIndex(index_spec)
self.assertRaises(oracledb.DatabaseError, coll.createIndex, index_spec)
self.assertEqual(coll.dropIndex(index_name), True)
self.assertEqual(coll.dropIndex(index_name), False)
coll.drop()
def test_3407_get_documents(self):
"3407 - test getting documents from Collection"
self.connection.autocommit = True
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoTestGetDocs")
coll.find().remove()
data = [
{'name': 'John', 'address': {'city': 'Bangalore'}},
{'name': 'Johnson', 'address': {'city': 'Banaras'}},
{'name': 'Joseph', 'address': {'city': 'Mangalore'}},
{'name': 'Jibin', 'address': {'city': 'Secunderabad'}},
{'name': 'Andrew', 'address': {'city': 'Hyderabad'}}
]
inserted_keys = list(sorted(coll.insertOneAndGet(v).key for v in data))
fetched_keys = list(sorted(d.key for d in coll.find().getDocuments()))
self.assertEqual(fetched_keys, inserted_keys)
coll.drop()
def test_3408_cursor(self):
"3408 - test fetching documents from a cursor"
self.connection.autocommit = True
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoFindViaCursor")
coll.find().remove()
data = [
{'name': 'John', 'address': {'city': 'Bangalore'}},
{'name': 'Johnson', 'address': {'city': 'Banaras'}},
{'name': 'Joseph', 'address': {'city': 'Mangalore'}},
]
inserted_keys = list(sorted(coll.insertOneAndGet(v).key for v in data))
fetched_keys = list(sorted(d.key for d in coll.find().getCursor()))
self.assertEqual(fetched_keys, inserted_keys)
coll.drop()
def test_3409_multiple_document_remove(self):
"3409 - test removing multiple documents using multiple keys"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoRemoveMultipleDocs")
coll.find().remove()
data = [
{'name': 'John', 'address': {'city': 'Bangalore'}},
{'name': 'Johnson', 'address': {'city': 'Banaras'}},
{'name': 'Joseph', 'address': {'city': 'Mangalore'}},
{'name': 'Jibin', 'address': {'city': 'Secunderabad'}},
{'name': 'Andrew', 'address': {'city': 'Hyderabad'}},
{'name': 'Matthew', 'address': {'city': 'Mumbai'}}
]
docs = [coll.insertOneAndGet(v) for v in data]
keys = [docs[i].key for i in (1, 3, 5)]
num_removed = coll.find().keys(keys).remove()
self.assertEqual(num_removed, len(keys))
self.assertEqual(coll.find().count(), len(data) - len(keys))
self.connection.commit()
coll.drop()
def test_3410_document_version(self):
"3410 - test using version to get documents and remove them"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoDocumentVersion")
coll.find().remove()
content = {'name': 'John', 'address': {'city': 'Bangalore'}}
inserted_doc = coll.insertOneAndGet(content)
key = inserted_doc.key
version = inserted_doc.version
doc = coll.find().key(key).version(version).getOne()
self.assertEqual(doc.getContent(), content)
new_content = {'name': 'James', 'address': {'city': 'Delhi'}}
replacedDoc = coll.find().key(key).replaceOneAndGet(new_content)
new_version = replacedDoc.version
doc = coll.find().key(key).version(version).getOne()
self.assertEqual(doc, None)
doc = coll.find().key(key).version(new_version).getOne()
self.assertEqual(doc.getContent(), new_content)
self.assertEqual(coll.find().key(key).version(version).remove(), 0)
self.assertEqual(coll.find().key(key).version(new_version).remove(), 1)
self.assertEqual(coll.find().count(), 0)
self.connection.commit()
coll.drop()
def test_3411_get_cursor(self):
"3411 - test keys with GetCursor"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoKeysWithGetCursor")
coll.find().remove()
data = [
{'name': 'John', 'address': {'city': 'Bangalore'}},
{'name': 'Johnson', 'address': {'city': 'Banaras'}},
{'name': 'Joseph', 'address': {'city': 'Mangalore'}},
{'name': 'Jibin', 'address': {'city': 'Secunderabad'}},
{'name': 'Andrew', 'address': {'city': 'Hyderabad'}},
{'name': 'Matthew', 'address': {'city': 'Mumbai'}}
]
docs = [coll.insertOneAndGet(v) for v in data]
keys = [docs[i].key for i in (2, 4, 5)]
fetched_keys = [d.key for d in coll.find().keys(keys).getCursor()]
self.assertEqual(list(sorted(fetched_keys)), list(sorted(keys)))
self.connection.commit()
coll.drop()
def test_3412_created_on(self):
"3412 - test createdOn attribute of Document"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("CreatedOn")
coll.find().remove()
data = {'name': 'John', 'address': {'city': 'Bangalore'}}
doc = coll.insertOneAndGet(data)
self.assertEqual(doc.createdOn, doc.lastModified)
@unittest.skipIf(test_env.get_client_version() < (20, 1),
"unsupported client")
def test_3413_soda_truncate(self):
"3413 - test Soda truncate"
soda_db = self.connection.getSodaDatabase()
coll = soda_db.createCollection("cxoTruncateDocs")
coll.find().remove()
values_to_insert = [
{"name": "George", "age": 47},
{"name": "Susan", "age": 39},
{"name": "John", "age": 50},
{"name": "Jill", "age": 54}
]
for value in values_to_insert:
coll.insertOne(value)
self.connection.commit()
self.assertEqual(coll.find().count(), len(values_to_insert))
coll.truncate()
self.assertEqual(coll.find().count(), 0)
coll.drop()
@unittest.skipIf(test_env.skip_client_version_old_multi((19, 11), (21, 3)),
"unsupported client")
def test_3414_soda_hint(self):
"3414 - verify hints are reflected in the executed SQL statement"
soda_db = self.connection.getSodaDatabase()
cursor = self.connection.cursor()
statement = """
SELECT
( SELECT t2.sql_fulltext
FROM v$sql t2
WHERE t2.sql_id = t1.prev_sql_id
AND t2.child_number = t1.prev_child_number
)
FROM v$session t1
WHERE t1.audsid = sys_context('userenv', 'sessionid')"""
coll = soda_db.createCollection("cxoSodaHint")
coll.find().remove()
values_to_insert = [
{"name": "George", "age": 47},
{"name": "Susan", "age": 39},
]
coll.insertOneAndGet(values_to_insert[0], hint="MONITOR")
cursor.execute(statement)
result, = cursor.fetchone()
self.assertTrue('MONITOR' in result.read())
coll.find().hint("MONITOR").getOne().getContent()
cursor.execute(statement)
result, = cursor.fetchone()
self.assertTrue('MONITOR' in result.read())
coll.insertOneAndGet(values_to_insert[1], hint="NO_MONITOR")
cursor.execute(statement)
result, = cursor.fetchone()
self.assertTrue('NO_MONITOR' in result.read())
class TestCase(test_env.BaseTestCase):
def _test_positive_set_and_get(self,
var_type,
value_to_set,
expected_value,
type_name=None):
var = self.cursor.var(var_type, typename=type_name)
var.setvalue(0, value_to_set)
result = var.getvalue()
if isinstance(result, oracledb.LOB):
result = result.read()
elif isinstance(result, oracledb.Object):
result = self.get_db_object_as_plain_object(result)
self.assertEqual(result, expected_value)
def _test_negative_set_and_get(self,
var_type,
value_to_set,
type_name=None):
var = self.cursor.var(var_type, typename=type_name)
self.assertRaises((TypeError, oracledb.DatabaseError), var.setvalue, 0,
value_to_set)
def test_3700_DB_TYPE_NUMBER(self):
"3700 - setting values on variables of type DB_TYPE_NUMBER"
self._test_positive_set_and_get(oracledb.DB_TYPE_NUMBER, 5, 5)
self._test_positive_set_and_get(oracledb.DB_TYPE_NUMBER, 3.5, 3.5)
self._test_positive_set_and_get(oracledb.DB_TYPE_NUMBER,
decimal.Decimal("24.8"), 24.8)
self._test_positive_set_and_get(oracledb.DB_TYPE_NUMBER, True, 1)
self._test_positive_set_and_get(oracledb.DB_TYPE_NUMBER, False, 0)
self._test_positive_set_and_get(oracledb.DB_TYPE_NUMBER, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_NUMBER, "abc")
def test_3701_DB_TYPE_BINARY_INTEGER(self):
"3701 - setting values on variables of type DB_TYPE_BINARY_INTEGER"
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER, 5, 5)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER, 3.5,
3)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER,
decimal.Decimal("24.8"), 24)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER, True,
1)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER, False,
0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER, None,
None)
self._test_negative_set_and_get(oracledb.DB_TYPE_BINARY_INTEGER, "abc")
def test_3702_DB_TYPE_VARCHAR(self):
"3702 - setting values on variables of type DB_TYPE_VARCHAR"
value = "A VARCHAR string"
self._test_positive_set_and_get(oracledb.DB_TYPE_VARCHAR, value, value)
value = b"A raw string for VARCHAR"
self._test_positive_set_and_get(oracledb.DB_TYPE_VARCHAR, value,
value.decode())
self._test_positive_set_and_get(oracledb.DB_TYPE_VARCHAR, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_VARCHAR, 5)
def test_3703_DB_TYPE_NVARCHAR(self):
"3703 - setting values on variables of type DB_TYPE_NVARCHAR"
value = "A NVARCHAR string"
self._test_positive_set_and_get(oracledb.DB_TYPE_NVARCHAR, value,
value)
value = b"A raw string for NVARCHAR"
self._test_positive_set_and_get(oracledb.DB_TYPE_NVARCHAR, value,
value.decode())
self._test_positive_set_and_get(oracledb.DB_TYPE_NVARCHAR, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_NVARCHAR, 5)
def test_3704_DB_TYPE_CHAR(self):
"3704 - setting values on variables of type DB_TYPE_CHAR"
value = "A CHAR string"
self._test_positive_set_and_get(oracledb.DB_TYPE_CHAR, value, value)
value = b"A raw string for CHAR"
self._test_positive_set_and_get(oracledb.DB_TYPE_CHAR, value,
value.decode())
self._test_positive_set_and_get(oracledb.DB_TYPE_CHAR, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_CHAR, 5)
def test_3705_DB_TYPE_NCHAR(self):
"3705 - setting values on variables of type DB_TYPE_NCHAR"
value = "A NCHAR string"
self._test_positive_set_and_get(oracledb.DB_TYPE_NCHAR, value, value)
value = b"A raw string for NCHAR"
self._test_positive_set_and_get(oracledb.DB_TYPE_CHAR, value,
value.decode())
self._test_positive_set_and_get(oracledb.DB_TYPE_NCHAR, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_NCHAR, 5)
def test_3706_DB_TYPE_LONG(self):
"3706 - setting values on variables of type DB_TYPE_LONG"
value = "Long Data" * 15000
self._test_positive_set_and_get(oracledb.DB_TYPE_LONG, value, value)
value = b"Raw data for LONG" * 15000
self._test_positive_set_and_get(oracledb.DB_TYPE_LONG, value,
value.decode())
self._test_positive_set_and_get(oracledb.DB_TYPE_LONG, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_LONG, 5)
def test_3707_DB_TYPE_RAW(self):
"3707 - setting values on variables of type DB_TYPE_RAW"
value = b'Raw Data'
self._test_positive_set_and_get(oracledb.DB_TYPE_RAW, value, value)
value = "String data for RAW"
self._test_positive_set_and_get(oracledb.DB_TYPE_RAW, value,
value.encode())
self._test_positive_set_and_get(oracledb.DB_TYPE_RAW, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_RAW, 5)
def test_3708_DB_TYPE_LONG_RAW(self):
"3708 - setting values on variables of type DB_TYPE_LONG_RAW"
value = b'Long Raw Data' * 15000
self._test_positive_set_and_get(oracledb.DB_TYPE_LONG_RAW, value,
value)
value = "String data for LONG RAW" * 15000
self._test_positive_set_and_get(oracledb.DB_TYPE_LONG_RAW, value,
value.encode())
self._test_positive_set_and_get(oracledb.DB_TYPE_LONG_RAW, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_LONG_RAW, 5)
def test_3709_DB_TYPE_DATE(self):
"3709 - setting values on variables of type DB_TYPE_DATE"
self._test_positive_set_and_get(oracledb.DB_TYPE_DATE,
datetime.date(2017, 5, 6),
datetime.datetime(2017, 5, 6))
value = datetime.datetime(2017, 5, 6, 9, 36, 0)
self._test_positive_set_and_get(oracledb.DB_TYPE_DATE, value, value)
self._test_positive_set_and_get(oracledb.DB_TYPE_DATE, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_DATE, 5)
def test_3710_DB_TYPE_TIMESTAMP(self):
"3710 - setting values on variables of type DB_TYPE_TIMESTAMP"
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP,
datetime.date(2017, 5, 6),
datetime.datetime(2017, 5, 6))
value = datetime.datetime(2017, 5, 6, 9, 36, 0, 300000)
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP, value,
value)
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_TIMESTAMP, 5)
def test_3711_DB_TYPE_TIMESTAMP_TZ(self):
"3711 - setting values on variables of type DB_TYPE_TIMESTAMP_TZ"
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP_TZ,
datetime.date(2017, 5, 6),
datetime.datetime(2017, 5, 6))
value = datetime.datetime(2017, 5, 6, 9, 36, 0, 300000)
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP_TZ, value,
value)
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP_TZ, None,
None)
self._test_negative_set_and_get(oracledb.DB_TYPE_TIMESTAMP_TZ, 5)
def test_3712_DB_TYPE_TIMESTAMP_LTZ(self):
"3712 - setting values on variables of type DB_TYPE_TIMESTAMP_LTZ"
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP_LTZ,
datetime.date(2017, 5, 6),
datetime.datetime(2017, 5, 6))
value = datetime.datetime(2017, 5, 6, 9, 36, 0, 300000)
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP_LTZ, value,
value)
self._test_positive_set_and_get(oracledb.DB_TYPE_TIMESTAMP_LTZ, None,
None)
self._test_negative_set_and_get(oracledb.DB_TYPE_TIMESTAMP_LTZ, 5)
def test_3713_DB_TYPE_BLOB(self):
"3713 - setting values on variables of type DB_TYPE_BLOB"
value = b'Short temp BLOB value'
temp_blob = self.connection.createlob(oracledb.DB_TYPE_BLOB)
temp_blob.write(value)
self._test_positive_set_and_get(oracledb.DB_TYPE_BLOB, temp_blob,
value)
self._test_negative_set_and_get(oracledb.DB_TYPE_CLOB, temp_blob)
self._test_negative_set_and_get(oracledb.DB_TYPE_NCLOB, temp_blob)
value = b'Short BLOB value'
self._test_positive_set_and_get(oracledb.DB_TYPE_BLOB, value, value)
self._test_positive_set_and_get(oracledb.DB_TYPE_BLOB, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_BLOB, 5)
def test_3714_DB_TYPE_CLOB(self):
"3714 - setting values on variables of type DB_TYPE_CLOB"
value = 'Short temp CLOB value'
temp_clob = self.connection.createlob(oracledb.DB_TYPE_CLOB)
temp_clob.write(value)
self._test_positive_set_and_get(oracledb.DB_TYPE_CLOB, temp_clob,
value)
self._test_negative_set_and_get(oracledb.DB_TYPE_BLOB, temp_clob)
self._test_negative_set_and_get(oracledb.DB_TYPE_NCLOB, temp_clob)
value = 'Short CLOB value'
self._test_positive_set_and_get(oracledb.DB_TYPE_CLOB, value, value)
self._test_positive_set_and_get(oracledb.DB_TYPE_CLOB, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_CLOB, 5)
def test_3715_DB_TYPE_NCLOB(self):
"3715 - setting values on variables of type DB_TYPE_NCLOB"
value = 'Short temp NCLOB value'
temp_nclob = self.connection.createlob(oracledb.DB_TYPE_NCLOB)
temp_nclob.write(value)
self._test_positive_set_and_get(oracledb.DB_TYPE_NCLOB, temp_nclob,
value)
self._test_negative_set_and_get(oracledb.DB_TYPE_BLOB, temp_nclob)
self._test_negative_set_and_get(oracledb.DB_TYPE_CLOB, temp_nclob)
value = 'Short NCLOB Value'
self._test_positive_set_and_get(oracledb.DB_TYPE_NCLOB, value, value)
self._test_positive_set_and_get(oracledb.DB_TYPE_NCLOB, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_NCLOB, 5)
def test_3716_DB_TYPE_BINARY_FLOAT(self):
"3716 - setting values on variables of type DB_TYPE_BINARY_FLOAT"
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT, 5, 5.0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT, 3.5,
3.5)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT,
decimal.Decimal("24.5"), 24.5)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT, True,
1.0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT, False,
0.0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT, None,
None)
self._test_negative_set_and_get(oracledb.DB_TYPE_BINARY_FLOAT, "abc")
def test_3717_DB_TYPE_BINARY_DOUBLE(self):
"3717 - setting values on variables of type DB_TYPE_BINARY_DOUBLE"
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE, 5, 5.0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE, 3.5,
3.5)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE,
decimal.Decimal("192.125"), 192.125)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE, True,
1.0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE, False,
0.0)
self._test_positive_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE, None,
None)
self._test_negative_set_and_get(oracledb.DB_TYPE_BINARY_DOUBLE, "abc")
def test_3718_DB_TYPE_BOOLEAN(self):
"3718 - setting values on variables of type DB_TYPE_BOOLEAN"
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN, 5, True)
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN, 2.0, True)
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN, "abc", True)
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN,
decimal.Decimal("24.8"), True)
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN, 0.0, False)
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN, 0, False)
self._test_positive_set_and_get(oracledb.DB_TYPE_BOOLEAN, None, None)
def test_3719_DB_TYPE_INTERVAL_DS(self):
"3719 - setting values on variables of type DB_TYPE_INTERVAL_DS"
value = datetime.timedelta(days=5, seconds=56000, microseconds=123780)
self._test_positive_set_and_get(oracledb.DB_TYPE_INTERVAL_DS, value,
value)
self._test_positive_set_and_get(oracledb.DB_TYPE_INTERVAL_DS, None,
None)
self._test_negative_set_and_get(oracledb.DB_TYPE_INTERVAL_DS, 5)
def test_3720_DB_TYPE_ROWID(self):
"3720 - setting values on variables of type DB_TYPE_ROWID"
self._test_negative_set_and_get(oracledb.DB_TYPE_ROWID, 12345)
self._test_negative_set_and_get(oracledb.DB_TYPE_ROWID, "523lkhlf")
def test_3721_DB_TYPE_OBJECT(self):
"3721 - setting values on variables of type DB_TYPE_OBJECT"
obj_type = self.connection.gettype("UDT_OBJECT")
obj = obj_type.newobject()
plain_obj = self.get_db_object_as_plain_object(obj)
self._test_positive_set_and_get(oracledb.DB_TYPE_OBJECT, obj,
plain_obj, "UDT_OBJECT")
self._test_positive_set_and_get(obj_type, obj, plain_obj)
self._test_positive_set_and_get(oracledb.DB_TYPE_OBJECT, None, None,
"UDT_OBJECT")
self._test_positive_set_and_get(obj_type, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_OBJECT, "abc",
"UDT_OBJECT")
self._test_negative_set_and_get(oracledb.DB_TYPE_OBJECT, obj,
"UDT_OBJECTARRAY")
wrong_obj_type = self.connection.gettype("UDT_OBJECTARRAY")
self._test_negative_set_and_get(wrong_obj_type, obj)
@unittest.skipIf(test_env.get_client_version() < (21, 0),
"unsupported client")
@unittest.skipIf(test_env.get_server_version() < (21, 0),
"unsupported server")
def test_3722_DB_TYPE_JSON(self):
"3722 - setting values on variables of type DB_TYPE_JSON"
json_data = [
5, 25.25,
decimal.Decimal("10.25"), True, False,
datetime.datetime(2017, 5, 6),
datetime.datetime(2017, 5, 6, 9, 36, 0, 300000),
datetime.timedelta(days=5, seconds=56000, microseconds=123780), {},
'String', b'Some bytes', {
'keyA': 1,
'KeyB': 'Melbourne'
}, [], [1, "A"], {
"name": None
}, {
"name": "John"
}, {
"age": 30
}, {
"Permanent": True
}, {
"employee": {
"name": "John",
"age": 30,
"city": "Delhi",
"Parmanent": True
}
}, {
"employees": ["John", "Matthew", "James"]
}, {
"employees": [{
"employee1": {
"name": "John",
"city": "Delhi"
}
}, {
"employee2": {
"name": "Matthew",
"city": "Mumbai"
}
}, {
"employee3": {
"name": "James",
"city": "Bangalore"
}
}]
}
]
self._test_positive_set_and_get(oracledb.DB_TYPE_JSON, json_data,
json_data)
self._test_positive_set_and_get(oracledb.DB_TYPE_JSON, None, None)
def test_3723_DB_TYPE_CURSOR(self):
"3723 - test setting values on variables of type DB_TYPE_CURSOR"
cursor = self.connection.cursor()
var = self.cursor.var(oracledb.DB_TYPE_CURSOR)
var.setvalue(0, cursor)
self._test_positive_set_and_get(oracledb.DB_TYPE_CURSOR, None, None)
self._test_negative_set_and_get(oracledb.DB_TYPE_CURSOR, 5)
#
# Portions Copyright 2001-2007, Computronix (Canada) Ltd., Edmonton, Alberta,
# Canada. All rights reserved.
#------------------------------------------------------------------------------
"""
3200 - Module for testing features introduced in 12.1
"""
import datetime
import unittest
import cx_Oracle as oracledb
import test_env
@unittest.skipUnless(test_env.get_client_version() >= (12, 1),
"unsupported client")
class TestCase(test_env.BaseTestCase):
def test_3200_array_dml_row_counts_off(self):
"3200 - test executing with arraydmlrowcounts mode disabled"
self.cursor.execute("truncate table TestArrayDML")
rows = [(1, "First"), (2, "Second")]
sql = "insert into TestArrayDML (IntCol,StringCol) values (:1,:2)"
self.cursor.executemany(sql, rows, arraydmlrowcounts=False)
self.assertRaises(oracledb.DatabaseError,
self.cursor.getarraydmlrowcounts)
rows = [(3, "Third"), (4, "Fourth")]
self.cursor.executemany(sql, rows)
self.assertRaises(oracledb.DatabaseError,
self.cursor.getarraydmlrowcounts)
class TestCase(test_env.BaseTestCase):
requires_connection = False
def __connect_and_drop(self):
"""Connect to the database, perform a query and drop the connection."""
connection = test_env.get_connection(threaded=True)
cursor = connection.cursor()
cursor.execute("select count(*) from TestNumbers")
count, = cursor.fetchone()
self.assertEqual(count, 10)
def __verify_fetched_data(self, connection):
expected_data = [f"String {i + 1}" for i in range(10)]
sql = "select StringCol from TestStrings order by IntCol"
for i in range(5):
with connection.cursor() as cursor:
fetched_data = [s for s, in cursor.execute(sql)]
self.assertEqual(fetched_data, expected_data)
def __verify_args(self, connection):
self.assertEqual(connection.username, test_env.get_main_user(),
"user name differs")
self.assertEqual(connection.tnsentry, test_env.get_connect_string(),
"tnsentry differs")
self.assertEqual(connection.dsn, test_env.get_connect_string(),
"dsn differs")
def __verify_attributes(self, connection, attrName, value, sql):
setattr(connection, attrName, value)
cursor = connection.cursor()
cursor.execute(sql)
result, = cursor.fetchone()
self.assertEqual(result, value, "%s value mismatch" % attrName)
def test_1100_all_args(self):
"1100 - connection to database with user, password, TNS separate"
connection = test_env.get_connection()
self.__verify_args(connection)
def test_1101_app_context(self):
"1101 - test use of application context"
namespace = "CLIENTCONTEXT"
app_context_entries = [(namespace, "ATTR1", "VALUE1"),
(namespace, "ATTR2", "VALUE2"),
(namespace, "ATTR3", "VALUE3")]
connection = test_env.get_connection(appcontext=app_context_entries)
cursor = connection.cursor()
for namespace, name, value in app_context_entries:
cursor.execute("select sys_context(:1, :2) from dual",
(namespace, name))
actual_value, = cursor.fetchone()
self.assertEqual(actual_value, value)
def test_1102_app_context_negative(self):
"1102 - test invalid use of application context"
self.assertRaises(TypeError,
oracledb.connect,
user=test_env.get_main_user(),
password=test_env.get_main_password(),
dsn=test_env.get_connect_string(),
appcontext=[('userenv', 'action')])
def test_1103_attributes(self):
"1103 - test connection end-to-end tracing attributes"
connection = test_env.get_connection()
if test_env.get_client_version() >= (12, 1) \
and not self.is_on_oracle_cloud(connection):
sql = "select dbop_name from v$sql_monitor " \
"where sid = sys_context('userenv', 'sid')" \
"and status = 'EXECUTING'"
self.__verify_attributes(connection, "dbop", "oracledb_dbop", sql)
sql = "select sys_context('userenv', 'action') from dual"
self.__verify_attributes(connection, "action", "oracledb_Action", sql)
sql = "select sys_context('userenv', 'module') from dual"
self.__verify_attributes(connection, "module", "oracledb_Module", sql)
sql = "select sys_context('userenv', 'client_info') from dual"
self.__verify_attributes(connection, "clientinfo", "oracledb_cinfo",
sql)
sql = "select sys_context('userenv', 'client_identifier') from dual"
self.__verify_attributes(connection, "client_identifier",
"oracledb_cid", sql)
def test_1104_autocommit(self):
"1104 - test use of autocommit"
connection = test_env.get_connection()
cursor = connection.cursor()
other_connection = test_env.get_connection()
other_cursor = other_connection.cursor()
cursor.execute("truncate table TestTempTable")
cursor.execute("insert into TestTempTable (IntCol) values (1)")
other_cursor.execute("select IntCol from TestTempTable")
rows = other_cursor.fetchall()
self.assertEqual(rows, [])
connection.autocommit = True
cursor.execute("insert into TestTempTable (IntCol) values (2)")
other_cursor.execute(
"select IntCol from TestTempTable order by IntCol")
rows = other_cursor.fetchall()
self.assertEqual(rows, [(1, ), (2, )])
def test_1105_bad_connect_string(self):
"1105 - connection to database with bad connect string"
self.assertRaises(oracledb.DatabaseError, oracledb.connect,
test_env.get_main_user())
self.assertRaises(oracledb.DatabaseError, oracledb.connect,
test_env.get_main_user() + "@" + \
test_env.get_connect_string())
self.assertRaises(oracledb.DatabaseError, oracledb.connect,
test_env.get_main_user() + "@" + \
test_env.get_connect_string() + "/" + \
test_env.get_main_password())
def test_1106_bad_password(self):
"1106 - connection to database with bad password"
self.assertRaises(oracledb.DatabaseError,
oracledb.connect,
user=test_env.get_main_user(),
password=test_env.get_main_password() + "X",
dsn=test_env.get_connect_string())
def test_1107_change_password(self):
"1107 - test changing password"
connection = test_env.get_connection()
if self.is_on_oracle_cloud(connection):
self.skipTest("passwords on Oracle Cloud are strictly controlled")
sys_random = random.SystemRandom()
new_password = "".join(sys_random.choice(string.ascii_letters) \
for i in range(20))
connection.changepassword(test_env.get_main_password(), new_password)
connection = oracledb.connect(dsn=test_env.get_connect_string(),
user=test_env.get_main_user(),
password=new_password)
connection.changepassword(new_password, test_env.get_main_password())
def test_1108_change_password_negative(self):
"1108 - test changing password to an invalid value"
connection = test_env.get_connection()
if self.is_on_oracle_cloud(connection):
self.skipTest("passwords on Oracle Cloud are strictly controlled")
new_password = "******" * 150
self.assertRaises(oracledb.DatabaseError, connection.changepassword,
test_env.get_main_password(), new_password)
def test_1109_parse_password(self):
"1109 - test connecting with password containing / and @ symbols"
connection = test_env.get_connection()
if self.is_on_oracle_cloud(connection):
self.skipTest("passwords on Oracle Cloud are strictly controlled")
sys_random = random.SystemRandom()
chars = list(
sys_random.choice(string.ascii_letters) for i in range(20))
chars[4] = "/"
chars[8] = "@"
new_password = "".join(chars)
connection.changepassword(test_env.get_main_password(), new_password)
try:
arg = "%s/%s@%s" % (test_env.get_main_user(), new_password,
test_env.get_connect_string())
oracledb.connect(arg)
finally:
connection.changepassword(new_password,
test_env.get_main_password())
def test_1110_encodings(self):
"1110 - connection with only encoding/nencoding specified should work"
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string())
encoding = connection.encoding
nencoding = connection.nencoding
alt_encoding = "ISO-8859-1"
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
encoding=alt_encoding)
self.assertEqual(connection.encoding, alt_encoding)
self.assertEqual(connection.nencoding, nencoding)
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
nencoding=alt_encoding)
self.assertEqual(connection.encoding, encoding)
self.assertEqual(connection.nencoding, alt_encoding)
def test_1111_different_encodings(self):
"1111 - different encodings can be specified for encoding/nencoding"
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
encoding="UTF-8",
nencoding="UTF-16")
value = "\u03b4\u4e2a"
cursor = connection.cursor()
nchar_var = cursor.var(oracledb.DB_TYPE_NVARCHAR, 100)
nchar_var.setvalue(0, value)
cursor.execute("select :value from dual", value=nchar_var)
result, = cursor.fetchone()
self.assertEqual(result, value)
def test_1112_exception_on_close(self):
"1112 - confirm an exception is raised after closing a connection"
connection = test_env.get_connection()
connection.close()
self.assertRaises(oracledb.InterfaceError, connection.rollback)
def test_1113_connect_with_handle(self):
"1113 - test creating a connection using a handle"
connection = test_env.get_connection()
cursor = connection.cursor()
cursor.execute("truncate table TestTempTable")
int_value = random.randint(1, 32768)
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (:val, null)""",
val=int_value)
connection2 = oracledb.connect(handle=connection.handle)
cursor = connection2.cursor()
cursor.execute("select IntCol from TestTempTable")
fetched_int_value, = cursor.fetchone()
self.assertEqual(fetched_int_value, int_value)
cursor.close()
self.assertRaises(oracledb.DatabaseError, connection2.close)
connection.close()
def test_1114_make_dsn(self):
"1114 - test making a data source name from host, port and sid"
format_string = "(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)" + \
"(HOST=%s)(PORT=%d))(CONNECT_DATA=(SID=%s)))"
args = ("hostname", 1521, "TEST")
result = oracledb.makedsn(*args)
self.assertEqual(result, format_string % args)
def test_1115_single_arg(self):
"1115 - connection to database with user, password, DSN together"
arg = "%s/%s@%s" % (test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string())
connection = oracledb.connect(arg)
self.__verify_args(connection)
def test_1116_version(self):
"1116 - connection version is a string"
connection = test_env.get_connection()
self.assertTrue(isinstance(connection.version, str))
def test_1117_rollback_on_close(self):
"1117 - connection rolls back before close"
connection = test_env.get_connection()
cursor = connection.cursor()
cursor.execute("truncate table TestTempTable")
other_connection = test_env.get_connection()
other_cursor = other_connection.cursor()
other_cursor.execute("insert into TestTempTable (IntCol) values (1)")
other_cursor.close()
other_connection.close()
cursor.execute("select count(*) from TestTempTable")
count, = cursor.fetchone()
self.assertEqual(count, 0)
def test_1118_rollback_on_del(self):
"1118 - connection rolls back before destruction"
connection = test_env.get_connection()
cursor = connection.cursor()
cursor.execute("truncate table TestTempTable")
other_connection = test_env.get_connection()
other_cursor = other_connection.cursor()
other_cursor.execute("insert into TestTempTable (IntCol) values (1)")
del other_cursor
del other_connection
cursor.execute("select count(*) from TestTempTable")
count, = cursor.fetchone()
self.assertEqual(count, 0)
def test_1119_threading(self):
"1119 - multiple connections to database with multiple threads"
threads = []
for i in range(20):
thread = threading.Thread(None, self.__connect_and_drop)
threads.append(thread)
thread.start()
for thread in threads:
thread.join()
def test_1120_string_format(self):
"1120 - test string format of connection"
connection = test_env.get_connection()
expected_value = "<cx_Oracle.Connection to %s@%s>" % \
(test_env.get_main_user(), test_env.get_connect_string())
self.assertEqual(str(connection), expected_value)
def test_1121_ctx_mgr_close(self):
"1121 - test context manager - close"
connection = test_env.get_connection()
with connection:
cursor = connection.cursor()
cursor.execute("truncate table TestTempTable")
cursor.execute("insert into TestTempTable (IntCol) values (1)")
connection.commit()
cursor.execute("insert into TestTempTable (IntCol) values (2)")
self.assertRaises(oracledb.InterfaceError, connection.ping)
connection = test_env.get_connection()
cursor = connection.cursor()
cursor.execute("select count(*) from TestTempTable")
count, = cursor.fetchone()
self.assertEqual(count, 1)
def test_1122_connection_attributes(self):
"1122 - test connection attribute values"
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
encoding="ASCII")
self.assertEqual(connection.maxBytesPerCharacter, 1)
connection = oracledb.connect(test_env.get_main_user(),
test_env.get_main_password(),
test_env.get_connect_string(),
encoding="UTF-8")
self.assertEqual(connection.maxBytesPerCharacter, 4)
if test_env.get_client_version() >= (12, 1):
self.assertEqual(connection.ltxid, b'')
self.assertEqual(connection.current_schema, None)
connection.current_schema = "test_schema"
self.assertEqual(connection.current_schema, "test_schema")
self.assertEqual(connection.edition, None)
connection.external_name = "test_external"
self.assertEqual(connection.external_name, "test_external")
connection.internal_name = "test_internal"
self.assertEqual(connection.internal_name, "test_internal")
connection.stmtcachesize = 30
self.assertEqual(connection.stmtcachesize, 30)
self.assertRaises(TypeError, connection.stmtcachesize, 20.5)
self.assertRaises(TypeError, connection.stmtcachesize, "value")
def test_1123_closed_connection_attributes(self):
"1123 - test closed connection attribute values"
connection = test_env.get_connection()
connection.close()
attr_names = [
"current_schema", "edition", "external_name", "internal_name",
"stmtcachesize"
]
if test_env.get_client_version() >= (12, 1):
attr_names.append("ltxid")
for name in attr_names:
self.assertRaises(oracledb.InterfaceError, getattr, connection,
name)
def test_1124_ping(self):
"1124 - test connection ping"
connection = test_env.get_connection()
connection.ping()
def test_1125_transaction_begin(self):
"1125 - test begin, prepare, cancel transaction"
connection = test_env.get_connection()
cursor = connection.cursor()
cursor.execute("truncate table TestTempTable")
connection.begin(10, 'trxnId', 'branchId')
self.assertEqual(connection.prepare(), False)
connection.begin(10, 'trxnId', 'branchId')
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (1, 'tesName')""")
self.assertEqual(connection.prepare(), True)
connection.cancel()
connection.rollback()
cursor.execute("select count(*) from TestTempTable")
count, = cursor.fetchone()
self.assertEqual(count, 0)
def test_1126_multiple_transactions(self):
"1126 - test multiple transactions on the same connection"
connection = test_env.get_connection()
with connection.cursor() as cursor:
cursor.execute("truncate table TestTempTable")
id_ = random.randint(0, 2**128)
xid = (0x1234, "%032x" % id_, "%032x" % 9)
connection.begin(*xid)
with connection.cursor() as cursor:
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (1, 'tesName')""")
self.assertEqual(connection.prepare(), True)
connection.commit()
for begin_trans in (True, False):
val = 3
if begin_trans:
connection.begin()
val = 2
with connection.cursor() as cursor:
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (:int_val, 'tesName')""",
int_val=val)
connection.commit()
expected_rows = [(1, "tesName"), (2, "tesName"), (3, "tesName")]
with connection.cursor() as cursor:
cursor.execute("select IntCol, StringCol from TestTempTable")
self.assertEqual(cursor.fetchall(), expected_rows)
def test_1127_multiple_global_transactions(self):
"1127 - test multiple global transactions on the same connection"
connection = test_env.get_connection()
with connection.cursor() as cursor:
cursor.execute("truncate table TestTempTable")
id_ = random.randint(0, 2**128)
xid = (0x1234, "%032x" % id_, "%032x" % 9)
connection.begin(*xid)
with connection.cursor() as cursor:
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (1, 'tesName')""")
self.assertEqual(connection.prepare(), True)
connection.commit()
for begin_trans in (True, False):
val = 3
if begin_trans:
connection.begin()
val = 2
with connection.cursor() as cursor:
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (:int_val, 'tesName')""",
int_val=val)
connection.commit()
id2_ = random.randint(0, 2**128)
xid2 = (0x1234, "%032x" % id2_, "%032x" % 9)
connection.begin(*xid2)
with connection.cursor() as cursor:
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (4, 'tesName')""")
self.assertEqual(connection.prepare(), True)
connection.commit()
expected_rows = [(1, "tesName"), (2, "tesName"), (3, "tesName"),
(4, "tesName")]
with connection.cursor() as cursor:
cursor.execute("select IntCol, StringCol from TestTempTable")
self.assertEqual(cursor.fetchall(), expected_rows)
def test_1128_exception_creating_global_txn_after_local_txn(self):
"1128 - test creating global txn after a local txn"
connection = test_env.get_connection()
with connection.cursor() as cursor:
cursor.execute("truncate table TestTempTable")
val = 2
with connection.cursor() as cursor:
cursor.execute("""
insert into TestTempTable (IntCol, StringCol)
values (:int_val, 'tesName')""",
int_val=val)
id_ = random.randint(0, 2**128)
xid = (0x1234, "%032x" % id_, "%032x" % 9)
self.assertRaises(oracledb.DatabaseError, connection.begin, *xid)
def test_1129_threading_single_connection(self):
"1129 - single connection to database with multiple threads"
with test_env.get_connection(threaded=True) as connection:
threads = [
threading.Thread(target=self.__verify_fetched_data,
args=(connection, )) for i in range(3)
]
for t in threads:
t.start()
for t in threads:
t.join()
def test_1130_cancel(self):
"1130 - test connection cancel"
conn = test_env.get_connection()
def perform_cancel():
time.sleep(0.1)
conn.cancel()
thread = threading.Thread(target=perform_cancel)
thread.start()
try:
with conn.cursor() as cursor:
self.assertRaises(oracledb.OperationalError, cursor.callproc,
test_env.get_sleep_proc_name(), [2])
finally:
thread.join()
with conn.cursor() as cursor:
cursor.execute("select user from dual")
user, = cursor.fetchone()
self.assertEqual(user, test_env.get_main_user().upper())
def test_1131_change_password_during_connect(self):
"1131 - test changing password during connect"
connection = test_env.get_connection()
if self.is_on_oracle_cloud(connection):
self.skipTest("passwords on Oracle Cloud are strictly controlled")
sys_random = random.SystemRandom()
new_password = "".join(sys_random.choice(string.ascii_letters) \
for i in range(20))
connection = oracledb.connect(dsn=test_env.get_connect_string(),
user=test_env.get_main_user(),
password=test_env.get_main_password(),
newpassword=new_password)
connection = oracledb.connect(dsn=test_env.get_connect_string(),
user=test_env.get_main_user(),
password=new_password)
connection.changepassword(new_password, test_env.get_main_password())
def test_1132_autocommit_during_reexecute(self):
"1132 - test use of autocommit during reexecute"
sql = "insert into TestTempTable (IntCol, StringCol) values (:1, :2)"
data_to_insert = [(1, "Test String #1"), (2, "Test String #2")]
connection = test_env.get_connection()
cursor = connection.cursor()
other_connection = test_env.get_connection()
other_cursor = other_connection.cursor()
cursor.execute("truncate table TestTempTable")
cursor.execute(sql, data_to_insert[0])
other_cursor.execute("select IntCol, StringCol from TestTempTable")
rows = other_cursor.fetchall()
self.assertEqual(rows, [])
connection.autocommit = True
cursor.execute(sql, data_to_insert[1])
other_cursor.execute("select IntCol, StringCol from TestTempTable")
rows = other_cursor.fetchall()
self.assertEqual(rows, data_to_insert)
def test_1133_current_schema(self):
"1133 - test current_schame is set properly"
conn = test_env.get_connection()
self.assertEqual(conn.current_schema, None)
user = test_env.get_main_user().upper()
proxy_user = test_env.get_proxy_user().upper()
cursor = conn.cursor()
cursor.execute(f'alter session set current_schema={proxy_user}')
self.assertEqual(conn.current_schema, proxy_user)
conn.current_schema = user
self.assertEqual(conn.current_schema, user)
cursor.execute("""
select sys_context('userenv', 'current_schema')
from dual""")
result, = cursor.fetchone()
self.assertEqual(result, user)
def test_1134_dbms_output(self):
"1134 - test dbms_output package"
conn = test_env.get_connection()
cursor = conn.cursor()
test_string = "Testing DBMS_OUTPUT package"
cursor.callproc("dbms_output.enable")
cursor.execute("""
begin
dbms_output.put_line(:val);
end; """,
val=test_string)
string_var = cursor.var(str)
number_var = cursor.var(int)
cursor.callproc("dbms_output.get_line", (string_var, number_var))
self.assertEqual(string_var.getvalue(), test_string)
@unittest.skipIf(test_env.get_client_version() < (18, 1),
"unsupported client")
def test_1135_calltimeout(self):
"1135 - test connection call_timeout"
conn = test_env.get_connection()
conn.call_timeout = 500 # milliseconds
self.assertEqual(conn.call_timeout, 500)
self.assertRaises(oracledb.DatabaseError,
conn.cursor().callproc,
test_env.get_sleep_proc_name(), [2])
