Abstract: A relational database management system (RDBMS) optimizes limit queries over analytical functions, wherein the limit queries include an output clause comprising a LIMIT, TOP and SAMPLE clause with an expression specifying a limit that is a number K or a percentage ? %. The optimizations of the limit queries include: (1) static compile-time optimizations, and (2) dynamic run-time optimizations, based on semantic properties of “granularity” and “input-to-output cardinality” for the analytical functions.

Abstract: A query that is frequently processed to access an object storage is identified. Results from the query returned from the object storage is transformed into a relational database format as a materialized view. When the query is submitted a subsequent time, updated results are managed from the materialized view, other materialized views, and/or the object storage when needed.

Abstract: Techniques for improving complex database queries are provided. A determination is made whether to adopt a static or dynamic query execution plan for a received database query based on metrics. When a dynamic query execution plan is adopted, the database query is separated into query fragments. A plan fragment is generated for each query fragment and executed to generate feedback for the plan fragment. The feedback from the execution of each plan fragment is used to initiate query rewrite rules to simplify the corresponding query fragments. The rewritten query fragments are combined to generate the dynamic query plan.

Abstract: In a database system, at least one metric associated with resources in a database system used by multiple classes of requests is monitored, where a first of the multiple classes is associated with a lower priority than a second of the multiple classes. A throttle limit is calculated for requests of the first class, based on the monitored metric. The calculated throttle limit is used to determine scheduling of the request of the first class for execution.

Abstract: In some examples, a database system includes a plurality of processing engines to process data for database operations, and instructions executable on at least one processor to insert first data into first objects stored in a remote data store coupled to the database system over a network, and select, based on a size of the first data, a first partition level from a plurality of different partition levels to associate with the first objects. Different partition levels define different quantities of hash buckets that correspond to different distributions of objects across the plurality of processing engines. The first partition level is associated with the first objects.

Abstract: Execution of a query invoking an analytical function (AF) is optimized. The query includes a join operation between an AF table and an AuxiliaryTable. A determination is made that the AF includes a plurality of AF properties. Query-level properties about the query are inferred. A determination is made to change an order of the join operation from the plurality of AF properties and query-level properties.

Abstract: A security mechanism, e.g., a computing system, security server, can effectively serve as a centralized security mechanism, e.g., a computing system, security server, for an ecosystem that can include diverse clients and servers. The security mechanism can obtain redirected requests for services, authenticate credentials of a client and generate a (client-side) token that can be provided by the client to the server for verification of the identity of the client. The security mechanism can also obtain a token from a server that can be similar to a (client-side) token provided to a client and then generate a (server-side) token that can be provided to a server. The server-side token can include authorization information that allows access to one or more services of one or more other servers.

Abstract: A data store system may include a storage device configured to store a plurality of data store tables. The data store system a further include a processor in communication with the storage device. The processor may receive a request to encode a column of a data store table from the plurality of data store tables. The processor may further generate a bit value representation of each value in the column of the data store table. The processor may further generate an index. The index may include an index value representative of each bit position of the bit value representations. The processor may further reorder bits of each bit value representation according to a predetermined pattern. The processor may further encode each reordered bit value representation according to an encoding technique. The processor may further store each encoded reordered bit value representations and the index. A method and computer-readable medium are also disclosed.

Abstract: In some examples, a system learns properties of an analytical function based on information of queries invoking the analytical function that have been previously executed, creates a function descriptor for the analytical function based on the learning, and provides the function descriptor for use by an optimizer in generating an execution plan for a received database query that includes the analytical function.

Abstract: In some examples, a database system includes a storage medium to store a materialized view (MV) that includes data satisfying an MV condition. At least one processor is to receive a query including a query condition, determine that the query condition partially matches the MV condition, and access a part of the data in the MV partially satisfy the query.

Abstract: Improved techniques for management of memory (or memory management) for computing systems and environments are disclosed. The improved techniques are especially well suited for computing systems that operate in highly complex and/or demanding computing environments (e.g., massively parallel database systems that may be required to process many complex database queries in parallel. Memory can be managed dynamically at run time to determine and designate one of multiple memories that are available for execution of executable components (e.g., database queries, Opcodes of a Virtual Machine). In addition, memory can be managed dynamically at run time to effectively reuse memory locations of a memory (e.g., stack memory) being used for execution of one or more executable components (e.g., Opcodes of a Virtual Machine) at run time when the memory is being actively used to execute the one or more executable components.

Abstract: A database system receives a query to be processed. The database system has resources. A user assigns the query to a tier of resource allocation priorities in a hierarchy of tiers. The tier has been designated as being automatically managed by the database system. The tier has a plurality of levels of priority for resource allocation (LPRAs). The database system decomposes the query into a first step and a set of subsequent steps. The first step has a beginning and each of the set of subsequent steps has a respective beginning. The database system assigns the first step to a first LPRA, wherein executing the query at the first LPRA is projected by the database system to satisfy a service level goal (SLG) within a on_schedule_range of the SLG.

Abstract: A method and apparatus for optimizing a query in a relational database management system (RDBMS) when a predicate on a data column in the query has a correlation to a partitioning attribute of a partitioning column in data retrieved from a cloud-based store, wherein the optimizing uses the correlation between the data column in the query to the partitioning column in the data retrieved from the cloud-based store for data elimination when processing the query. The correlation is defined in a formula or lookup data structure that maps or range-maps from the data column to the partitioning column.

Abstract: A method, apparatus, and computer program product for executing a relational database management system (RDBMS) in a computer system, wherein the RDBMS manages a relational database comprised of at least one column-partitioned base table storing data. Column values from at least one column of the column-partitioned base table are stored in one or more containers spread across one or more data blocks. Metadata comprising summarized information about the column values in the containers is stored in a metadata index subtable. A query with a filtering condition on the column is applied to the metadata index subtable before the column-partitioned base table is accessed, so that only qualified containers and data blocks are accessed, and unqualified containers and data blocks are eliminated, when responding to the query.

Abstract: Various embodiments herein each include at least one of systems, methods, and software for generating, storing, and using non-unique secondary indexes of semi-structured data in database tables. One method embodiment includes creating and storing a non-unique secondary index (NUSI) for a database table based on column data stored in rows of the database table. The NUSI in some such embodiments identifying an offset to specific data included in the column data of at least some rows of the database table where the specific data is located. Other embodiments include building a NUSI index that includes values embedded therein.

Abstract: A data store system includes a storage device and a processor in communication with the storage device. The processor may receive data from a source and generate a plurality of rows from the data. The processor may further apply row reduction criteria to the buffered plurality of rows. The processor may further, in response to application of the row reduction criteria, determine at least one resultant row. A number of the at least one resultant row is less than a number of the plurality of rows. The processor may further store the at least one resultant row in the storage device. A method and computer-readable medium is also disclosed.

Abstract: A system and method for loading data into column-partitioned database tables. The system and method incorporate a mechanism for buffering data extracted from the rows of a source table in column-oriented fashion within an in-buffer memory, enabling an efficient bulk-write of large arrays of values from the buffer into column-partitioned database tables. The system and method may also include optimizations for grouping columns according to data types and altering the order in which columns are inserted into the database tables.

Abstract: One or more assignments (e.g., one or more maps) can be used for assigning data to processing units of a database system with multiple processing. In other words, assignments can be provided as a more effective solution for assigning data to the processing units of database systems that can operate with multiple processing units. Generally, an assignment can be used to assign data to the processing units for processing, virtually in any desired manner (e.g., virtually any desired function). By way of example, maps can associate data to containers (e.g., buckets) and associate the containers to processing units of database system with multiple processing units.

Abstract: In some examples, a system stores data in a logically disconnected data store. In response to a query for data in the data store, the system accesses metadata of objects stored in the data store, the metadata including information of a respective range of values of at least one clustering attribute in data contained in each respective object of the objects. The system partitions the objects across the plurality of processing engines based on the information of the respective ranges of values of the at least one clustering attribute in the data contained in the objects. The system assigns, based on the partitioning, the objects to respective processing engines of the plurality of processing engines.

Abstract: Disclosed are systems and methods for implementing contract-based polymorphic and parallelizable user-defined scalar and aggregate functions. The systems and methods can include receiving a query including a plurality of user-defined functions, parsing the query into a plurality of nodes (e.g., basic operation unit or atomic operator), generating an execution plan that minimizes data transfer between the plurality of nodes, and executing the plan in a distributed environment. Each of the plurality of user-defined functions can correspond to one of a plurality of nodes.