async def sample_batching(self):
# Instantiate a TableServiceClient using a connection string
# [START batching]
from azure.data.tables.aio import TableClient
from azure.data.tables import UpdateMode, BatchErrorException
from azure.core.exceptions import ResourceExistsError
self.table_client = TableClient.from_connection_string(
conn_str=self.connection_string, table_name=self.table_name)
try:
await self.table_client.create_table()
print("Created table")
except ResourceExistsError:
print("Table already exists")
await self._create_entities()
batch = self.table_client.create_batch()
batch.create_entity(self.entity1)
batch.delete_entity(partition_key=self.entity2['PartitionKey'],
row_key=self.entity2['RowKey'])
batch.upsert_entity(self.entity3)
batch.update_entity(self.entity4, mode=UpdateMode.REPLACE)
try:
await self.table_client.send_batch(batch)
except BatchErrorException as e:
print("There was an error with the batch operation")
print("Error: {}".format(e))
async def create_table_client(self):
# Instantiate a TableServiceClient using a connection string
# [START create_table_client]
from azure.data.tables.aio import TableClient
table_client = TableClient.from_connection_string(
conn_str=self.connection_string, table_name="tableName")
print("Table name: {}".format(table_client.table_name))
async def insert_random_entities(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import ResourceExistsError
brands = ["Crayola", "Sharpie", "Chameleon"]
colors = ["red", "blue", "orange", "yellow"]
names = ["marker", "pencil", "pen"]
entity_template = {
"PartitionKey": "pk",
"RowKey": "row",
}
table_client = TableClient.from_connection_string(self.connection_string, self.table_name)
async with table_client:
try:
await table_client.create_table()
except ResourceExistsError:
print("Table already exists")
for i in range(25):
e = copy.deepcopy(entity_template)
e["RowKey"] += str(i)
e["Name"] = random.choice(names)
e["Brand"] = random.choice(brands)
e["Color"] = random.choice(colors)
e["Value"] = random.randint(0, 100)
await table_client.create_entity(entity=e)
async def sample_transaction(self):
# Instantiate a TableServiceClient using a connection string
# [START batching]
from azure.data.tables.aio import TableClient
from azure.data.tables import TableTransactionError
from azure.core.exceptions import ResourceExistsError
self.table_client = TableClient.from_connection_string(
conn_str=self.connection_string, table_name=self.table_name)
try:
await self.table_client.create_table()
print("Created table")
except ResourceExistsError:
print("Table already exists")
await self._create_entities()
operations = [('create', self.entity1), ('delete', self.entity2),
('upsert', self.entity3),
('update', self.entity4, {
'mode': 'replace'
})]
try:
await self.table_client.submit_transaction(operations)
except TableTransactionError as e:
print("There was an error with the transaction operation")
print("Error: {}".format(e))
async def create_and_get_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
table = TableClient.from_connection_string(
self.connection_string, table_name=self.table_base + "create")
async with table:
await table.create_table()
my_entity = {
'PartitionKey': 'color',
'RowKey': 'crayola',
'text': 'Marker',
'color': 'Purple',
'price': '5'
}
try:
created_entity = await table.create_entity(entity=my_entity)
print("Created entity: {}".format(created_entity))
# [START get_entity]
# Get Entity by partition and row key
got_entity = await table.get_entity(
partition_key=my_entity['PartitionKey'],
row_key=my_entity['RowKey']
)
print("Received entity: {}".format(got_entity))
# [END get_entity]
finally:
await table.delete_table()
async def list_all_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
table = TableClient.from_connection_string(
self.connection_string, table_name=self.table_base + "list")
# Create the table
async with table:
await table.create_table()
entity = {'PartitionKey': 'color2', 'RowKey': 'sharpie', 'text': 'Marker', 'color': 'Purple', 'price': '5'}
entity1 = {'PartitionKey': 'color2', 'RowKey': 'crayola', 'text': 'Marker', 'color': 'Red', 'price': '3'}
try:
# Create entities
await table.create_entity(entity=entity)
await table.create_entity(entity=entity1)
# [START list_entities]
# Query the entities in the table
entities = []
async for e in table.list_entities():
entities.append(e)
for i, entity in enumerate(entities):
print("Entity #{}: {}".format(entity, i))
# [END list_entities]
finally:
await table.delete_table()
async def create_and_get_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
table = TableClient.from_connection_string(self.connection_string,
table_name=self.table_base +
"create")
async with table:
await table.create_table()
my_entity = {
"PartitionKey": "color",
"RowKey": "crayola",
"text": "Marker",
"color": "Purple",
"price": "5",
}
try:
created_entity = await table.create_entity(entity=my_entity)
print("Created entity: {}".format(created_entity))
# [START get_entity]
# Get Entity by partition and row key
got_entity = await table.get_entity(
partition_key=my_entity["PartitionKey"],
row_key=my_entity["RowKey"])
print("Received entity: {}".format(got_entity))
# [END get_entity]
finally:
await table.delete_table()
async def delete_from_table_client(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import HttpResponseError
# [START delete_from_table_client]
async with TableClient.from_connection_string(
conn_str=self.connection_string,
table_name=self.table_name) as table_client:
await table_client.delete_table()
print("Deleted table {}!".format(self.table_name))
async def create_from_table_client(self):
from azure.data.tables.aio import TableClient
# [START create_from_table_client]
async with TableClient.from_connection_string(conn_str=self.connection_string, table_name=self.table_name) as table_client:
try:
table_item = await table_client.create_table()
print("Created table {}!".format(table_item.table_name))
except ResourceExistsError:
print("Table already exists")
async def delete_from_table_client(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import ResourceNotFoundError
# [START delete_from_table_client]
async with TableClient.from_connection_string(conn_str=self.connection_string, table_name=self.table_name) as table_client:
try:
await table_client.delete_table()
print("Deleted table {}!".format(self.table_name))
except ResourceNotFoundError:
print("Table could not be found")
async def update_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
from azure.data.tables import UpdateMode
table = TableClient.from_connection_string(
self.connection_string, table_name=self.table_base + "update")
# Create the table and Table Client
async with table:
await table.create_table()
entity = {'PartitionKey': 'color', 'RowKey': 'sharpie', 'text': 'Marker', 'color': 'Purple', 'price': '5'}
entity1 = {'PartitionKey': 'color2', 'RowKey': 'crayola', 'text': 'Marker', 'color': 'Red', 'price': '3'}
try:
# Create entities
await table.create_entity(entity=entity)
created = await table.get_entity(partition_key=entity["PartitionKey"], row_key=entity["RowKey"])
# [START upsert_entity]
# Try Replace and then Insert on Fail
insert_entity = await table.upsert_entity(mode=UpdateMode.REPLACE, entity=entity1)
print("Inserted entity: {}".format(insert_entity))
# Try merge, and merge since already in table
created['text'] = "NewMarker"
merged_entity = await table.upsert_entity(mode=UpdateMode.MERGE, entity=entity)
print("Merged entity: {}".format(merged_entity))
# [END upsert_entity]
# [START update_entity]
# Update the entity
created['text'] = "NewMarker"
await table.update_entity(mode=UpdateMode.REPLACE, entity=created)
# Get the replaced entity
replaced = await table.get_entity(
partition_key=created['PartitionKey'], row_key=created['RowKey'])
print("Replaced entity: {}".format(replaced))
# Merge the entity
replaced['color'] = "Blue"
await table.update_entity(mode=UpdateMode.MERGE, entity=replaced)
# Get the merged entity
merged = await table.get_entity(
partition_key=replaced['PartitionKey'], row_key=replaced['RowKey'])
print("Merged entity: {}".format(merged))
# [END update_entity]
finally:
await table.delete_table()
def test_create_client_for_cosmos_emulator(self):
emulator_credential = AzureNamedKeyCredential(
'localhost', self.tables_primary_cosmos_account_key)
emulator_connstr = "DefaultEndpointsProtocol=http;AccountName=localhost;AccountKey={};TableEndpoint=http://localhost:8902/;".format(
self.tables_primary_cosmos_account_key)
client = TableServiceClient.from_connection_string(emulator_connstr)
assert client.url == "http://localhost:8902"
assert client.account_name == 'localhost'
assert client.credential.named_key.name == 'localhost'
assert client.credential.named_key.key == self.tables_primary_cosmos_account_key
assert client._cosmos_endpoint
client = TableServiceClient("http://localhost:8902/",
credential=emulator_credential)
assert client.url == "http://localhost:8902"
assert client.account_name == 'localhost'
assert client.credential.named_key.name == 'localhost'
assert client.credential.named_key.key == self.tables_primary_cosmos_account_key
assert client._cosmos_endpoint
table = TableClient.from_connection_string(emulator_connstr,
'tablename')
assert table.url == "http://localhost:8902"
assert table.account_name == 'localhost'
assert table.table_name == 'tablename'
assert table.credential.named_key.name == 'localhost'
assert table.credential.named_key.key == self.tables_primary_cosmos_account_key
assert table._cosmos_endpoint
table = TableClient("http://localhost:8902/",
"tablename",
credential=emulator_credential)
assert table.url == "http://localhost:8902"
assert table.account_name == 'localhost'
assert table.table_name == 'tablename'
assert table.credential.named_key.name == 'localhost'
assert table.credential.named_key.key == self.tables_primary_cosmos_account_key
assert table._cosmos_endpoint
table = TableClient.from_table_url(
"http://localhost:8902/Tables('tablename')",
credential=emulator_credential)
assert table.url == "http://localhost:8902"
assert table.account_name == 'localhost'
assert table.table_name == 'tablename'
assert table.credential.named_key.name == 'localhost'
assert table.credential.named_key.key == self.tables_primary_cosmos_account_key
assert table._cosmos_endpoint
async def list_all_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
table = TableClient.from_connection_string(self.connection_string,
table_name=self.table_base +
"list")
# Create the table
async with table:
await table.create_table()
entity = {
"PartitionKey": "color2",
"RowKey": "sharpie",
"text": "Marker",
"color": "Purple",
"price": 5.99,
"inventory": 42,
"product_id": uuid4(),
}
entity1 = {
"PartitionKey": "color2",
"RowKey": "crayola",
"text": "Marker",
"color": "Red",
"price": 3.99,
"inventory": 42,
"product_id": uuid4(),
}
try:
# Create entities
await table.create_entity(entity=entity)
await table.create_entity(entity=entity1)
# [START list_entities]
# Query the entities in the table
i = 0
async for entity in table.list_entities():
print("Entity #{}: {}".format(i, entity))
i += 1
# [END list_entities]
finally:
await table.delete_table()
async def create_entity(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import ResourceExistsError, HttpResponseError
table_client = TableClient.from_connection_string(self.connection_string, self.table_name)
# Create a table in case it does not already exist
# [START create_entity]
async with table_client:
try:
await table_client.create_table()
except HttpResponseError:
print("Table already exists")
try:
entity = await table_client.create_entity(entity=self.entity)
print(entity)
except ResourceExistsError:
print("Entity already exists")
async def sample_query_entities_values(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import HttpResponseError
print("Entities with 25 < Value < 50")
# [START query_entities]
async with TableClient.from_connection_string(self.connection_string, self.table_name) as table_client:
try:
parameters = {u"lower": 25, u"upper": 50}
name_filter = u"Value gt @lower and Value lt @upper"
queried_entities = table_client.query_entities(
query_filter=name_filter, select=[u"Value"], parameters=parameters
)
async for entity_chosen in queried_entities:
print(entity_chosen)
except HttpResponseError as e:
print(e.message)
async def sample_query_entities_multiple_params(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import HttpResponseError
print("Entities with name: marker and brand: Crayola")
# [START query_entities]
async with TableClient.from_connection_string(self.connection_string, self.table_name) as table_client:
try:
parameters = {u"name": u"marker", u"brand": u"Crayola"}
name_filter = u"Name eq @name and Brand eq @brand"
queried_entities = table_client.query_entities(
query_filter=name_filter, select=[u"Brand", u"Color"], parameters=parameters
)
async for entity_chosen in queried_entities:
print(entity_chosen)
except HttpResponseError as e:
print(e.message)
async def sample_query_entities(self):
from azure.data.tables.aio import TableClient
from azure.core.exceptions import HttpResponseError
print("Entities with name: marker")
table_client = TableClient.from_connection_string(self.connection_string, self.table_name)
# [START query_entities]
async with table_client:
try:
parameters = {
u"name": u"marker"
}
name_filter = u"Name eq @name"
async for entity_chosen in table_client.query_entities(
filter=name_filter, select=[u"Brand",u"Color"], parameters=parameters):
print(entity_chosen)
except HttpResponseError as e:
pass
async def _insert_random_entities(self):
from azure.data.tables.aio import TableClient
brands = ["Crayola", "Sharpie", "Chameleon"]
colors = ["red", "blue", "orange", "yellow"]
names = ["marker", "pencil", "pen"]
entity_template = {
"PartitionKey": "pk",
"RowKey": "row",
}
table_client = TableClient.from_connection_string(
self.connection_string, self.table_name)
await table_client.create_table()
for i in range(10):
e = copy.deepcopy(entity_template)
e["RowKey"] += str(i)
e["Name"] = random.choice(names)
e["Brand"] = random.choice(brands)
e["Color"] = random.choice(colors)
await table_client.create_entity(entity=e)
async def sample_query_entities(self):
await self._insert_random_entities()
from azure.data.tables.aio import TableClient
from azure.core.exceptions import HttpResponseError
table_client = TableClient.from_connection_string(
self.connection_string, self.table_name)
# [START query_entities]
async with table_client:
try:
entity_name = "marker"
name_filter = "Name eq '{}'".format(entity_name)
async for entity_chosen in table_client.query_entities(
filter=name_filter, select=["Brand", "Color"]):
print(entity_chosen)
except HttpResponseError as e:
pass
# [END query_entities]
finally:
await table_client.delete_table()
async def create_and_get_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
table = TableClient.from_connection_string(self.connection_string,
table_name=self.table_base +
"create")
async with table:
await table.create_table()
my_entity = {
"PartitionKey": "color",
"RowKey": "brand",
"text": "Marker",
"color": "Purple",
"price": 4.99,
"last_updated": datetime.today(),
"product_id": uuid4(),
"inventory_count": 42,
"barcode": b"135aefg8oj0ld58"
}
try:
created_entity = await table.create_entity(entity=my_entity)
print("Created entity: {}".format(created_entity))
# [START get_entity]
# Get Entity by partition and row key
got_entity = await table.get_entity(
partition_key=my_entity["PartitionKey"],
row_key=my_entity["RowKey"])
print("Received entity: {}".format(got_entity))
# [END get_entity]
finally:
await table.delete_table()
async def update_entities(self):
# Instantiate a table service client
from azure.data.tables.aio import TableClient
from azure.data.tables import UpdateMode
table = TableClient.from_connection_string(self.connection_string,
table_name=self.table_base +
"update")
# Create the table and Table Client
async with table:
await table.create_table()
entity = {
"PartitionKey": "color",
"RowKey": "sharpie",
"text": "Marker",
"color": "Purple",
"price": "5"
}
entity1 = {
"PartitionKey": "color2",
"RowKey": "crayola",
"text": "Marker",
"color": "Red",
"price": "3"
}
try:
# Create entities
await table.create_entity(entity=entity)
created = await table.get_entity(
partition_key=entity["PartitionKey"],
row_key=entity["RowKey"])
# [START upsert_entity]
# Try Replace and insert on fail
insert_entity = await table.upsert_entity(
mode=UpdateMode.REPLACE, entity=entity1)
print("Inserted entity: {}".format(insert_entity))
created["text"] = "NewMarker"
merged_entity = await table.upsert_entity(
mode=UpdateMode.MERGE, entity=entity)
print("Merged entity: {}".format(merged_entity))
# [END upsert_entity]
# [START update_entity]
# Update the entity
created["text"] = "NewMarker"
await table.update_entity(mode=UpdateMode.REPLACE,
entity=created)
# Get the replaced entity
replaced = await table.get_entity(
partition_key=created["PartitionKey"],
row_key=created["RowKey"])
print("Replaced entity: {}".format(replaced))
# Merge the entity
replaced["color"] = "Blue"
await table.update_entity(mode=UpdateMode.MERGE,
entity=replaced)
# Get the merged entity
merged = await table.get_entity(
partition_key=replaced["PartitionKey"],
row_key=replaced["RowKey"])
print("Merged entity: {}".format(merged))
# [END update_entity]
finally:
await table.delete_table()
async def test_create_client_for_azurite(self):
azurite_credential = AzureNamedKeyCredential(
"myaccount", self.tables_primary_storage_account_key)
http_connstr = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey={};TableEndpoint=http://127.0.0.1:10002/devstoreaccount1;".format(
self.tables_primary_storage_account_key)
https_connstr = "DefaultEndpointsProtocol=https;AccountName=devstoreaccount1;AccountKey={};TableEndpoint=https://127.0.0.1:10002/devstoreaccount1;".format(
self.tables_primary_storage_account_key)
account_url = "https://127.0.0.1:10002/myaccount"
client = TableServiceClient(account_url, credential=azurite_credential)
assert client.account_name == "myaccount"
assert client.url == "https://127.0.0.1:10002/myaccount"
assert client._location_mode == "primary"
assert client._secondary_endpoint == "https://127.0.0.1:10002/myaccount-secondary"
assert client.credential.named_key.key == azurite_credential.named_key.key
assert client.credential.named_key.name == azurite_credential.named_key.name
assert not client._cosmos_endpoint
client = TableServiceClient.from_connection_string(http_connstr)
assert client.account_name == "devstoreaccount1"
assert client.url == "http://127.0.0.1:10002/devstoreaccount1"
assert client._location_mode == "primary"
assert client._secondary_endpoint == "http://127.0.0.1:10002/devstoreaccount1-secondary"
assert client.credential.named_key.key == self.tables_primary_storage_account_key
assert client.credential.named_key.name == "devstoreaccount1"
assert not client._cosmos_endpoint
client = TableServiceClient.from_connection_string(https_connstr)
assert client.account_name == "devstoreaccount1"
assert client.url == "https://127.0.0.1:10002/devstoreaccount1"
assert client._location_mode == "primary"
assert client._secondary_endpoint == "https://127.0.0.1:10002/devstoreaccount1-secondary"
assert client.credential.named_key.key == self.tables_primary_storage_account_key
assert client.credential.named_key.name == "devstoreaccount1"
assert not client._cosmos_endpoint
table = TableClient(account_url,
"tablename",
credential=azurite_credential)
assert table.account_name == "myaccount"
assert table.table_name == "tablename"
assert table.url == "https://127.0.0.1:10002/myaccount"
assert table._location_mode == "primary"
assert table._secondary_endpoint == "https://127.0.0.1:10002/myaccount-secondary"
assert table.credential.named_key.key == azurite_credential.named_key.key
assert table.credential.named_key.name == azurite_credential.named_key.name
assert not table._cosmos_endpoint
table = TableClient.from_connection_string(http_connstr, "tablename")
assert table.account_name == "devstoreaccount1"
assert table.table_name == "tablename"
assert table.url == "http://127.0.0.1:10002/devstoreaccount1"
assert table._location_mode == "primary"
assert table._secondary_endpoint == "http://127.0.0.1:10002/devstoreaccount1-secondary"
assert table.credential.named_key.key == self.tables_primary_storage_account_key
assert table.credential.named_key.name == "devstoreaccount1"
assert not table._cosmos_endpoint
table = TableClient.from_connection_string(https_connstr, "tablename")
assert table.account_name == "devstoreaccount1"
assert table.table_name == "tablename"
assert table.url == "https://127.0.0.1:10002/devstoreaccount1"
assert table._location_mode == "primary"
assert table._secondary_endpoint == "https://127.0.0.1:10002/devstoreaccount1-secondary"
assert table.credential.named_key.key == self.tables_primary_storage_account_key
assert table.credential.named_key.name == "devstoreaccount1"
assert not table._cosmos_endpoint
table_url = "https://127.0.0.1:10002/myaccount/Tables('tablename')"
table = TableClient.from_table_url(table_url,
credential=azurite_credential)
assert table.account_name == "myaccount"
assert table.table_name == "tablename"
assert table.url == "https://127.0.0.1:10002/myaccount"
assert table._location_mode == "primary"
assert table._secondary_endpoint == "https://127.0.0.1:10002/myaccount-secondary"
assert table.credential.named_key.key == azurite_credential.named_key.key
assert table.credential.named_key.name == azurite_credential.named_key.name
assert not table._cosmos_endpoint
async def clean_up(self):
print("cleaning up")
from azure.data.tables.aio import TableClient
async with TableClient.from_connection_string(self.connection_string, self.table_name) as table_client:
await table_client.delete_table()