Store data in google sheets from Azure functions - azure

Question

I am trying to insert data into google sheets from azure functions.
In the azure function, integrate tab I selected new Output as External Table and selected googleSheets and a connection string was created. But I don't see any documents showing how we can read/insert data from/into the excel sheets. Any quick sample for jump start?

Answer 1

Below is a simple example of using Azure function bindings to tabular connectors. I have verified that it works with SQL Server, Google Sheets and Salesforce. Theoretically it should work with any tabular connector as long as it implements the Connector Data Protocol (CDP).
Develop
#r "Microsoft.Azure.ApiHub.Sdk"
#r "Newtonsoft.Json"
using System;
using Microsoft.Azure.ApiHub;
public class Contact
{
public string Id { get; set; }
public string LastName { get; set; }
public string FirstName { get; set; }
}
public static async Task Run(string input, ITable<Contact> table, TraceWriter log)
{
ContinuationToken continuationToken = null;
do
{
var contactsSegment = await table.ListEntitiesAsync(
continuationToken: continuationToken);
foreach (var contact in contactsSegment.Items)
{
log.Info(string.Format("{0} {1}", contact.FirstName, contact.LastName));
}
continuationToken = contactsSegment.ContinuationToken;
}
while (continuationToken != null);
}
For simplicity the example uses a manual trigger. The trigger’s input value is not used.
The example assumes that the connector provides a Contact table with Id, LastName and FirstName columns. The code lists the Contact entities in the table and logs the first and last names.
Integrate
{
"bindings": [
{
"type": "manualTrigger",
"direction": "in",
"name": "input"
},
{
"type": "apiHubTable",
"direction": "in",
"name": "table",
"connection": "ConnectionAppSettingsKey",
"dataSetName": "default",
"tableName": "Contact",
"entityId": "",
}
],
"disabled": false
}
ConnectionAppSettingsKey identifies the app setting that stores the connection string.
A tabular connector provides data sets, and each data set contains tables. The name of the default data set is “default”. These concepts are identified by dataSetName and tableName and are specific to each connector:
Connector Dataset Table
SharePoint Site SharePoint List
SQL Database Table
Google Sheet Spreadsheet Worksheet
Excel Excel file Sheet
entityId must be empty for table bindings.
Bindings
The table binding (exemplified above) is probably the most useful. Here is the full list of supported C# bindings, with their requirements:
Table Client
The parameter type must be ITableClient.
dataSetName, tableName and entityId must be empty.
Table
The parameter type must be ITable (TEntity is a POCO type), ITable, IAsyncCollector or IAsyncCollector. dataSetName and tableName must be provided. entityId must be empty.
Entity
The parameter type must be TEntity (POCO type) or JObject. dataSetName, tableName and entityId must be provided.
 
Interfaces
public interface ITableClient
{
/// <summary>
/// Gets a reference to a data set.
/// </summary>
/// <param name="dataSetName">The name of the data set.</param>
/// <returns>The data set reference.</returns>
IDataSet GetDataSetReference(string dataSetName = null);
/// <summary>
/// Queries the table client for data sets.
/// </summary>
/// <param name="query">The query to be executed.</param>
/// <param name="continuationToken">A continuation token from the server
/// when the operation returns a partial result.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns>The retrieved data sets. In case of partial result the
/// object returned will have a continuation token.</returns>
Task<SegmentedResult<IDataSet>> ListDataSetsAsync(
Query query = null,
ContinuationToken continuationToken = null,
CancellationToken cancellationToken = default(CancellationToken));
}
 
public interface IDataSet
{
/// <summary>
/// Gets the data set name.
/// </summary>
string DataSetName { get; }
/// <summary>
/// Gets the data set display name.
/// </summary>
string DisplayName { get; }
/// <summary>
/// Gets a reference to a table.
/// </summary>
/// <typeparam name="TEntity">The type of entities in the table.</typeparam>
/// <param name="tableName">The name of the table.</param>
/// <returns>The table reference.</returns>
ITable<TEntity> GetTableReference<TEntity>(string tableName)
where TEntity : class;
/// <summary>
/// Queries the data set for tables.
/// </summary>
/// <param name="query">The query to be executed.</param>
/// <param name="continuationToken">A continuation token from the server
/// when the operation returns a partial result.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns>The retrieved tables. In case of partial result the
/// object returned will have a continuation token.</returns>
Task<SegmentedResult<ITable<JObject>>> ListTablesAsync(
Query query = null,
ContinuationToken continuationToken = null,
CancellationToken cancellationToken = default(CancellationToken));
}
 
public interface ITable<TEntity>
where TEntity : class
{
/// <summary>
/// Gets the data set name.
/// </summary>
string DataSetName { get; }
/// <summary>
/// Gets the table name.
/// </summary>
string TableName { get; }
/// <summary>
/// Gets the table display name.
/// </summary>
string DisplayName { get; }
/// <summary>
/// Retrieves table metadata.
/// </summary>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns>The table metadata.</returns>
Task<TableMetadata> GetMetadataAsync(
CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Retrieves the entity with the specified identifier.
/// </summary>
/// <param name="entityId">The entity identifier.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns>The entity or null if not found.</returns>
Task<TEntity> GetEntityAsync(
string entityId,
CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Queries the table for entities.
/// </summary>
/// <param name="query">The query to be executed.</param>
/// <param name="continuationToken">A continuation token from the server
/// when the operation returns a partial result.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns>The retrieved entities. In case of partial result the
/// object returned will have a continuation token.</returns>
Task<SegmentedResult<TEntity>> ListEntitiesAsync(
Query query = null,
ContinuationToken continuationToken = null,
CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Adds a new entity to the table.
/// </summary>
/// <param name="entity">The entity to be created.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns></returns>
Task CreateEntityAsync(
TEntity entity,
CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Updates an existing entity.
/// </summary>
/// <param name="entityId">The entity identifier.</param>
/// <param name="entity">The updated entity.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns></returns>
Task UpdateEntityAsync(
string entityId,
TEntity entity,
CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
/// Deletes an existing entity.
/// </summary>
/// <param name="entityId">The entity identifier.</param>
/// <param name="cancellationToken">A cancellation token that can be used
/// by other objects or threads to receive notice of cancellation.</param>
/// <returns></returns>
Task DeleteEntityAsync(
string entityId,
CancellationToken cancellationToken = default(CancellationToken));
}
 
Notes
Here are some instructions to try the example:
SQL Server
The script to create and populate the Contact table is below. dataSetName is “default”.
CREATE TABLE Contact
(
Id int NOT NULL,
LastName varchar(20) NOT NULL,
FirstName varchar(20) NOT NULL,
CONSTRAINT PK_Contact_Id PRIMARY KEY (Id)
)
GO
INSERT INTO Contact(Id, LastName, FirstName)
VALUES (1, 'Bitt', 'Prad')
GO
INSERT INTO Contact(Id, LastName, FirstName)
VALUES (2, 'Glooney', 'Ceorge')
GO
Google Sheets
In Google docs create a spreadsheet with a worksheet named Contact. The connector cannot use the spreadsheet display name. The internal name (in bold) needs to be used as dataSetName, for example: https://docs.google.com/spreadsheets/d/1UIz545JF_cx6Chm_5HpSPVOenU4DZh4bDxbFgJOSMz0
Add the column names Id, LastName, FirstName to the first row, the populate with data on subsequent rows.
Salesforce
dataSetName is “default”.

Answer 2

There are some samples here: https://github.com/Azure/azure-webjobs-sdk-templates/tree/dev/Functions.Templates/Templates/ExternalTable-CSharp
Thanks