def test_1122_connection_attributes(self):
"1122 - test connection attribute values"
connection = oracledb.connect(base.get_main_user(),
base.get_main_password(),
base.get_connect_string(),
encoding="ASCII")
self.assertEqual(connection.maxBytesPerCharacter, 1)
connection = oracledb.connect(base.get_main_user(),
base.get_main_password(),
base.get_connect_string(),
encoding="UTF-8")
self.assertEqual(connection.maxBytesPerCharacter, 4)
if base.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 = base.get_pool(getmode=oracledb.SPOOL_ATTRVAL_NOWAIT)
conn = pool.acquire()
self.assertRaises(TypeError, pool.release, conn, tag=12345)
if base.get_client_version() >= (12, 2):
self.assertRaises(oracledb.DatabaseError, pool.release, conn,
tag="INVALID_TAG")
def test_1123_closed_connection_attributes(self):
"1123 - test closed connection attribute values"
connection = base.get_connection()
connection.close()
attr_names = ["current_schema", "edition", "external_name",
"internal_name", "stmtcachesize"]
if base.get_client_version() >= (12, 1):
attr_names.append("ltxid")
for name in attr_names:
self.assertRaises(oracledb.InterfaceError, getattr, connection,
name)
def test_2400_pool(self):
"2400 - test that the pool is created and has the right attributes"
pool = base.get_pool(min=2, max=8, increment=3,
getmode=oracledb.SPOOL_ATTRVAL_WAIT)
self.assertEqual(pool.username, base.get_main_user(),
"user name differs")
self.assertEqual(pool.tnsentry, base.get_connect_string(),
"tnsentry differs")
self.assertEqual(pool.dsn, base.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 base.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 base.get_client_version() >= (12, 1):
pool.max_lifetime_session = 10
self.assertEqual(pool.max_lifetime_session, 10)
def test_1103_attributes(self):
"1103 - test connection end-to-end tracing attributes"
connection = base.get_connection()
if base.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 base.get_client_version() < (12, 2):
self.skipTest("PL/SQL session callbacks not supported before 12.2")
pool = base.get_pool(min=2, max=8, increment=3,
getmode=oracledb.SPOOL_ATTRVAL_NOWAIT,
sessionCallback="pkg_SessionCallback.TheCallback")
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)
#
# Portions Copyright 2001-2007, Computronix (Canada) Ltd., Edmonton, Alberta,
# Canada. All rights reserved.
#------------------------------------------------------------------------------
"""
3200 - Module for testing features introduced in 12.1
"""
import base
import cx_Oracle as oracledb
import datetime
import unittest
@unittest.skipUnless(base.get_client_version() >= (12, 1),
"unsupported client")
class TestCase(base.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(base.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_CreateAndDropIndex(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(base.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()