Abstract: An operation (such as a relational query) may be processed on a processing engine (such as a relational database server) on behalf of a client. A conventional processing involves the delivery of the operation to the processing engine, which executes the entire operation to completion and returns a result data set. It may be more efficient to allocate part of the operation to be performed on the client, but a developer may be unable or unavailable to rewrite the operation in a distributed manner. Instead, the operation may be automatically partitioned into a pre-engine client portion, a processing engine portion, and a client portion, and the instructions of each portion may be automatically allocated respectively to the client, the server, and the client. The partitioning may be adjusted to conserve computing resources, such as bandwidth and storage, and the instructions may be reordered to improve the processing of the operation.

Abstract: An operation (such as a relational query) may be processed on a processing engine (such as a relational database server) on behalf of a client. A conventional processing involves the delivery of the operation to the processing engine, which executes the entire operation to completion and returns a result data set. It may be more efficient to allocate part of the operation to be performed on the client, but a developer may be unable or unavailable to rewrite the operation in a distributed manner. Instead, the operation may be automatically partitioned into a pre-engine client portion, a processing engine portion, and a client portion, and the instructions of each portion may be automatically allocated respectively to the client, the server, and the client. The partitioning may be adjusted to conserve computing resources, such as bandwidth and storage, and the instructions may be reordered to improve the processing of the operation.

Abstract: Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Abstract: Type inference is used to provide the benefits of static type checking without explicitly declaring type in the source code. Type inference that proceeds in a bottom up direction is augmented by contextual typing that proceeds in a top down direction. Contextual typing types enclosed expressions by associating the type of a directly enclosing expression with the enclosed expression. Object literals, function literals and array literals enclosed in assignment and call expressions, can be contextually typed.

Abstract: Statically extensible types allow a static type system to model the behavior of dynamic object model extension in dynamic runtime systems. Static types that model dynamically extended types can be extended using additional declarations in the same compilation. Declarations for a particular type can come from multiple independent sources which can have been defined at multiple points in time. Extension declarations can use the same syntax as the initial type declaration. Hence presence of one or more declarations for the same type in a compilation can indicate that the type has been extended. These features allow static type checking of dynamic plug-ins to be supported using statically extensible types. Declarations and extension declarations for a type can be merged together to create an extended type that enables different processing paths and dependencies.

Abstract: A static type, called “dynamic”, is introduced into a statically bound programming language. An expression or subexpression that is defined as a static type called “dynamic” in the source code of a program written in the statically bound programming language, is bound based on its runtime type instead of on its compile time type. Binding can be performed based on a mixture of compile time and runtime types that are based on the specification of types of expressions in source code. This type of binding is called hybrid binding. Operations are bound using the runtime type of constituent expressions (i.e., the runtime type of a receiver, an argument, or an operand) typed as dynamic and the compile time type of static constituents. If any constituent expression of an operation is dynamic, binding occurs at runtime instead of at compile time.

Abstract: An imperative framework having a more than one type is defined. At least one of the types is an immutable type, and the immutable type has at least one immutable field.

Abstract: A dynamic programming environment includes a dynamic runtime infrastructure configured to receive static metadata as source text in a source code written in a dynamic programming language. The dynamic runtime infrastructure determines an object representation based on the static metadata from the source text in the source code.

Abstract: The present invention extends to methods, systems, and computer program products for transforming source code to await execution of asynchronous operations. Embodiments of the invention simplify authoring and use of asynchronous methods, by generating statements that use well-defined awaitable objects to await completion of asynchronous operations. For example, a computer system can transform a statement that requests to await the completion of an asynchronous operation into a plurality of statements that use a predefined pattern of members of an awaitable object corresponding the asynchronous operation. The pattern can include one or more members configured to return a completion status of the asynchronous operation, one or more members configured to resume execution of the asynchronous method at a resumption point when the asynchronous operation completes, and one or more members configured to retrieve completion results.

Abstract: A function in a type system can be overloaded using specified constants. The constant can be can be the result of evaluating an expression to: a string, a number, a Boolean, a pattern or any type of constant. The return type of the function can depend on the specified constant that is passed into the function. The return type of the function can depend on the type of the specified constant that is passed into the function. The type of the parameter that is passed into the function can depend on the value of the constant. The function overloads can be validated to ensure that the constant-based overload is a subtype of a more general overload. A constant can be an expression used at compile time during type checking.

Abstract: Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Abstract: Type inference is used to provide the benefits of static type checking without explicitly declaring type in the source code. Type inference that proceeds in a bottom up direction is augmented by contextual typing that proceeds in a top down direction. Contextual typing types enclosed expressions by associating the type of a directly enclosing expression with the enclosed expression. Object literals, function literals and array literals enclosed in assignment and call expressions, can be contextually typed.

Abstract: Statically extensible types allow a static type system to model the behavior of dynamic object model extension in dynamic runtime systems. Static types that model dynamically extended types can be extended using additional declarations in the same compilation. Declarations for a particular type can come from multiple independent sources which can have been defined at multiple points in time. Extension declarations can use the same syntax as the initial type declaration. Hence presence of one or more declarations for the same type in a compilation can indicate that the type has been extended. These features allow static type checking of dynamic plug-ins to be supported using statically extensible types. Declarations and extension declarations for a type can be merged together to create an extended type that enables different processing paths and dependencies.

Abstract: Data source queries may be specified in various languages, such as SQL, XQuery, and object-oriented languages, and each language may have various linguistic features that enable different types of queries. It may be advantageous to formulate mixed language queries having portions specified in a first language and portions specified in a second language, and to provide mixed language query evaluation components that can parse portions of queries of different languages. It may also be advantageous to permit the translation of single language queries into multiple languages to be parsed by such mixed language query evaluation components. Such techniques may permit queries to utilize linguistic features and processing techniques of one language that are less efficient, less direct, or simply unavailable in another language.

Abstract: Queries targeting various data sources are processed in a query processing pipeline that parses the query into a set of operations (e.g., an expression tree or a translated SQL query) using a set of query operators, each handling a particular type of operation. The query operators are often designed in an unspecialized manner, such that each query operator handles one query operation in an atomic, generic manner (e.g., sorting generic data items for an ORDER BY clause.) More efficient queries may be devised by including specialized queries that operate in common but special cases, such as a sorting of a particular data type (e.g., a floating-point number sort) or a sequence of two or more operations that are often performed together (e.g., a WHERE test of an attribute followed by a SELECT of the same attribute.) The use of specialized operators may result in the formulation of more efficient queries.

Abstract: The present invention extends to methods, systems, and computer program products for representing various programming elements with compiler-generated tasks. Embodiments of the invention enable access to the future state of a method through a handle to a single and composable task object. For example, an asynchronous method is rewritten to generate and return a handle to an instance of a builder object, which represents one or more future states of the asynchronous method. Information about operation of the asynchronous method is then passed through the handle. Accordingly, state of the asynchronous method is trackable prior to and after completing.

Abstract: A system and method for parsing XML is provided. The method includes associating an input stream with a pull model parser, accepting requests to selectively parse out XML items from the input stream and retrieving metadata information associated with the parsed out XML items. The method further includes checking the pulled XML item to determine whether it conforms to XML syntax and/or semantic standards and validating the pulled XML item to determine whether it conforms to a selected DTD.

Abstract: An object reference is tagged with an isolation permission modifier. At least two permissions can be included, and in an example three permissions are included. In implementing the permissions, type modifiers for controlling access to type members through references pointing at an object are defined. One of the type modifiers is associated with each occurrence of a type name. Each of the of type modifiers defines a different access permission to restrict operations on the object to which the reference points.

Abstract: A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion.

Abstract: Queries against data sources (such as language-integrated queries to be applied against relational databases) may be prepared for processing by a query processing pipeline. This pipeline performs services including transforming the query into a form more easily applied by the data source, e.g., into SQL, by matching query terms with query operators configured to handle various query operations. Many query processing pipelines include single-item query operators that perform individual operations (e.g., an updating query operator that specifies an updating of individual records of a table.) An integrated query pipeline may be devised that includes both single-item query operators and multiple-item query operators that specify operations on sets of data items.