Abstract: The claimed subject matter relates to an architecture that can facilitate an incremental approach to an Object-Relational mapping solution. The architecture can provide a rich data model that is defined at the value layer. The rich data model can expose an interface that conforms with the interfaces exposed by common storage-specific data providers. The architecture can extend common storage-specific data provider to support common command representations, and provide entity services that work in terms of the rich data model as well as object services such as identity management, updating and change tracking.

Abstract: Multiple programming languages can be embedded and supported within a single source. Programs nested with syntax from a plurality of languages (e.g., C#, SQL, XML . . . ), among other things, enable users to avail themselves of advantageous aspects of different languages for particular tasks. Language services that provide language specific functionality including but not limited to formatting, intelligent assist, auto completion, and coloring, can be employed and switched between to afford support for their respective languages in a mixed language source program. Similarly, mixed language programs can be compiled with language specific services or systems such as parsers, scanners and the like to process corresponding code portions.

Abstract: Systems and methods for extension of a query language for defining a simple formulation of joins by capturing the semantics of an existing linkage between a plurality of tables, via employing a reference join. Such reference join enables a compiler to exploit existing relationships in a data base, and employ existing knowledge about referential constraints for an unambiguous transformation of the reference join expression into the equivalent INNER JOIN on the columns involved. Accordingly, a simpler query syntax and semantics can be provided to express multi-table join navigation over primary key/foreign key relations, for example.

Abstract: Systems and methodologies of partially deserializing a Complex Type Object, via a deserializer that intercepts and materializes such object on demand. The object or a subset thereof can be deserialized to produce an Instance of Complex Type that is implemented by a property store. The deserializer can include an analyzer component that analyzes the Property Store.

Abstract: Data management between a common data store and multiple applications of multiple disparate application frameworks. A data storage component is provided that facilitates the storage of data, which data includes structured, semi-structured, and unstructured data. A common data platform interfaces to the data storage component to provide data services accessible by a plurality of disparate application frameworks, which data services allow a corresponding application of the different frameworks to access the data.

Abstract: Improved query optimizer using implied predicates. The system facilitates allowing a query optimizing component to introduce into a query, extra predicates that facilitate the following: render the same results as the original query; are used as dictated by rules passed to the optimizing component—these rules specify whether the new predicate is an equivalence (that will substitute the old predicate) or an implication (in which the old predicate is preserved); are considered as cost-based alternatives, and discarded if not useful; are tied to index utilization; and can consider both standard and multi-valued indices.

Abstract: The present invention the is directed to systems and methods for hosting the CLR in a DBMS in order to achieve reliability, scalability, security, and robustness for enabled DBMS programming features. Integrating the CLR with a DBMS enables programming features in the database such as stored procedures, functions, triggers, types, and aggregates to be written in any of the programming languages that are compiled into IL code supported by the CLR. For the various embodiments of the present invention, the CLR is hosted inside the DBMS and, instead of making requests directly to the server operating system, the CLR instead interfaces with the DBMS via DBMS APIs for such requests, and only the DBMS directly interfaces with the server operating system to access the server.

Abstract: Various embodiments of the present invention are direct to the utilization of Blob Handles (BHs) which are an internal representation of a large value. BHs are immutable and stateless references to a large data object. The structure of a BH contains enough information to return an ILockBytes interface in order to provide access to the corresponding large data block, and a BH can also return information regarding its own lifetime description. A BH can be completely described using (a) a pointer to the beginning of BH data and (b) the byte-length of the BH.

Abstract: Various embodiments of the present invention enable functions, procedures, and triggers to be written in any of the .NET languages and executed by the RDBMS. User code can access data from the local or other SQL servers using the SQL Programming Model and both the SqlServer or SqlClient implementations respectively. Moreover, to improve upon the previous extensibility mechanism, a set of APIs (commonly known as “the in-process provider” or “inproc provider”) is utilized to provide efficient and easy to use data access while running inproc, a data access API that is an implementation of the ADO.net programming model.

Abstract: A database system and method allows a user to write program code in a high-level programming language that implements a class that defines the structure of a user-defined aggregate and methods that can be invoked on instances of the user-defined aggregate. The class is then registered with the database system, which enforces a specific contract for user-defined aggregates against the class. The contract comprises the following requirements. First, the class must specify one of a plurality of different formats for persisting instances of the user-defined aggregate in a database store.

Abstract: Various embodiments of the present invention are directed to a database with an extensible type system for at least one user-defined type that comprises information for describing its structure as well as information for describing an inheritance relationship between itself and another user-defined type (either a subtype or a supertype/base type). For certain embodiments, the user-defined type is defined in something other than Sequential Query Language (SQL) statement such as, for example, a Common Language Runtime (CLR) statement, a statement in C, C++, and C# (“C-sharp”), and/or a visual basic statement. In any event, several embodiments are further directed to a system wherein the database is aware of the inheritance relationship between two user-defined types by an explicit registration of the user-defined types with said database.

Abstract: A database system and method allows a user to write program code in a high-level programming language that implements a class that defines the structure of a user-defined type and methods that can be invoked on instances of the type. The class is then registered with the database system, which enforces a specific contract for user-defined types against the class. The contract comprises the following requirements. First, the class must specify one of a plurality of different formats for persisting instances of the user-defined type in a database store. Second, the class must be capable of returning a null value for the user-defined type. Third, the class must provide a method for converting the user-defined type to another type. Once these requirements are satisfied, the database system enables instances of the user-defined type to be created. A user-defined type can be used in all contexts where any other built-in type can be used.

Abstract: A database system and method allows a user to write program code in a high-level programming language that implements a class that defines the structure of a user-defined type and methods that can be invoked on instances of the type. The class is then registered with the database system, which enforces a specific contract for user-defined types against the class. The contract comprises the following requirements. First, the class must specify one of a plurality of different formats for persisting instances of the user-defined type in a database store. Second, the class must be capable of returning a null value for the user-defined type. Third, the class must provide a method for converting the user-defined type to another type. Once these requirements are satisfied, the database system enables instances of the user-defined type to be created. A user-defined type can be used in all contexts where any other built-in type can be used.

Abstract: A database system and method allows a user to write program code in a high-level programming language that implements a class that defines the structure of a user-defined type and methods that can be invoked on instances of the type. The class is then registered with the database system, which enforces a specific contract for user-defined types against the class. The contract comprises the following requirements. First, the class must specify one of a plurality of different formats for persisting instances of the user-defined type in a database store. Second, the class must be capable of returning a null value for the user-defined type. Third, the class must provide a method for converting the user-defined type to another type. Once these requirements are satisfied, the database system enables instances of the user-defined type to be created. A user-defined type can be used in all contexts where any other built-in type can be used.

Abstract: Several embodiments of the present invention are directed to systems and methods for extending the UDT framework of an extended relational data store (ERDS) to include support for unordered collections (multisets) and ordered collection (lists). More specifically, several embodiments of the present invention use an UDT infrastructure, CLR generics, and a new UNNEST operator to create and utilize a special type abstraction for collections that is simultaneously a scalar and a relation. As a scalar, this collection type can be processed by all parts of the data store engine that understand scalars (including but not limited to the client stack) and, as a relation, this collection type is queriable like any other type of relation.

Abstract: A new persistence format for storing objects of a user defined type in a database store enables information about the structure of the type to be communicated to the store. This information enables a number of store optimizations, including direct structural access to members of the type. Specifically, metadata is exchanged between the type implementer and the data store. The store uses the metadata to determine the storage layout for instances of the type. With this information, the store is able to detect access patterns that can be optimized to directly operate over the storage representation without hydration (deserialization) the object.

Abstract: A system and method are provided for modeling structured, semi-structured, and unstructured data all within a single instance of a user defined type (UDT) within a database store. In particular, the XML data model is extended to fields of a UDT. As a result, the properties of the XML data model—such as document order and document structure—can be preserved within instances of a UDT. Moreover, code representing object behavior (i.e., methods that can be invoked on an object in managed code) can be added to the UDT to operate on an XML field, as well as non-XML fields of the UDT. This enables a framework for adding business logic to XML data. The content model of the XML data can be optionally described using XML schema documents associated with the XML fields of the UDT.

Abstract: A technique for updating collection-valued and other complex structured columns in a nested table using a nested extension of an UPDATE statement that uses syntax and semantics to modify collection-valued columns in a way that is analogous to the syntax and semantics of the UPDATE statement that is used to modify scalar-valued columns of the table (called the outer UPDATE). Using the same syntactic and semantic constructs as the table at the outer level allows an existing implementation that processes modifications to relational tables to reuse its implementation techniques for processing outer updates to modify collection-valued columns as well. The UPDATE extensions enable the specification of updates to nested collections embedded at arbitrary levels of depth in the object model. The new syntax is embedded inside the outer UPDATE statement in a way that parallels the structure of the data itself and thus maps more directly to the user's conceptual model of the data.

Abstract: A new persistence format for storing objects of a user defined type in a database store enables information about the structure of the type to be communicated to the store. This information enables a number of store optimizations, including direct structural access to members of the type. Specifically, metadata is exchanged between the type implementer and the data store. The store uses the metadata to determine the storage layout for instances of the type. With this information, the store is able to detect access patterns that can be optimized to directly operate over the storage representation without hydration (deserialization) the object.

Abstract: A technique for representing the structure of hierarchically-organized data in a non-hierarchical data structure, such as a relation. The hierarchically-organized data is represented as a tree, and each node in the tree is assigned a position identifier that represents both the depth level of the node within the hierarchy, and its ancestor/descendant relationship to other nodes. The data represented by each node, as well as its position identifier, is stored in a row of a relational database, thereby capturing the hierarchical structure of the data in such relational database. A technique is provided for the compressed storage of position identifiers in a format that allows an efficient bytewise comparison of position identifiers to determine relative order and ancestry.