def run_sample():
AUTH_URI = os.environ.get("ACCOUNT_URI")
AUTH_KEY = os.environ.get("ACCOUNT_KEY")
DATABASE_ID = "testdocumentmanagementdb"
CONTAINER_ID = "testdocumentmanagementcollection"
client = CosmosClient(AUTH_URI, AUTH_KEY)
database = client.create_database(id=DATABASE_ID)
partition_key = PartitionKey(path="/purchase_order_number")
try:
container = database.create_container(id=CONTAINER_ID,
partition_key=partition_key)
print(f'Container with id "{CONTAINER_ID}"" created')
except HTTPFailure as e:
if e.status_code == 409:
print(f"Container with id {CONTAINER_ID} already exists")
container = database.get_container(container=CONTAINER_ID)
else:
raise
DocumentManagement.create_documents(container)
DocumentManagement.read_document(container, "SalesOrder1")
DocumentManagement.read_documents(container)
client.delete_database(database=DATABASE_ID)
print("\nrun_sample done")
def clean_up_database(cls):
client = CosmosClient(_config.host, key=_config.master_key)
query_iterable = client.list_database_properties(
query="SELECT * FROM root r WHERE r.id='{}'".format(
_config.TEST_DATABASE_NAME
)
)
for database in query_iterable:
client.delete_database(database)
def run_sample():
AUTH_URL = os.environ.get("ACCOUNT_HOST")
AUTH_KEY = os.environ.get("ACCOUNT_KEY")
DATABASE_ID = 'testdocumentmanagementdb'
CONTAINER_ID = 'testdocumentmanagementcollection'
client = CosmosClient(AUTH_URL, AUTH_KEY)
database = client.create_database(id=DATABASE_ID)
try:
container = database.create_container(id=CONTAINER_ID)
print(f'Container with id "{CONTAINER_ID}"" created')
except HTTPFailure as e:
if e.status_code == 409:
print(f'Container with id {CONTAINER_ID} already exists')
container = database.get_container(container=CONTAINER_ID)
else:
raise
DocumentManagement.create_documents(container)
DocumentManagement.read_document(container, 'SalesOrder1')
DocumentManagement.read_documents(container)
client.delete_database(database=DATABASE_ID)
print("\nrun_sample done")
class CosmosDB:
def __init__(self):
URL = os.environ["COSMOS_ENDPOINT"]
KEY = os.environ["COSMOS_KEY"]
self.client = CosmosClient(URL, {"masterKey": KEY})
self.dbName = "pySolarSystem-" + uuid.uuid1().hex
def create_database(self):
print("Creating '{0}' database...".format(self.dbName))
return self.client.create_database(self.dbName)
def create_container(self, db):
collectionName = "Planets"
print("Creating '{0}' collection...".format(collectionName))
partition_key = PartitionKey(path="/id", kind="Hash")
return db.create_container(id="Planets", partition_key=partition_key)
def create_documents(self, container):
# Cosmos will look for an 'id' field in the items, if the 'id' is not specify Cosmos is going to assing a random key.
planets = [
{
"id": "Earth",
"HasRings": False,
"Radius": 3959,
"Moons": [{"Name": "Moon"}],
},
{
"id": "Mars",
"HasRings": False,
"Radius": 2106,
"Moons": [{"Name": "Phobos"}, {"Name": "Deimos"}],
},
]
print("Inserting items in the collection...")
for planet in planets:
container.create_item(planet)
print("\t'{0}' created".format(planet["id"]))
print("\tdone")
def simple_query(self, container):
print("Quering the container...")
items = list(
container.query_items(
query="SELECT c.id FROM c", enable_cross_partition_query=True
)
)
print("\tdone: {0}".format(items))
def delete_database(self):
print("Cleaning up the resource...")
self.client.delete_database(self.dbName)
print("\tdone")
def run(self):
print("")
print("------------------------")
print("Cosmos DB")
print("------------------------")
print("1) Create a Database")
print("2) Create a Container in the database")
print("3) Insert Documents (items) into the Container")
print("4) Delete Database (Clean up the resource)")
print("")
# Ensure that the database does not exists
try:
self.delete_database()
except:
pass
try:
db = self.create_database()
container = self.create_container(db=db)
self.create_documents(container=container)
self.simple_query(container=container)
finally:
# if something goes wrong, the resource should be cleaned anyway
self.delete_database()
# Create a database
# <create_database_if_not_exists>
database_name = 'GameDatabase'
databases = list(
client.query_databases({
"query":
"SELECT * FROM r WHERE r.id=@id",
"parameters": [{
"name": "@id",
"value": database_name
}]
}))
if (len(databases) > 0):
client.delete_database(database_name)
database = client.create_database_if_not_exists(id=database_name)
# </create_database_if_not_exists>
orders_name = "Orders"
orders_db = database.create_container_if_not_exists(
id=orders_name,
partition_key=PartitionKey(path="/username"),
offer_throughput=400)
order_items_to_create = [
orders.vulture_1_1(),
orders.vulture_1_2(),
orders.scorpion_1_1(),
orders.scorpion_1_2(),
class CRUD:
'''
Class:
CRUD
Description:
Class to perform Basic CRUD Operations on Cosmos DB SQL API
Functions:
dbConnection()
create_database()
create_container()
insert_record()
delete_record()
read_record()
drop_database()
Variable:
None
'''
def __init__(self):
self.url = config('ACCOUNT_URI')
self.key = config('ACCOUNT_KEY')
self.clientConnection()
self.create_database()
self.create_container()
def clientConnection(self):
'''
Description:
Connection to Azure Cosmos DB
Parameter:
None
Return:
None
'''
try:
self.client = CosmosClient(self.url, credential=self.key)
logger.info("Connection Successfull")
except Exception:
logger.exception("Connection Unsuccessfull")
def create_database(self):
'''
Description:
Create a Database
Parameter:
None
Return:
None
'''
try:
database_name = 'testDatabase'
self.mydb = self.client.create_database(database_name)
logger.info("Database Creation Successfull")
except exceptions.CosmosResourceExistsError:
self.mydb = self.client.get_database_client(database_name)
logger.warning("Database Exists")
except Exception:
logger.exception("Database Creation Unsuccessfull")
def create_container(self):
'''
Description:
Create a Container
Parameter:
None
Return:
None
'''
try:
container_name = 'products'
self.myContainer = self.mydb.create_container(
id=container_name,
partition_key=PartitionKey(path="/productName"))
logger.info("Container Creation Successfull")
except exceptions.CosmosResourceExistsError:
self.myContainer = self.mydb.get_container_client(container_name)
logger.warning("Container Exists")
except Exception:
logger.exception("Container Creation Unsuccessfull")
def insert_record(self):
'''
Description:
Insert Records to the container
Parameter:
None
Return:
None
'''
try:
for i in range(1, 10):
self.myContainer.upsert_item({
'id':
'item{0}'.format(i),
'productName':
'Widget',
'productModel':
'Model {0}'.format(i)
})
logger.info("Insert Record Successfull")
except Exception:
logger.exception("Insert Record Unsuccessfull")
def delete_record(self):
'''
Description:
Delete a record in the container
Parameter:
None
Return:
None
'''
try:
myQuery = "SELECT * FROM products p WHERE p.id = 'item3'"
for item in self.myContainer.query_items(
query=myQuery, enable_cross_partition_query=True):
self.myContainer.delete_item(item, partition_key='Widget')
logger.info("Delete Record Successfull")
except Exception:
logger.exception("Delete Record Unsuccessfull")
def read_record(self):
'''
Description:
Read a record from the container
Parameter:
None
Return:
None
'''
try:
myQuery = "SELECT * FROM products p WHERE p.productModel = 'Model 2'"
for item in self.myContainer.query_items(
query=myQuery, enable_cross_partition_query=True):
print(json.dumps(item, indent=True))
logger.info("Read Record Successfull")
except Exception:
logger.exception("Read Record Unsuccessfull")
def drop_database(self):
'''
Description:
Delete the created Database
Parameter:
None
Return:
None
'''
try:
self.client.delete_database("testDatabase")
logger.info("Database Drop Successfull")
except Exception:
logger.exception("Drop Database Unsuccessfull")
