public async Task TestReducePageSizeScenario()
{
int partitionKey = 0;
// Create some docs to make sure that one separate response is returned for 1st execute of query before retries.
// These are to make sure continuation token is passed along during retries.
string sprocId = "createTwoDocs";
string sprocBody = @"function(startIndex) { for (var i = 0; i < 2; ++i) __.createDocument(
__.getSelfLink(),
{ id: 'doc' + (i + startIndex).toString(), value: 'y'.repeat(1500000), pk:0 },
err => { if (err) throw err;}
);}";
Scripts scripts = this.Container.Scripts;
StoredProcedureResponse storedProcedureResponse =
await scripts.CreateStoredProcedureAsync(new StoredProcedureProperties(sprocId, sprocBody));
ManualResetEvent allDocsProcessed = new ManualResetEvent(false);
int processedDocCount = 0;
string accumulator = string.Empty;
ChangeFeedProcessor processor = this.Container
.GetChangeFeedProcessorBuilder("test", (IReadOnlyCollection <dynamic> docs, CancellationToken token) =>
{
processedDocCount += docs.Count();
foreach (var doc in docs)
{
accumulator += doc.id.ToString() + ".";
}
if (processedDocCount == 5)
{
allDocsProcessed.Set();
}
return(Task.CompletedTask);
})
.WithStartFromBeginning()
.WithInstanceName("random")
.WithMaxItems(6)
.WithLeaseContainer(this.LeaseContainer).Build();
// Generate the payload
await scripts.ExecuteStoredProcedureAsync <int, object>(sprocId, 0, new PartitionKey(partitionKey));
// Create 3 docs each 1.5MB. All 3 do not fit into MAX_RESPONSE_SIZE (4 MB). 2nd and 3rd are in same transaction.
var content = string.Format("{{\"id\": \"doc2\", \"value\": \"{0}\", \"pk\": 0}}", new string('x', 1500000));
await this.Container.CreateItemAsync(JsonConvert.DeserializeObject <dynamic>(content), new PartitionKey(partitionKey));
await scripts.ExecuteStoredProcedureAsync <int, object>(sprocId, 3, new PartitionKey(partitionKey));
await processor.StartAsync();
// Letting processor initialize and pickup changes
var isStartOk = allDocsProcessed.WaitOne(10 * BaseChangeFeedClientHelper.ChangeFeedSetupTime);
await processor.StopAsync();
Assert.IsTrue(isStartOk, "Timed out waiting for docs to process");
Assert.AreEqual("doc0.doc1.doc2.doc3.doc4.", accumulator);
}
public async Task<HttpStatusCode> BulkUpdateAsync<T>(IEnumerable<T> entities, string storedProcedureName) where T : IIdentifiable
{
Guard.ArgumentNotNull(entities, nameof(entities));
string documentType = GetDocumentType<T>();
IList<DocumentEntity<T>> documents = new List<DocumentEntity<T>>();
foreach (T entity in entities)
{
DocumentEntity<T> doc = new DocumentEntity<T>(entity);
if (doc.DocumentType != null && doc.DocumentType != documentType)
{
throw new ArgumentException($"Cannot change {entity.Id} from {doc.DocumentType} to {typeof(T).Name}");
}
doc.DocumentType = documentType;
doc.UpdatedAt = DateTimeOffset.Now;
documents.Add(doc);
}
string documentsAsJson = JsonConvert.SerializeObject(documents);
dynamic[] args = new dynamic[] { JsonConvert.DeserializeObject<dynamic>(documentsAsJson) };
Scripts cosmosScripts = RepositoryContainer.Scripts;
StoredProcedureExecuteResponse<string> response = await cosmosScripts.ExecuteStoredProcedureAsync<string>(
storedProcedureId: storedProcedureName,
partitionKey: PartitionKey.Null,
requestOptions: null,
parameters: args);
return response.StatusCode;
}
// </RunBulkImport>
/// <summary>
/// Get documents ordered by some doc property. This is done using OrderBy stored procedure.
/// </summary>
// <RunOrderBy>
private static async Task RunOrderBy(Container container)
{
// 1. Create or get the stored procedure.
string body = File.ReadAllText(@"js\OrderBy.js");
string scriptId = "OrderBy";
await TryDeleteStoredProcedure(container, scriptId);
Scripts cosmosScripts = container.Scripts;
StoredProcedureResponse sproc = await cosmosScripts.CreateStoredProcedureAsync(new StoredProcedureProperties(scriptId, body));
// 2. Prepare to run stored procedure.
string orderByFieldName = "FamilyId";
string filterQuery = string.Format(CultureInfo.InvariantCulture, "SELECT r.FamilyId FROM root r WHERE r.{0} > 10", orderByFieldName);
// Note: in order to do a range query (> 10) on this field, the collection must have a range index set for this path (see ReadOrCreateCollection).
int?continuationToken = null;
int batchCount = 0;
do
{
// 3. Run the stored procedure.
StoredProcedureExecuteResponse <OrderByResult> response = await cosmosScripts.ExecuteStoredProcedureAsync <OrderByResult>(
scriptId,
new PartitionKey("Andersen"),
new dynamic[] { filterQuery, orderByFieldName, continuationToken });
// 4. Process stored procedure response.
continuationToken = response.Resource.Continuation;
Console.WriteLine($"Printing documents filtered/ordered by '{filterQuery}' and ordered by '{orderByFieldName}', batch #{batchCount++}, count #{response.Resource.Result.Length}");
} while (continuationToken != null);
// 5. To take care of big response, loop until Response.continuation token is null (see OrderBy.js for details).
}
public async Task ExecuteSPGreeting(string name)
{
string message = "Execute SPGreeting";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
StoredProcedureExecuteResponse <string> sprocResponse = await scripts.ExecuteStoredProcedureAsync <string>("Greetings", new PartitionKey("/pizzaType"), new dynamic[] { name });
WriteLine($"SP Greeting Result: {sprocResponse.Resource}");
Printer.PrintLine(noOfTimes: (101 + message.Length));
}
public async Task ExecuteSPDeletePizza(string pizzaType, string pizzaId)
{
string message = "Execute SPDeletePizza";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
StoredProcedureExecuteResponse <string> sprocResponse = await scripts.ExecuteStoredProcedureAsync <string>("DeletePizza", new PartitionKey(pizzaType), new dynamic[] { pizzaId });
WriteLine($"SP DeletePizza Result: \n{JsonConvert.DeserializeObject(sprocResponse.Resource)}");
Printer.PrintLine(noOfTimes: (101 + message.Length));
}
public async Task ExecuteGetPizzaCount(string partitionKey)
{
string message = "Execute GetPizzaCount";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
StoredProcedureExecuteResponse <string> sprocResponse = await scripts.ExecuteStoredProcedureAsync <string>("GetPizzaCount", new PartitionKey($"{partitionKey}"), new dynamic[] { });
WriteLine($"SP GetPizzaCount Result: {JsonConvert.DeserializeObject(sprocResponse.Resource)}");
Printer.PrintLine(noOfTimes: (101 + message.Length));
}
public async Task ExecuteNonePkTest()
{
// Create a container in v2 without a partition key
string containerId = "SprocPkNone" + Guid.NewGuid().ToString();
ContainerInternal containerNonePk = await NonPartitionedContainerHelper.CreateNonPartitionedContainer(this.database, containerId);
Scripts scriptsNonePk = containerNonePk.Scripts;
string sprocId = Guid.NewGuid().ToString();
string sprocBody = @"function() {
var context = getContext();
var response = context.getResponse();
var collection = context.getCollection();
var collectionLink = collection.getSelfLink();
var filterQuery = 'SELECT * FROM c';
collection.queryDocuments(collectionLink, filterQuery, { },
function(err, documents) {
response.setBody(documents);
}
);
}";
StoredProcedureResponse storedProcedureResponse =
await scriptsNonePk.CreateStoredProcedureAsync(new StoredProcedureProperties(sprocId, sprocBody));
Assert.AreEqual(HttpStatusCode.Created, storedProcedureResponse.StatusCode);
StoredProcedureTests.ValidateStoredProcedureSettings(sprocId, sprocBody, storedProcedureResponse);
// Insert document and then query
string testPartitionId = Guid.NewGuid().ToString();
var payload = new { id = testPartitionId, user = testPartitionId };
ItemResponse <dynamic> createItemResponse = await containerNonePk.CreateItemAsync <dynamic>(payload);
Assert.AreEqual(HttpStatusCode.Created, createItemResponse.StatusCode);
StoredProcedureProperties storedProcedure = storedProcedureResponse;
StoredProcedureExecuteResponse <JArray> sprocResponse = await scriptsNonePk.ExecuteStoredProcedureAsync <JArray>(
sprocId,
Cosmos.PartitionKey.None,
parameters : null);
Assert.AreEqual(HttpStatusCode.OK, sprocResponse.StatusCode);
JArray jArray = sprocResponse;
Assert.AreEqual(1, jArray.Count);
Assert.AreEqual(testPartitionId, jArray[0]["id"]);
StoredProcedureResponse deleteResponse = await scriptsNonePk.DeleteStoredProcedureAsync(sprocId);
Assert.AreEqual(HttpStatusCode.NoContent, deleteResponse.StatusCode);
}
public async Task ExecuteSPCreateNewPizza(string pizzaType, string pizzaFileName)
{
string newPizza = File.ReadAllText($"Models/PizzaData/{pizzaFileName}.json");
string message = "Execute SPCreateNewPizza";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
StoredProcedureExecuteResponse <string> sprocResponse = await scripts.ExecuteStoredProcedureAsync <string>("CreateNewPizza", new PartitionKey(pizzaType), new dynamic[] { newPizza });
WriteLine($"SP Create New Pizza Result: \n{JsonConvert.DeserializeObject(sprocResponse.Resource)}");
Printer.PrintLine(noOfTimes: (100 + message.Length));
}
public async Task ExecuteSPBulkPizzaCreate(string pizzaFile, string partitionKey)
{
var jsonArray = JArray.Parse(File.ReadAllText($@"Models/PizzaData/PizzaCollection/{pizzaFile}PizzaCollection.json"));
string message = "Execute SPBulkPizzaCreate";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
StoredProcedureExecuteResponse <string> sprocResponse = await scripts.ExecuteStoredProcedureAsync <string>("BulkPizzaCreate", new PartitionKey($"{partitionKey}"), new dynamic[] { jsonArray });
WriteLine($"SP Bulk Pizza Create Result: \n{JsonConvert.DeserializeObject(sprocResponse.Resource)}");
Printer.PrintLine(noOfTimes: (100 + message.Length));
}
private static async Task Execute_spHelloWorld()
{
Console.WriteLine("\nExecute spHelloWorld stored procedure");
Scripts scripts = Shared.Client.GetContainer("mydb", "mystore").Scripts;
PartitionKey partitionKey = new PartitionKey(string.Empty);
StoredProcedureExecuteResponse <string> result = await scripts.ExecuteStoredProcedureAsync <string>("spHelloWorld", partitionKey, null);
string message = result.Resource;
Console.WriteLine($"Result: {message}");
}
protected async Task <StoredProcedureExecuteResponse <T> > ExecuteStoredProc <T>(Scripts client, string partitionId, CancellationToken cancellationToken, params object[] parameters)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(partitionId, nameof(partitionId));
StoredProcedureExecuteResponse <T> results = await client.ExecuteStoredProcedureAsync <T>(
FullName,
new PartitionKey(partitionId),
parameters,
cancellationToken : cancellationToken);
return(results);
}
public async Task ExecuteSPGetPizzas(string pizzaType = "Veg", decimal price = 300)
{
string message = "Execute SPGetPizzas";
Printer.PrintLine(message: message);
Scripts scripts = _container.Scripts;
StoredProcedureExecuteResponse <string> sprocResponse = await scripts.ExecuteStoredProcedureAsync <string>("GetPizzas", new PartitionKey(pizzaType), new dynamic[] { pizzaType, price });
// StoredProcedureExecuteResponse<string> sprocResponse = await scripts.ExecuteStoredProcedureAsync<string>("GetPizzas", new PartitionKey(pizzaType), new dynamic[] { pizzaType });
// StoredProcedureExecuteResponse<string> sprocResponse = await scripts.ExecuteStoredProcedureAsync<string>("GetPizzas", new PartitionKey(pizzaType), new dynamic[] { });
WriteLine($"SP Get VegPizza Result: \n{JsonConvert.DeserializeObject(sprocResponse.Resource)}");
Printer.PrintLine(noOfTimes: (101 + message.Length));
}
public async Task GetRequestChargeFromResource()
{
// <GetRequestCharge>
Container container = this.cosmosClient.GetContainer("database", "container");
string itemId = "myItem";
string partitionKey = "partitionKey";
string storedProcedureId = "storedProcedureId";
string queryText = "SELECT * FROM c";
ItemResponse <dynamic> itemResponse = await container.CreateItemAsync <dynamic>(
item : new { id = itemId, pk = partitionKey },
partitionKey : new PartitionKey(partitionKey));
double requestCharge = itemResponse.RequestCharge;
Scripts scripts = container.Scripts;
StoredProcedureExecuteResponse <object> sprocResponse = await scripts.ExecuteStoredProcedureAsync <object>(
storedProcedureId : storedProcedureId,
partitionKey : new PartitionKey(partitionKey),
parameters : new dynamic[] { new object() });
requestCharge = sprocResponse.RequestCharge;
FeedIterator <dynamic> feedIterator = container.GetItemQueryIterator <dynamic>(
queryText: queryText,
requestOptions: new QueryRequestOptions()
{
PartitionKey = new PartitionKey(partitionKey)
});
while (feedIterator.HasMoreResults)
{
FeedResponse <dynamic> feedResponse = await feedIterator.ReadNextAsync();
requestCharge = feedResponse.RequestCharge;
}
// </GetRequestCharge>
}
// </RunSimpleScript>
/// <summary>
/// Import many documents using stored procedure.
/// </summary>
// <RunBulkImport>
private static async Task RunBulkImport(Container container)
{
string inputDirectory = @".\Data\";
string inputFileMask = "*.json";
int maxFiles = 2000;
int maxScriptSize = 50000;
// 1. Get the files.
string[] fileNames = Directory.GetFiles(inputDirectory, inputFileMask);
DirectoryInfo di = new DirectoryInfo(inputDirectory);
FileInfo[] fileInfos = di.GetFiles(inputFileMask);
// 2. Prepare for import.
int currentCount = 0;
int fileCount = maxFiles != 0 ? Math.Min(maxFiles, fileNames.Length) : fileNames.Length;
// 3. Create stored procedure for this script.
string scriptId = "BulkImport";
string body = File.ReadAllText(@".\JS\BulkImport.js");
await TryDeleteStoredProcedure(container, scriptId);
Scripts cosmosScripts = container.Scripts;
StoredProcedureResponse sproc = await cosmosScripts.CreateStoredProcedureAsync(new StoredProcedureProperties(scriptId, body));
// 4. Create a batch of docs (MAX is limited by request size (2M) and to script for execution.
// We send batches of documents to create to script.
// Each batch size is determined by MaxScriptSize.
// MaxScriptSize should be so that:
// -- it fits into one request (MAX request size is 16Kb).
// -- it doesn't cause the script to time out.
// -- it is possible to experiment with MaxScriptSize to get best performance given number of throttles, etc.
while (currentCount < fileCount)
{
// 5. Create args for current batch.
// Note that we could send a string with serialized JSON and JSON.parse it on the script side,
// but that would cause script to run longer. Since script has timeout, unload the script as much
// as we can and do the parsing by client and framework. The script will get JavaScript objects.
string argsJson = CreateBulkInsertScriptArguments(fileNames, currentCount, fileCount, maxScriptSize);
dynamic[] args = new dynamic[] { JsonConvert.DeserializeObject <dynamic>(argsJson) };
// 6. execute the batch.
StoredProcedureExecuteResponse <int> scriptResult = await cosmosScripts.ExecuteStoredProcedureAsync <int>(
scriptId,
new PartitionKey("Andersen"),
args);
// 7. Prepare for next batch.
int currentlyInserted = scriptResult.Resource;
currentCount += currentlyInserted;
}
// 8. Validate
int numDocs = 0;
using (FeedIterator <dynamic> setIterator = container.GetItemQueryIterator <dynamic>())
{
while (setIterator.HasMoreResults)
{
FeedResponse <dynamic> response = await setIterator.ReadNextAsync();
numDocs += response.Count();
}
}
Console.WriteLine("Found {0} documents in the collection. There were originally {1} files in the Data directory\r\n", numDocs, fileCount);
}