OData - the Best Way to REST

OData 4.01 Committee Spec Approved

Thu, 01 Feb 2018 12:59:43 +0300

OData V4.01 was officially approved as a Committee Specification this week, marking the next step toward final standardization of the much anticipated extensions to OData V4.0.

OData v4.01 is a fully compatible extension of the OData V4.0 protocol that adopts many popular conventions, syntax and payload simplifications, and incorporates new functionality.

Some of the major enhancements in OData V4.01 include:

Model improvements. OData V4.01 services can support the following new metadata constructs:

Edm.Untyped – For specifying that a property may be any type. Supports representing things outside of the OData data model, such as variant typed properties, mixed collections, or collections of collections.
Keyless entity types for Singletons – entity types used as singletons, or singleton navigation properties, no longer need to have a defined key value
Specialization in Derived Types – Derived types can restrict properties of a base type to be a subtype of the property’s declared type.
Ordered Collections – Services can annotate a collection as being “Ordered”, and syntax is added for referencing a member of an ordered collection of primitive or complex types for the purposes of retrieval, update, or delete, as well as inserting into a given location within an ordered collection.
Optional Function Parameters – Function parameters can be annotated as optional. Optional parameters may be omitted when invoking the function.

Simplified URL patterns. OData V4.01 adds support for simplified URL syntax, including:

Key as Segment – Common semantics for representing keys within a URL as a segment, rather than enclosed in parenthesis.
Query Option Simplification – Query options are now case-insensitive, and can optionally omit the $ prefix.
Optional type prefix for Enums, Durations – Enum and duration values in a Url can be specified without the type prefix.
Simplified Operations – Operation names are now case-insensitive, and namespace qualification is optional.

New Query Features. OData V4.01 adds support for new query functionality, including:

Computed Properties – Support for projecting computed properties
Set Operations – Support for updating/deleting/invoking actions on resources matching a particular criteria
New “in” operator – Expressions containing many OR statements can be simplified with the new “in” operator
Filtered Count – $count can be computed on a filtered nested collection
In-lined stream properties – Stream properties can be requested inline within a payload
Delta Update Payloads – Delta payloads can now be used in updates to submit a set of changes, including nested changes, to a collection

Simplified OData JSON Payloads. OData V4.01 simplifies JSON payloads to look more like custom payloads, including:

Optional OData Prefix – OData Prefix may be omitted from control information
Default Namespaces – Services can declare default namespaces in order to omit namespace prefixes from instance annotations
Optionally Omit Null Values – Clients can specify a preference to reduce payload size by omitting null or default values.
Improved Async response message – In OData V4.0, completed async responses were wrapped as an application/http response message. In 4.01, clients can request async responses be returned unwrapped.
New delta payload representation – OData V4.01 introduces a simplified representation for delta payloads, including nested delta sets.

A JSON representation for CSDL Metadata. OData V4.01 defines a new JSON representation for CSDL Metadata.

A JSON representation for Batch payloads. OData V4.01 defines a new JSON representation for batch request and response payloads.

For a full description of the new features and conventions, see What’s New in OData V4.01.

Please take a look and send feedback to the OASIS OData TC.

About the Author

Michael Pizzo is Co-Chair of the OASIS OData Technical Committee and co-editor of the OASIS Standard documents. He has worked for over 30 years in the design and delivery of data access solutions and APIs at Microsoft as a key designer and driver of Microsoft’s Data Access APIs including ODBC, OLEDB, ADO.NET, ADO.NET Entity Framework, and OData.

Contact Michael Pizzo: www.linkedin.com/in/michaeljpizzo/

Follow on twitter @michael_pizzo

Whats New in REST APIs Seminar December 5 2017

Wed, 22 Nov 2017 12:59:43 +0300

Join experts from Progress and Gartner on Tuesday, December 5th, 2017, in a webinar on using OData to modernize enterprise data.

Deliver OData-based REST APIs to Modernize your Enterprise Data

REST APIs have grown exponentially over the past decade thanks to the rise of SaaS applications and highly integrated microservices architectures. Organizations are adopting REST API strategies to better integrate data assets with modern consumers across desktop, web and mobile applications.

To simplify the process of building and consuming their REST APIs, many enterprises have increasingly adopted OData, an OASIS/ISO approved standard. In the wake of new data privacy laws such as GDPR, organizations are once again looking for powerful REST APIs to access their systems of record in real-time without duplicating or moving sensitive customer data from their enterprise databases.

Join experts from Progress and Gartner to learn:

Why you should RESTify your database
What OData is and what’s new in the latest ISO-approved version
Different options for REST-enabling your databases

Plus—don’t miss our quick demo of provisioning OData without code.

Speakers:

Sanjeev Mohan, Research Director, Big Data and Advanced Analytics, Gartner
Mark Biamonte, Senior Software Architect and OData TC Editor, Progress
Nishanth Kadiyala, Product Marketing Specialist, Progress

Sign-up today for what promises to be an interesting webinar!

About the Author

Sumit Sarkar is the Chief Data Evangelist at Progress Software new to developing on the Salesforce platform. He has presented five Dreamforce sessions on data connectivity including the most recent session from DF16 on External Objects for External Big Data Platforms. Contact Sumit Sarkar:

www.linkedin.com/in/meetsumit

Visual Studio Code Knows OData

Wed, 02 Aug 2017 00:00:00 +0300

Visual Studio Code Knows OData

Through a new Visual Studio Code Extension for OData, developers can now get rich language support for the OData query language.

Enabled features include syntax highlighting and query encoding/decoding. Syntax aware formatting, metadata-driven code completion, and diagnostics are available in a beta state, and can be enabled through settings.

If you’re an OData developer using Visual Studio Code, this is a must-have extension. Give it a quick try, send feedback, and tell your friends!

About the Author

Michael Pizzo is Co-Chair of the OASIS OData Technical Committee and co-editor of the OASIS Standard documents. He has worked for almost 30 years in the design and delivery of data access solutions and APIs at Microsoft as a key designer and driver of Microsoft’s Data Access APIs including ODBC, OLEDB, ADO.NET, ADO.NET Entity Framework, and OData.

Contact Michael Pizzo:

www.linkedin.com/in/michaeljpizzo/

Follow on twitter @michael_pizzo

OData Published as an ISO Standard

Thu, 23 Feb 2017 00:00:00 +0300

OData 4.0 Published as ISO/IEC 20802

For those that missed the announcement, I’m thrilled to report that OData 4.0 has been ratified and published as an ISO/IEC Standard.

OData 4.0 was published as an OASIS Standard in February of 2014. OASIS submitted OData 4.0 (including Errata) to the ISO/IEC JTC 1 Information Technology body the following year, where it went through the standard review process before being unanimously approved in early 2016. The ISO/IEC publication became available early this year.

The OData 4.0 Core Protocol is available as ISO/IEC 20802-1:2016, and the OData 4.0 JSON Format is available as ISO/IEC 20802-2:2016.

ISO ratification confirms a higher level of interoperability, and is important to many government agencies worldwide for open data solutions.

I’d like to take a moment to thank and congratulate the many individuals who have contributed over the years to establishing OData as an International Standard.

Resources

OASIS Press Release: ISO/IEC JTC 1 Approves OASIS OData Standard for Open Data Exchange

ISO OData Standards Publications ISO/IEC 20802-1:2016 and ISO/IEC 20802-2:2016

OASIS OData Technical Committee

OData 4.0 OASIS Standard

OData JSON Format 4.0 OASIS Standard

About the Author

Contact Michael Pizzo:

www.linkedin.com/in/michaeljpizzo/

Follow on twitter @michael_pizzo

Webinar on Salesforce Connect External Object Reporting

Mon, 12 Dec 2016 00:00:00 +0300

Salesforce External Object Reporting with OData

Reporting against external objects has been highly anticipated based on numerous requests on the Idea on the success community. Back in Winter ‘16, Mark Kovacevich blogged on a popular workaround to use external objects for reporting with custom visual force pages and apex controllers. But starting in Winter ’17, there is much rejoicing among report geeks as the Salesforce Connect product team delivers a seamless reporting experience with external data made possible by support for a standard OData REST interface.

Ralf Schundelmeier Director of Product Management, Salesforce and Sumit Sarkar Chief Data Evangelist, Progress DataDirect will host a webinar with live Q&A and a demo of this new capability for Salesforce developers.

For a developer preview, below are screenshots of the high level steps from the Winter ’17 release notes on getting started with external object reporting. The external data in this example is accessed from an on-premises SQL Server data mart connected on-demand by the Progress DataDirect OData Reporting service for Salesforce Connect. Other popular reporting OData feeds are available with on-premises reporting platforms such as SAP Business Objects and SQL Server Reporting Services.

Preview on Creating Salesforce External Object Reports

1. Get started with an External Object Report

2. To expand on this, create a new report type that blends standard objects with external data

Webinar: Configuring Salesforce External Object Reports

Date: December 15, 2016

Time: 12:00 pm ET

During this webinar, you’ll get:

An introduction to external objects and their new capabilities for reporting and Wave trending
Steps to setup Salesforce reports with external data sources
Steps to produce OData from warehouses, marts, lakes and other reporting systems
Report considerations and limitations with Salesforce Connect

[Register for the Webinar]

Resources

About the Author

www.linkedin.com/in/meetsumit

OData Hackathon at API World

Mon, 12 Sep 2016 12:59:43 +0300

Progress DataDirect held the first known OData Hackathon this week at APIWorld 2016.

Participants built applications to integrate with voice assistant services like Microsoft Cortana and Amazon Alexa that used OData to pull and update data from Salesforce, Microsoft Dynamics CRM and Sugar CRM.

The winners, Echo Jokes, used facial recognition from the Microsoft Cognitive Services API to evaluate jokes retrieved from Salesforce and Sugar CRMs using OData.

Other contestants built applications for homebuyers to find listings based on personality, and for executives to leverage Alexa as a real-time secretary to assist with customer leads.

Check it out at https://www.progress.com/blogs/first-odata-hackathon-challenge-winner-at-apiworld!

Doing something exciting with OData? Don’t be shy – Let us know!

Recap on OData session for SAP Business Objects Universe

Thu, 07 Jul 2016 12:59:43 +0300

The OData road show continues with a stop at SAP Analytics conference, IBIS 2016 in Carlsbad, CA. The previous stop was the Progress DataDirect Partner Summit in Redwood City, CA where Michael Pizzo from the OData Technical Committee co-presented with me to talk about OData specification updates and adoption across V2 and V4.x.

For this event, we talked about the future of SAP Business Objects Universes in the context of data connectivity. Starting BO 4.1 SP2, SAP introduced OData support where the Universe semantic layer (UNX) serves as both a producer and consumer.

What this means for analytics professionals is that they can connect their favorite tools across SAP Lumira, Tableau, Spotfire or Microsoft PowerBI to access the Universe in a couple of clicks without having to install any client software. There is a requirement on the server side with BI Platform services for WebApplicationContainerServer and WebIntelligence ProcessingServer. And with support for Generic OData 2.0 Sources for the Universe, there is new potential to access any OData 2.0 endpoint on the backend such as those from the DataDirect Cloud OData Service.

This is an exciting development for the OData ecosystem and we can expect similar developments in semantic layers from other enterprise platforms across Oracle OBIEE RPD and IBM Cognos FM.

#We had a packed room and great Q&A:

What limitations are there for OData REST API as a data source?
Does it support connect live from Tableau?
When is OData 4.0 supported?
How would a PowerBI user connecting to the API be seen from a license perspective?
How much data could be extracted for data visualization before violating the license based on this info? “This API is solely for the purposes of accessing semantic data, so you can’t use the API for mass data/metadata extraction, for bypassing SAP licensing, or for reverse-engineering a Universe.”
Download session from Slideshare
Learn more from the SAP Semantic Layer Product Team

#Let’s Connect:

Sumit Sarkar, Chief Data Evangelist

Progress Software

@SAsInSumit

OData JavaScript library - o.js explained

Tue, 23 Feb 2016 01:14:00 +0300

o.js is a small (minified 14.4 KB) client-side library for requesting data from an OData service. It is designed to run in a browser environment, however it also runs in node.js. In a browser environment it has no dependencies on other libraries and can be used standalone. The main goal of the library is, to provide a simple solution to query OData services from any browser. If you like to use it you can install it via npm install odata or just download the o.min.js file from this GitHub repository and add it to your webpage in a <script>-tag.

In this tutorial I will show you how easy you can use it in your web application and explain to you the example app. This application using some extended routing functionalities of o.js in combination with knockout.js to display detailed information about the OData TripPinService, a example service provided by odata.org.

Getting started with o.js

The installation of o.js is simple. You just need to include the o.js file into your page and you are ready to query OData services:

<script src="path/to/o.min.js"></script>

o.js adds a o() function to the global namespace. This function can be used to define a query. It returns a oHandler, which then allows to retrive, change or push data to the service:

var oHandler = o('https://services.odata.org/V4/(S(wptr35qf3bz4kb5oatn432ul))/TripPinServiceRW/People');
oHandler.get(function(data) {
    console.log(data); // data of the TripPinService/People endpoint
});

The example above shows how to get the data from the defined handler with the get() function. The get()-function accepts an success- and error-callback to get the return of the request. If you prefer to use promise, you can use q.js. The following example shows how to get data from the endpoint and manipulate the result with promise:

o('https://services.odata.org/V4/(S(wptr35qf3bz4kb5oatn432ul))/TripPinServiceRW/People(\'Russell Whyte\')').get().then(function(result) {
	result.data.FirstName = 'New Name';
	return(result.save());
}).then(function(result) {
    console.log('First name is now New Name');
});

If you include q.js you can call the get() function without a callback and it returns a promise. The data is then stored in a o.data which you can manipulate and save by calling save(). The save() itself is used for POST and PUT request to the database and returns a second promise. This way the function above requested a resource, manipulates it and saves the manipulated data back to the service.

As you can see the requested service URL is quite long. If you use o.js to query one endpoint often you can configure o.js to use the same endpoint all the time:

o().config({
	endpoint: 'https://services.odata.org/V4/(S(ms4wufavzmwsg3fjo3eqdgak))/TripPinServiceRW/'
});

From now on you can use only the resource name to query an endpoint. The following example uses the configured endpoint and the save() function to POST, PUT and DELETE data to the TripPinService:

    o('People').post({
            UserName:name,
            FirstName:'foo',
            LastName:'bar'
    }).save().then(function(result) {
        // Because o.js does not know which key to use, you need to initialize a new handler
        var oHandler = o('People')
            .find(('\'' + result.data.UserName + '\''))
            .patch({ FirstName: 'new name' });
        return(oHandler.save());
    }).then(function(result) {
        result.delete();
        return(result.save());
    }).then(function() {
       console.log('A person was added, modified and deleted.');
    });

In the promise chain above o.js first adds a new user using post() and saves it to the service. When this is promised we initializing a new handler to find the person which was added and modify him with the patch() function. Afterwards we delete him from the service by using the delete() function.

Chaining the query

We already used the chained function find() to find a specific person. o.js allows multiple functions to detail your query. The find() is a special case, because it allows to find a specific resource by the key. But you can also use functions to limit the result. For example you can chain your query with .skip(2).take(5) to request only the first 5 rows skipped by the first 2 rows. There are many more chained function and you can find a complete list in the o.js readme. Mostly you will use the where function to find something:

o('People').where('FirstName == "foo"').get(function(data) {
    console.log(data); //all persons where the firstname is "foo"
});

Note: o.js automatically maps some basic operations from JavaScript to OData. For complex where request, you need to use the OData equivalent (e.g. FirstName eq "foo").

As mentioned you can chain multiple functions to build a query. The following example shows a pagination function which expands the result with the Trip result:

function loadNextPage(skip) {
    o('People').expand('Trips').skip(skip).take(5).get(function(data) {
        console.log(data); // 5 People skipped by the function parameter and extended by "Trips"
    });
}

Complex pages with routing

o.js has a build in hash-routing functionality. This allows you to map a oHandler to a route. It allows an easy way to display data from a OData service on a Single Page Application. The o.js example uses the TripPinService, knockout.js and only 70 lines of code to display some useful information from the page.

For the example we will use the route() function of o.js and bind the data to the DOM with knockout.js. I will not go in detail of knockout.js. If you want to learn more about knockout, you should try the excellent tutorials on knockoutjs.com.

If you try the example you will see a top navigation point People. This is basically a typical html hash-link <a href="#People">People</a> which does not change anything. But if we register a o.js route on this hash value, o.js automatically triggers the request to the configured endpoint. Therefore we first configure the endpoint:

    // initialize the ko observables
	self.People=ko.observableArray([]);
	self.route=ko.observable('');
	self.detailPeople=ko.observable();
	self.isLoading=ko.observable(false);

	// configure the endpoint and define what to do while loading
	o().config({
		endpoint:'https://services.odata.org/V4/%28S%28wptr35qf3bz4kb5oatn432ul%29%29/TripPinServiceRW/',
		start:function() {
			self.isLoading(true);
		},
		ready:function() {
			self.isLoading(false);
		}
	});

The start and ready function defines what should be done when the request starts and what to do if the request ends. Here we just set a ko observable to true while the request is processed. We will later bind it to the DOM to display a loading spinner.

Note: The self object is a reference to this. This is usually done in knockout ViewModels-Function. For easier understanding the ViewModel-Function is left out here. You can find the full file here.

Afterwards you can define a route to map to the #People hash:

o('People').route('People', function(data) {
		self.route('People');
		self.People(data);
});

The first parameter of the route function is a string that maps to the hash. The second parameter is a callback that is triggered as soon as the first parameter and the hash is equal and the request to the OData service is done. When you now click on the top navigation link the callback gets triggered with the Data from the TripPinService. This callback then sets the knockout observable self.route to ‘People’ and adds the data to the observableArray self.People. Afterwards you only need to bind the data to your DOM with the knockout data-bind property:

<div data-bind="visible:route()==='People'">
	<!-- ko foreach: People -->
		<h4 data-bind="text:FirstName"></h4>
		<h2 data-bind="text:LastName"></h4>
		<a role="button" class="btn btn-primary" data-bind="attr { href:'#People/Detail/'+UserName }">Details</a>
	<!-- /ko -->
  </div>

The self.route parameter is used to handle the visibility of a route. We then bind all the People returned by the OData service with the ko foreach statement. In this statement we display the FirstName and LastName property to headings. Also we bind a href hash-link to the route #People/Detail/ + UserName. To handle this route we register a second o.js route-handler:

o('People').where('UserName == \':0\'').expand('Trips').first().route('People/Detail/:0', function(data) {
		self.route('Detail');
		self.detailPeople(data);
	});

The added route is a dynamic route. With :0 the dynamic part of the route is defined. This dynamic part is added to the OData request as soon as the route matches. So for example, if you navigate to the hash #People/Detail/russellwhyte the service request the resource /People/?$format=json&$filter=UserName%20%20eq%20%20%27russellwhyte%27&$expand=Trips&$top=1. You can add multiple dynamic parts by defining them with :0, :1, :2 etc.

As you can see this routing also expands the Trips resource and saves all to the knockout observable detailPeople. Therefore we can display the Trips of the person in the details by using the following DOM binding:

<div data-bind="visible:route()==='Detail',with:detailPeople">
    <div class="jumbotron">
        <h1 data-bind="text:FirstName + ' ' + LastName "></h1>
    </div>

	<table class="table table-hover">
		  <tbody>
			<!-- ko foreach: Trips -->
        		<tr>
        			<td data-bind="text:Name"></td>
        			<td data-bind="text:Description"></td>
        		</tr>
			<!-- /ko -->
		</tbody>
    </table>
</div>

That’s all to display people from the TripPin-Example service and their Trips. With the post, put and delete functions, explained in the beginning of this post, you can now add, modify or delete this data. In the full example you can find an example to delete Trips of a user.

One last thing is the loading animation. That is quite easy to do, because we already defined the self.isLoading observable. By simply binding this to the DOM we can show a loading spinner to the user:

<div class="loading" data-bind="visible:isLoading()">
	<div class="jumbotron" >
		<img src="img/ajax-loader.gif" alt="Loading ...">
		<p>Loading ...</p>
	</div>
</div>

Conclusion

o.js is a simple way to query OData services fast. It allows to add CRUD operations on any OData-Service easily into your page. So everything perfect? Sadly not. o.js is not a complete OData-Solution. It only supports the basic OData functions and is not suitable for complex scenarios. For example the batch operation is only supported rudimentary and ETag are not supported. However, if you need a quick request or want to display some OData service on a simple webpage, o.js is the right choice.

Links:

Webinar: External data integration strategies

Wed, 13 Jan 2016 11:17:23 +0300

The following is a post by Mark Stafford of Microsoft’s OData team.

Join us on January 19th at 1:00pm Eastern Time for a webinar discussing external data integration strategies. This webinar is free of charge and hosted by Progress Software, Oracle, and Microsoft. To register for the webinar, please follow this link: https://forms.progress.com/wbr-odata-integration-for-saas.

Self-service integration and the explosion of data sources are driving OData adoption from leading SaaS vendors.

Why have Salesforce and Oracle adopted OData for external data integration strategies with SaaS applications? Because OData hybrid connectivity gives direct access to a wide range of external data sources that can be integrated directly “out-of-box” with the ease of point-and-click. And citizen developers increasingly demand easy, point-and-click integration patterns that link their SaaS applications directly to external data. With tight deadlines to deliver data-driven features to SaaS users, find out why OData connectivity is gaining ground on traditional data integration patterns.

Join us for a live demo to see how OData hybrid data connectivity enables self service integration with Oracle Service Cloud Accelerators and Salesforce Connect, both powered by OData.

Webinar Title: OData External Data Integration Strategies For SaaS
Date: January 19, 2016
Time: 1:00 p.m. ET
Presenters:

Roderick Peace, Director Product Management, Oracle Service Cloud
Mike Pizzo, Principal Software Architect, Microsoft
Sumit Sarkar, Chief Data Evangelist, Progress DataDirect

During this webinar, you’ll:

Gain a clear understanding from Microsoft of the OData ecosystem across consumers and producers
Learn why the OData standard was selected as an external data integration pattern for Oracle Service Cloud
See firsthand how OData hybrid data connectivity enables point-and-click integration to external data of all shapes and sizes, deployed on-premise or cloud

Enabling Innovation: Making NSW Biodiversity Data Open

Mon, 30 Nov 2015 12:59:43 +0300

The following is a guest post by James Bibby of NSW Office of Environment & Heritage. The views expressed and statements made are those of Biodiversity Information Systems and not of OData.org or its administrators.

The NSW Office of Environment and Heritage has recently opened up its massive store of biodiversity data to IT developers using an OData based web service. This first release of BioNet Web Services makes over 7 million species sightings records available for direct access by software applications enabling open innovation on this valuable public resource.

##Why was OData selected?##

OEH’s Science Division had a clear aim of improving both environmental decision making and engagement with the natural environment through open data. To achieve this aim the project team realised that making the data openly accessible was only one of the barriers to active usage of the data. Their evaluation of existing APIs for biodiversity data indicated that up front and long term development costs, both to learn and develop against proprietary APIs, introduced additional barriers to use.

By adopting the OASIS OData standard for the BioNet web service, the project team saw that these barriers could be significantly reduced. IT developers wishing to consume data via the OData API would be able to easily access a range of pre-existing libraries across a range of platforms, and in addition tap into existing online developer communities to support their development.

Realisation of these benefits was borne out by Gaia Guide, one of the early adopters of the service who use the Apache Olingo Library. “The API is really nice and transparent”, commented Geoff Shuetrim, Director at GaiaGuide. “It took us 2 hours of development effort to connect to the BioNet web service compared with nearly a week for any other web service we have connected to.”

An extract of all sightings for Clarence Valley Local Government Area retrieved using Power Query for Excel and displayed via Power Map for Excel

##What next?##

The project team continues to work on making more biodiversity data held in BioNet openly available. Release 2 is targeted this coming year, and will add data held on vegetation communities.

##Where can I find out more?##

More information, including developer guides, can be found at data.bionet.nsw.gov.au

James Bibby

Senior Scientist, Biodiversity Information Systems