Everything about Winfs totally explained
WinFS (short for
Windows Future Storage) is the
code name for a data storage and
management system based on
relational databases, developed by
Microsoft and first demonstrated in 2003 as an advanced storage subsystem for the
Microsoft Windows operating system, being designed for
persistence and management of
structured,
semi-structured as well as
unstructured data. WinFS includes a
relational database for storage of information, and allows any type of information to be stored in it, provided there's a well defined
schema for the type. Individual data items could then be related together by relationships, which are either inferred by the system based on certain attributes or explicitly stated by the user. As the data has a well defined schema, any application can reuse the data; and using the relationships, related data can be effectively organized as well as retrieved. Because the system knows the structure and intent of the information, it can be used to make complex queries that enable advanced searching through the data and aggregating various data items by exploiting the relationships between them.
While WinFS and its shared type schema makes it possible for an application to recognize the different data types, the application still has to be coded to render the different data types. Consequently, it wouldn't allow development of a single application that can view or edit all data types; rather what WinFS enables is applications to understand the structure of all data and extract the information that it can use further. When WinFS was introduced at the 2003
Professional Developers Conference, Microsoft also released a video presentation, named IWish, showing mockup interfaces that showed how applications would expose interfaces that takes advantage of a unified type system. The concepts shown in the video ranged from applications using the relationships of items to dynamically offer filtering options to applications grouping multiple related data types and rendering them in an unified presentation.
WinFS was billed as one of the pillars of the
"Longhorn" wave of technologies, and would ship as part of the next version of Windows. It was subsequently decided that WinFS would ship after the release of
Windows Vista, but those plans were shelved in June 2006, with some of its component technologies being integrated into upcoming releases of
ADO.NET and
Microsoft SQL Server. While it was then assumed by observers that WinFS was finished as a project, in November 2006
Steve Ballmer announced that WinFS was still in development, though it wasn't clear how the technology was to be delivered.
Motivation
Many
filesystems found on common
operating systems, including the
NTFS filesystem which is used in modern versions of Microsoft Windows, store files and other objects only as a
stream of bytes, and have little or no information about the data stored in the files. Such file systems also provide only a single way of organizing the files, namely via directories and file names.
Because a file system has no knowledge about the data it stores, Using common file formats is a workaround to this problem but not a universal solution; there's no guarantee that all applications will use the format. Data with standardized schema, such as
XML documents and
relational data fare better as they've a standardized structure and run-time requirements.
Also, a traditional file system can retrieve and search data based only on the filename, because the only knowledge it has about the data is the name of the files that store the data. Different data types expose different properties. Besides that, WinFS also allows different data instances to be related together, such as a document and a contact can be related by an
Authored By relationship. Thus WinFS help reduce redundancies.
| bar4-colour=#f4a460
| note4 = Features cut
| note4-at = 1999
| bar5-from=2000.5
| bar5-to=2002
| bar5-text=
LIS But the Cairo project was shelved, and with it OFS. However, later during the development of COM, a storage system, called Storage+, based on then-upcoming SQL Server 8.0, was planned, which was slated to offer similar aggregation features. and build 4051 of Windows Vista, then called by its codename "Longhorn", given to developers at the Microsoft
Professional Developers Conference in 2003, included WinFS, but it suffered from significant performance issues. The beta was refreshed on
December 1 2005 to be compatible with version 2.0 of the .NET Framework. WinFS Beta 2 was planned for some time later in 2006, and was supposed to include integration with
Windows Desktop Search, so that search results include results from both regular files and WinFS stores, as well as allow access of WinFS data using
ADO.NET.
However, on
June 23 2006, the WinFS team at Microsoft announced that WinFS would no longer be delivered as a separate product, in
SQL Server 2008, then codenamed
Katmai, as well as integration with
Win32 APIs and
Windows Shell and support for traversal of hierarchies by traversing relationships into later releases of
Microsoft SQL Server;
Data storage
Architecture
WinFS isn't a physical file system; rather, it provides schematized data modeling capabilities on top of the NTFS file system. It still uses NTFS to store its data in physical files. to provide the data relations mechanism. WinFS stores are simply SQL Server database (.MDF) files with the FILESTREAM attribute set. These files are stored in access-restricted folder named "System Volume Information" placed into the volume root, in folders under the folder "WinFS" with names of
GUIDs of these stores. -
WinFS.exe, which hosts relational datastore,
WinFSSearch.exe, which hosts the indexing and querying engine, and
WinFPM.exe (WinFS File Promotion Manager), which interfaces with the underlying file system. It allows programmatic access to its features, via a set of
.NET Framework APIs, that enables applications to define custom made data types, define relationships among data, store and retrieve information, and allow advanced searches. Relations can also be specified by other applications or the user.
WinFS provides a unified storage but stops short of defining the format that's to be stored in the data stores. Instead it supports data to be written in application specific formats. But applications must provide a
schema that defines how the file format should be interpreted. The Contact Item defined in this way will be used to store information regarding the Contact, by populating the properties field and storing it. Only those fields marked as mandatory needs to be filled up during initial save. The related items, in turn, may be related to other data items as well, resulting in a network of relationships, which is called a many-to-many relationship. Creating a relationship between two Items create another field in the data of the Items concerned which refer the row in the other Item’s table where the related object is stored. which are executed when certain condition is met. WinFS rules work on data and data relationships. For example, a rule can be created which states that whenever an Item is created which contains field
"Name" and if the value of that field is some particular name, a relationship should be created which relates the Item with some other Item. WinFS rules can also access any external application. For example, a rule can be built which launches a
Notify application whenever a mail is received from a particular contact. The data in them can be accessed by accessing the properties of individual objects. A set of all matches are returned, which can then be bound to an UI widget for displaying
en masse or enumerating individually. It can specify a single search condition, such as
"title = Something'", or a compound condition such as
"title = 'Title 1' || title = 'Title 2' && author = 'Someone'". These boolean and relational operations can be specified using
C# like
&&,
||,
=,
!= operators as well as their English-like equivalent like
EQUAL,
NOT EQUAL.
SQL like operators such as
LIKE,
GROUP BY and
ORDER BY are also supported, as is wildcard conditions. A WinFS item can also be copied to a non-WinFS file system, but unless that data item is put back into the WinFS store, it won't support the advanced services provided by WinFS.
The WinFS API also provides some support for sharing with non-WinFS applications. WinFS exposes a shell object to access WinFS stores. This object maps WinFS items to a virtual folder hierarchy, and can be accessed by any application. which allowed one to browse WinFS stores by presenting a hierarchical view of WinFS Items. It automatically generated
virtual folders based on access permissions, date and other metadata, and presented them in a hierarchical tree view, akin to what traditional folders are presented in. The application generated tabs for different Item types. StoreSpy allowed viewing
Items,
Relationships,
MultiSet,
Nested Elements,
Extensions and other types in the store along with its full metadata. It also presented a search interface to perform manual searches, and save them as virtual folders. The application also presented a graphical view of WinFS Rules. However, it didn't allow editing of Items or their properties, though it was slated for inclusion in a future release. But the WinFS project was cut back before it could materialize.
Type Browser
WinFS also includes another application, named
WinFS Type Browser, which can be used to browse the WinFS types, as well as visualize the hierarchical relationship between WinFS types. A WinFS type, both built-in types as well as custom schemas, can be visualized along with all the properties and methods that it supports. It also shows the types that it derives from as well as other types that extend the type schema. However, while it was included with WinFS, it was released as an unsupported tool. It presents a
graphical interface for writing
Opath queries. It can be used by selecting target object type and specifying the parameters of the query. It also includes
Intellisense-like parameter completion feature. It can then be used to perform visualization tasks like binding results of a query to a
DataGrid control, create views of the data in WinFS itself, or just extract the query string.
Project "Orange"
Microsoft launched a project to build a data visualization application for WinFS. It was codenamed
"Project Orange" and was supposedly built using
Windows Presentation Foundation. It was supposed to provide exploration of
Items stored in WinFS stores, and data relationships were supposed to be a prominent part of the navigation model. It was supposed to let people allow organization of the WinFS stores graphically as well - productizing many of the concepts shown in the
IWish Concept Video
. However, since the WinFS project went dark, the status of this project is unknown.
Further Information
Get more info on 'Winfs'.
|
External Link Exchanges
Do you know how hard it is to get a link from a large encyclopaedia? Well we're different and will prove it. To get a link from us just add the following HTML to your site on a relevant page:
<a href="http://winfs.totallyexplained.com">WinFS Totally Explained</a>
Then simply click through this link from your web page. Our crawlers will verify your link, extract the title of your web page and instantly add a link back to it. If you like you can remove the words Totally Explained and embed the link in article text.
As long as your link remains in place, we'll keep our link to you right here. Please play fair - our crawlers are watching. Your site must be closely related to this one's topic. Any kind of spamming, dubious practises or removing the link will result in your link from us being dropped and, potentially, your whole site being banned. |
