Java StoredProcedure类代码示例

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
private RxDocumentServiceRequest getStoredProcedureRequest(String collectionLink, StoredProcedure storedProcedure,
        RequestOptions options, OperationType operationType) {
    if (StringUtils.isEmpty(collectionLink)) {
        throw new IllegalArgumentException("collectionLink");
    }
    if (storedProcedure == null) {
        throw new IllegalArgumentException("storedProcedure");
    }

    validateResource(storedProcedure);

    String path = Utils.joinPath(collectionLink, Paths.STORED_PROCEDURES_PATH_SEGMENT);
    Map<String, String> requestHeaders = this.getRequestHeaders(options);
    RxDocumentServiceRequest request = RxDocumentServiceRequest.create(operationType, ResourceType.StoredProcedure,
            path, storedProcedure, requestHeaders);
    return request;
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> createStoredProcedure(String collectionLink,
        StoredProcedure storedProcedure, RequestOptions options) {

    return Observable.defer(() -> {
        // we are using an observable factory here
        // observable will be created fresh upon subscription
        // this is to ensure we capture most up to date information (e.g.,
        // session)
        try {

            logger.debug("Creating a StoredProcedure. collectionLink: [{}], storedProcedure id [{}]",
                    collectionLink, storedProcedure.getId());
            RxDocumentServiceRequest request = getStoredProcedureRequest(collectionLink, storedProcedure, options,
                    OperationType.Create);

            return this.doCreate(request).map(response -> toResourceResponse(response, StoredProcedure.class));

        } catch (Exception e) {
            // this is only in trace level to capture what's going on
            logger.debug("Failure in creating a StoredProcedure due to [{}]", e.getMessage(), e);
            return Observable.error(e);
        }
    });
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> upsertStoredProcedure(String collectionLink,
        StoredProcedure storedProcedure, RequestOptions options) {
    return Observable.defer(() -> {
        // we are using an observable factory here
        // observable will be created fresh upon subscription
        // this is to ensure we capture most up to date information (e.g.,
        // session)
        try {

            logger.debug("Upserting a StoredProcedure. collectionLink: [{}], storedProcedure id [{}]",
                    collectionLink, storedProcedure.getId());
            RxDocumentServiceRequest request = getStoredProcedureRequest(collectionLink, storedProcedure, options,
                    OperationType.Upsert);

            return this.doUpsert(request).map(response -> toResourceResponse(response, StoredProcedure.class));

        } catch (Exception e) {
            // this is only in trace level to capture what's going on
            logger.debug("Failure in upserting a StoredProcedure due to [{}]", e.getMessage(), e);
            return Observable.error(e);
        }
    });
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Test(groups = { "simple" }, timeOut = TIMEOUT)
public void createStoredProcedure() throws Exception {

    // create a stored procedure
    StoredProcedure storedProcedureDef = new StoredProcedure();
    storedProcedureDef.setId(UUID.randomUUID().toString());
    storedProcedureDef.setBody("function() {var x = 10;}");

    Observable<ResourceResponse<StoredProcedure>> createObservable = client.createStoredProcedure(getCollectionLink(), storedProcedureDef, null);

    // validate stored procedure creation
    ResourceResponseValidator<StoredProcedure> validator = new ResourceResponseValidator.Builder<StoredProcedure>()
            .withId(storedProcedureDef.getId())
            .withBody("function() {var x = 10;}")
            .notNullEtag()
            .build();
    validateSuccess(createObservable, validator);
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Test(groups = { "simple" }, timeOut = TIMEOUT)
public void readStoredProcedure() throws Exception {
    // create a stored procedure
    StoredProcedure storedProcedureDef = new StoredProcedure();
    storedProcedureDef.setId(UUID.randomUUID().toString());
    storedProcedureDef.setBody("function() {var x = 10;}");
    StoredProcedure storedProcedure = client.createStoredProcedure(getCollectionLink(), storedProcedureDef, null).toBlocking().single().getResource();

    // read stored procedure
    Observable<ResourceResponse<StoredProcedure>> readObservable = client.readStoredProcedure(storedProcedure.getSelfLink(), null);


    ResourceResponseValidator<StoredProcedure> validator = new ResourceResponseValidator.Builder<StoredProcedure>()
            .withId(storedProcedureDef.getId())
            .withBody("function() {var x = 10;}")
            .notNullEtag()
            .build();
    validateSuccess(readObservable, validator);
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Test(groups = { "simple" }, timeOut = TIMEOUT)
public void deleteStoredProcedure() throws Exception {
    // create a stored procedure
    StoredProcedure storedProcedureDef = new StoredProcedure();
    storedProcedureDef.setId(UUID.randomUUID().toString());
    storedProcedureDef.setBody("function() {var x = 10;}");
    StoredProcedure storedProcedure = client.createStoredProcedure(getCollectionLink(), storedProcedureDef, null).toBlocking().single().getResource();

    // delete
    Observable<ResourceResponse<StoredProcedure>> deleteObservable = client.deleteStoredProcedure(storedProcedure.getSelfLink(), null);

    // validate
    ResourceResponseValidator<StoredProcedure> validator = new ResourceResponseValidator.Builder<StoredProcedure>()
            .nullResource()
            .build();
    validateSuccess(deleteObservable, validator);

    //TODO validate after deletion the resource is actually deleted (not found)
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Test
public void executeStoredProcWithArgs() throws DocumentClientException {
    // create stored procedure
    StoredProcedure storedProcedure = new StoredProcedure(
            "{" +
                    "  'id': 'multiplySample'," +
                    "  'body':" +
                    "    'function (value, num) {" +
                    "      getContext().getResponse().setBody(" +
                    "          \"2*\" + value + \" is \" + num * 2 );" +
                    "    }'" +
            "}");

    client.createStoredProcedure(collection.getSelfLink(), storedProcedure, null).getResource();

    // execute stored procedure
    RequestOptions requestOptions = new RequestOptions();
    requestOptions.setPartitionKey(new PartitionKey("Seattle"));

    String storedProcLink = String.format("/dbs/%s/colls/%s/sprocs/%s", databaseId, collectionId, "multiplySample");

    Object[] storedProcedureArgs = new Object[] {"a", 123};
    String storedProcResultAsString = client.executeStoredProcedure(storedProcLink, requestOptions, storedProcedureArgs).getResponseAsString();
    assertThat(storedProcResultAsString, equalTo("\"2*a is 246\""));
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
/**
 * Executes the bulk import stored procedure for a list of documents.
 * The execution takes into consideration throttling and blacklisting of the stored procedure.
 * @param client The DocumentClient instance for DocumentDB
 * @param collectionSelfLink the self-link for the collection to write to.
 * @param sproc The stored procedure to execute
 * @param allDocs The list of documents to write
 * @param upsert  Specifies whether to replace the document if exists or not. By default it's true.
 */
public static void executeWriteStoredProcedure(final DocumentClient client, String collectionSelfLink, final StoredProcedure sproc,
        List<Document> allDocs, final boolean upsert) {
    
    int currentCount = 0;
        
    while (currentCount < allDocs.size())
        {
        String []jsonArrayString = CreateBulkInsertScriptArguments(allDocs, currentCount, MAX_SCRIPT_SIZE);
        BackoffExponentialRetryPolicy retryPolicy = new BackoffExponentialRetryPolicy();
        String response = null;
        while(retryPolicy.shouldRetry()){
            try {
                response = client.executeStoredProcedure(sproc.getSelfLink(), new Object[] { jsonArrayString, upsert })
                    .getResponseAsString();
                break;
            } catch(Exception e){
                retryPolicy.errorOccured(e);  
            }
        }

        int createdCount = Integer.parseInt(response);
        currentCount += createdCount;
    }
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
public DocumentDBRecordWriter(Configuration conf, String host, String key, String dbName, String[] collNames,
        int outputStringPrecision, boolean upsert, String offerType) throws IOException {
    try {
        ConnectionPolicy policy = ConnectionPolicy.GetDefault();
        policy.setUserAgentSuffix(DocumentDBConnectorUtil.UserAgentSuffix);
        DocumentClient client = new DocumentClient(host, key, policy,
                ConsistencyLevel.Session);

        Database db = DocumentDBConnectorUtil.GetDatabase(client, dbName);
        this.collections = new DocumentCollection[collNames.length];
        this.sprocs = new StoredProcedure[collNames.length];
        for (int i = 0; i < collNames.length; i++) {
            this.collections[i] =  DocumentDBConnectorUtil.getOrCreateOutputCollection(client, db.getSelfLink(), collNames[i],
                    outputStringPrecision, offerType);
            this.sprocs[i] = DocumentDBConnectorUtil.CreateBulkImportStoredProcedure(client, this.collections[i].getSelfLink());
        }
        
        this.client = client;
        this.enableUpsert = upsert;
        this.cachedDocs = new LinkedList<Document>();
    } catch (Exception e) {
        e.printStackTrace();
        throw new IOException(e);
    }
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> deleteStoredProcedure(String storedProcedureLink,
        RequestOptions options) {
    return Observable.defer(() -> {
        // we are using an observable factory here
        // observable will be created fresh upon subscription
        // this is to ensure we capture most up to date information (e.g.,
        // session)
        try {

            if (StringUtils.isEmpty(storedProcedureLink)) {
                throw new IllegalArgumentException("storedProcedureLink");
            }

            logger.debug("Deleting a StoredProcedure. storedProcedureLink [{}]", storedProcedureLink);
            String path = Utils.joinPath(storedProcedureLink, null);
            Map<String, String> requestHeaders = this.getRequestHeaders(options);
            RxDocumentServiceRequest request = RxDocumentServiceRequest.create(OperationType.Delete,
                    ResourceType.StoredProcedure, path, requestHeaders);

            return this.doDelete(request).map(response -> toResourceResponse(response, StoredProcedure.class));

        } catch (Exception e) {
            // this is only in trace level to capture what's going on
            logger.debug("Failure in deleting a StoredProcedure due to [{}]", e.getMessage(), e);
            return Observable.error(e);
        }
    });
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> readStoredProcedure(String storedProcedureLink,
        RequestOptions options) {

    return Observable.defer(() -> {
        // we are using an observable factory here
        // observable will be created fresh upon subscription
        // this is to ensure we capture most up to date information (e.g.,
        // session)
        try {

            if (StringUtils.isEmpty(storedProcedureLink)) {
                throw new IllegalArgumentException("storedProcedureLink");
            }

            logger.debug("Reading a StoredProcedure. storedProcedureLink [{}]", storedProcedureLink);
            String path = Utils.joinPath(storedProcedureLink, null);
            Map<String, String> requestHeaders = this.getRequestHeaders(options);
            RxDocumentServiceRequest request = RxDocumentServiceRequest.create(OperationType.Read,
                    ResourceType.StoredProcedure, path, requestHeaders);

            return this.doRead(request).map(response -> toResourceResponse(response, StoredProcedure.class));

        } catch (Exception e) {
            // this is only in trace level to capture what's going on
            logger.debug("Failure in reading a StoredProcedure due to [{}]", e.getMessage(), e);
            return Observable.error(e);
        }
    });

}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> createStoredProcedure(final String collectionLink, final
        StoredProcedure storedProcedure, final RequestOptions options) {
    return this.createResourceResponseObservable(new ImplFunc<ResourceResponse<StoredProcedure>>() {
        @Override
        public ResourceResponse<StoredProcedure> invoke() throws Exception {
            return client.createStoredProcedure(collectionLink, storedProcedure, options);
        }
    });
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> upsertStoredProcedure(final String collectionLink, final
        StoredProcedure storedProcedure, final RequestOptions options) {
    return this.createResourceResponseObservable(new ImplFunc<ResourceResponse<StoredProcedure>>() {
        @Override
        public ResourceResponse<StoredProcedure> invoke() throws Exception {
            return client.upsertStoredProcedure(collectionLink, storedProcedure, options);
        }
    });
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> replaceStoredProcedure(final StoredProcedure storedProcedure, final
        RequestOptions options) {
    return this.createResourceResponseObservable(new ImplFunc<ResourceResponse<StoredProcedure>>() {
        @Override
        public ResourceResponse<StoredProcedure> invoke() throws Exception {
            return client.replaceStoredProcedure(storedProcedure, options);
        }
    });
}
 

import com.microsoft.azure.documentdb.StoredProcedure; //导入依赖的package包/类
@Override
public Observable<ResourceResponse<StoredProcedure>> deleteStoredProcedure(final String storedProcedureLink, final
        RequestOptions options) {
    return this.createResourceResponseObservable(new ImplFunc<ResourceResponse<StoredProcedure>>() {
        @Override
        public ResourceResponse<StoredProcedure> invoke() throws Exception {
            return client.deleteStoredProcedure(storedProcedureLink, options);
        }
    });
}