1. A system comprising:
- a memory storing processor-executable instructions; and
a processor to execute the processor-executable instructions to cause the system to;
receive a request to perform an operation relying on sets-related tables of a semantic layer universe;
inject, in response to the received request, persisted Data Foundation (DF) objects stored in a dedicated data structure of a first set container into an in-memory representation of a semantic layer universe, each of the DF objects being automatically created based on sets-related tables of the semantic layer universe;
inject, in response to the received request, persisted business layer (BL) objects stored in a dedicated data structure of the first set container into the in-memory representation of the semantic layer universe, each of the BL objects being automatically created based on the sets-related tables of the semantic layer universe; and
execute the operation on the augmented semantic universe, including using the injected DF objects and the injected BL objects.
A system and method including receiving a request to perform an operation relying on sets-related tables of a semantic layer universe; injecting in response to the received request, persisted Data Foundation (DF) objects stored in a dedicated data structure of a first set container into the in-memory representation of the semantic layer universe, each of the DF objects being automatically created based on sets-related tables of the semantic layer universe; injecting, by the processor and in response to the received request, persisted business layer (BL) objects stored in a dedicated data structure of the first set container into the in-memory representation of the semantic layer universe, each of the BL objects being automatically created based on the sets-related tables of the semantic layer universe; and executing the operation on the augmented semantic universe, including using the injected DF objects and the injected BL objects.
- 1. A system comprising:
a memory storing processor-executable instructions; and a processor to execute the processor-executable instructions to cause the system to; receive a request to perform an operation relying on sets-related tables of a semantic layer universe; inject, in response to the received request, persisted Data Foundation (DF) objects stored in a dedicated data structure of a first set container into an in-memory representation of a semantic layer universe, each of the DF objects being automatically created based on sets-related tables of the semantic layer universe; inject, in response to the received request, persisted business layer (BL) objects stored in a dedicated data structure of the first set container into the in-memory representation of the semantic layer universe, each of the BL objects being automatically created based on the sets-related tables of the semantic layer universe; and execute the operation on the augmented semantic universe, including using the injected DF objects and the injected BL objects.
- View Dependent Claims (2, 3, 4, 5, 6, 7)
- 8. A computer-implemented method for authoring extensions to a semantic layer universe, the method comprising:
receiving, by a processor, a request to perform an operation relying on sets-related tables of a semantic layer universe; injecting, by the processor and in response to the received request, persisted Data Foundation (DF) objects stored in a dedicated data structure of a first set container into an in-memory representation of a semantic layer universe, each of the DF objects being automatically created based on sets-related tables of the semantic layer universe; injecting, by the processor and in response to the received request, persisted business layer (BL) objects stored in a dedicated data structure of the first set container into the in-memory representation of the semantic layer universe, each of the BL objects being automatically created based on the sets-related tables of the semantic layer universe; and executing, by the processor, the operation on the augmented semantic universe, including using the injected DF objects and the injected BL objects.
- View Dependent Claims (9, 10, 11, 12, 13, 14)
- 15. A non-transitory computer readable medium having executable instructions stored therein, the medium comprising:
instructions to receive a request to perform an operation relying on sets-related tables of a semantic layer universe; instructions to inject, in response to the received request, persisted Data Foundation (DF) objects stored in a dedicated data structure of a first set container into an in-memory representation of a semantic layer universe, each of the DF objects being automatically created based on sets-related tables of the semantic layer universe; instructions to inject, in response to the received request, persisted business layer (BL) objects stored in a dedicated data structure of the first set container into the in-memory representation of the semantic layer universe, each of the BL objects being automatically created based on the sets-related tables of the semantic layer universe; and instructions to execute the operation on the augmented semantic universe, including using the injected DF objects and the injected BL objects.
- View Dependent Claims (16, 17, 18, 19, 20)
Enterprise software systems receive, generate, and store data related to many aspects of a business enterprise. This data may relate to sales, customer relationships, marketing, supplier relationships, inventory, human resources, and/or finances. Users may operate querying and reporting tools to access such data and display the data in useful formats, such as graphic visualizations and reports.
In some environments, a semantic layer universe may reside between an enterprise'"'"'s data (e.g., a database) and the end users (e.g., customers). In some aspects, the semantic layer universe can include representations of the enterprise'"'"'s data warehouse, including representations of real-world entities and processes. In some cases, the semantic layer universe might provide a mechanism to securely share the enterprise'"'"'s data through a connection to one or more different querying clients. The semantic layer universe can be a valuable asset of the enterprise that can be used to generate insights into the operations of the enterprise. As such, constant maintenance of the integrity and security of the semantic layer universe may be vital to the enterprise. However, some users may have a desire to dynamically enhance capabilities of the semantic layer universe.
The following description is provided to enable any person in the art to make and use the described embodiments. Various modifications, however, will remain readily apparent to those in the art.
In some example contexts, use-cases, and embodiments, one or more terms will be used in the present disclosure. As a matter of introduction and to ease the understanding of the present disclosure, a number of terms will be introduced, where the full meaning of the following terms will be further understood in context of the disclosure herein, on the whole.
As used herein, a “Business Object” (BO) or simply “object” represents an aspect or feature of a real-world entity (e.g., company, person, product, process, a key performance index (KPI) for an area of an organization or business, etc.) and is mapped to specific data structures (e.g., table columns) in an underlying data source such as a database. A BO is a semantic entity, such as “Year”, “Region”, “Product”, “Customer”, etc. that represents a logical way of categorizing and grouping data for meaningful analysis of a business area or activity. A BO data structure can include fields with attributes and metadata associated with and defining the attribute fields. In some aspects, the BO refers to the specific collection of data according to the data structure (i.e., an instance of the BO data structure) that is stored in the database.
A “repository” may refer to a database used to store enterprise (i.e., organizational) platform information, such as user, server, folder, document, configuration, and authentication details.
A Semantic Layer (SL) herein refers to a representation of an organization'"'"'s data that facilitates end users accessing the data autonomously using common understandable terms. A semantic layer may map complex data to familiar terms such as, for example, “product”, “customer”, or “revenue” in an effort to offer a unified, consolidated view of data across the organization that users can access without having a need to know the intricacies and complexities of the database, including its schema. The data and metadata (that is, objects) that comprise the semantic layer may be retrieved from a database and form a “semantic layer universe”. As used herein, a semantic layer universe (also referred to simply as a “universe” and “UNX”) is an abstraction of a data source that maps complex data into descriptive terms used across the organization. Some examples include, “Product,” “Customer,” “Region,” “Revenue,” “Margin”, and “Costs”. The universe resides between an organization'"'"'s database(s) (or other data sources) and end-users such as customers, and isolates the end users from the technical details of the database(s) where source data is stored. Consistent with other terms herein, semantic universes include objects that are grouped into classes (and subclasses) that are mapped to the source data in the database and may be accessed through queries and reports. A “universe editor” refers to a dedicated User Interface (UI) that provides a mechanism to allow a specific role among users (universe designers) to design universes.
As used herein, a “set” refers to a semantic entity defining one or more steps to follow (i.e., a method) to produce, for example, a list of unique and homogeneous data-mart identifiers (Customer IDs, Product IDs, Transaction IDs, etc.). A set is created on top of BOs, including the data (e.g., fields and attributes) and metadata associated therewith. A set may include other aspects or features, in addition to the one or more BOs on which it is created or based. A “set container” refers to a structure hosting a number of sets, possibly among other entities, for performance and administrative purposes. A “set designer” refers to a role aimed at designing and publishing sets and a “sets editor” refers to a dedicated UI that allows set designers to design Sets.
In some aspects herein, the term “secured universe” is used. A secured universe refers to a transient version of a universe that might be generated for end users'"'"' purposes. The secured universe restricts what a given user can see and manipulate according to the credentials the user provides when logging into a system.
A “query” is used to retrieve a collection of BOs (i.e., “objects”) based on specific criteria. In some embodiments, an inquiry or query is converted by an application, service, or server (e.g. a BusinessObjects server) to SQL or other language statements appropriate to query the database. The SQL (or other language) query is sent to the database to retrieve the data mapped to the objects referenced and relevant to the query. A collection of criteria that restricts the type and/or number of records returned as a query result is referred to as a “filter”. In some aspects, a filter defines a sub-set of data to appear in a query'"'"'s result list. Some embodiments herein may include a “query panel” (QP). A QP refers to a UI, possibly dedicated, that provides a mechanism to allow end users to define queries. The QP may also present a view of the Universe to the end user.
System 200 includes a semantic layer universe 225 comprising a plurality of business objects (BOs) 220. Universe 225 is logically located between an enterprise'"'"'s or organization'"'"'s source of data stored on data store 230 (e.g., an in-memory database) and a consumption level including clients 205 where users can create queries via, for example, user interfaces, UIs, (not shown in
Universe 225 is an abstraction of data source 230 that maps complex data into descriptive terms used across the organization. Some example terms include “Revenue”, “Margin”, and “Costs”. Universe 225 is separate and distinct from the data source 230. Universe 225 includes objects (e.g., “Product”, “Customer”, and “Region”) that are grouped into classes and mapped to the data in the database 230. The data in database 230 may be accessed using, for example, plain language names, through queries from applications 210. Universe 225 may be created or authored by a “universe editor” (not shown). The universe editor may include a UI that provides a mechanism for a user to design universes using, for example, drag-and-drop techniques to interact with graphical representations thereon.
In some aspects, a universe administrator or other authorized entity in defining a universe may consider and attempt to anticipate what data features, access, and relationships end users/consumers may want and need. After defining the objects and constraints of a universe, the universe administrator may author and publish the universe so the end users can see, access, and use it to interact with the database supporting the universe.
In some aspects, universe 225 may be used by the different applications 210, where applications 210 may correspond to different applications or services offered by a software provider. As such, the data representations of universe 225 may be a valuable asset and aspect to the on-going functionality of an associated organization, including objects representing operational and analytical processes of the organization.
In some aspects, it can be vital that the integrity and accuracy of universe 225 be securely maintained. In some embodiments, universe 225 may be read-only by users, thereby preventing users from changing data that might be critical or relevant to an enterprise and parts thereof. Universe 225 may however be modified by an entity having a sufficient security clearance to making changes thereto such as a universe editor (not shown). In some embodiments or contexts, a universe may be periodically updated or otherwise modified to reflect changes to the organization and/or its processes and methods of operation. However, a universe might be modified occasionally, about, in some instances, once every three to six months.
In one example, a client 205 executes an application 210 to present a query panel (QP) via a user interface (UI) to a user on a display of client 205. The user manipulates UI elements within the UI to indicate a query by selecting one or more graphical representations of BOs, where a server or service embodying universe 225 operates to generate one or more SQL statements that are sent to database 230. Database 230 may execute instructions corresponding to the SQL statements to generate query results (i.e., data mapped to the objects selected by the user). The query results may be presented to the user in a view including, for example, a report, a dashboard, or other record.
Data store 230 may comprise any data source or sources that are or become known. Data store 230 may comprise a relational database, a HTML document, an eXtendable Markup Language (XML) document, or any other data storage system storing structured and/or unstructured data files. The data of data store 230 may be distributed among several data sources. Embodiments are not limited to any number or types of data sources.
Data store 230 may implement an “in-memory” database, where a full database is stored in volatile (e.g., non-disk-based) memory (e.g., Random Access Memory). The full database may be persisted in and/or backed up to fixed disks (not shown). Embodiments herein are not limited to an in-memory implementation. For example, data may be stored in Random Access Memory (e.g., cache memory for storing recently-used data) and other forms of solid state memory and/or one or more fixed disks (e.g., persistent memory for storing their respective portions of the full database).
In some contexts, a user or other entity may want to enrich an existing or new universe (e.g., 225) to include innovations such as, for example, additional or different methods and data representations and relationships not offered by an organizations'"'"' semantic layer universe. In some example embodiments, the innovations may occur rather frequently as compared to the lifecycle of the universe and may further relate to a specific subset of applications 110 and/or users thereof. In some aspects, a “set” may be created by a user (e.g., a set designer working to implement desires of end users) to define a method to produce, for example, a list of unique and homogeneous data-mart identifiers (Customer IDs, Product IDs, Transaction IDs, etc.). The set is created on top of the BOs of universe 125, where the set is also a semantic entity and includes at least some aspects (e.g., fields, attributes, methods, and metadata) of the objects of the universe. A set herein may include other aspects or features, in addition to the one or more BOs (or parts thereof) on which it is created or based. In some aspects, the set may be updated or created on a daily or even shorter timeframe.
In some aspects, including but not limited to security concerns and an incompatibility in lifecycles, a universe and one or more sets relating thereto might not be merged. For example, enhancements and features that might be desired by some users and not included in a semantic layer universe might not be added to the universe at an authoring level of the universe where the universe is created and published. However, in accordance with some example embodiments herein, features enabled by one or more (new) semantic layer sets may be consolidated with a universe to add, from a user'"'"'s perspective, the technical features and enhancements of the one or more sets to the universe at a consumption level where the user creates a query of a database via the universe.
Operation 610 includes creating set containers that may be linked to the semantic layer universe published in operation 605. In some instances, a set designer may create one or more set containers at operation 610, where the set containers are semantic layer entities that are separate and distinct from the semantic layer universe 300. Operation 610 is directed to the creation of the one or more set containers. As such, the set containers do not yet include any sets. As a repository resource itself, a set container may have a level of security applied to it.
Proceeding to operation 615, the semantic layer universe published at operation 605 may be linked to or otherwise associated with one or more of the set containers created at operation 610. In some embodiments, the universe and the set containers may be linked to each other via repository relationships defining a dependency therebetween. The repository relationships may be expressed in metadata that may be stored in a location separate and distinct from the universe.
At operation 620, sets are created on top of the universe'"'"'s BOs. The sets are also a semantic layer entity and may represent collections of data (e.g., methods, entities, etc.) that differ from the BOs of the universe from which the sets'"'"' BOs are derived. In some embodiments, sets may be designed by a set designer using a dedicated sets editor that is a design tool strictly for defining sets. In some embodiments, only BOs available to the set designer in accordance with their role and security privileges can be created by a given set designer. The sets generated at operation 620 may be grouped into the one or more set containers linked to the universe at operation 615. The sets can be published for viewing and usage as being grouped into set containers. The set(s) are a semantic entity and are not stored in the universe, rather the sets are stored elsewhere.
Process 600 may, in some embodiments, include all of the operations shown in
At operation 810, the set containers available to the querying entity based on that entity'"'"'s role and corresponding security access levels or privileges are retained. Set containers not available due to security constraints may be discarded from further consideration with respect to the current query. Operation 815 further includes retaining the BOs in the set containers retained at operation 810 that are allowed based on the querying entity'"'"'s role and corresponding security access levels or privileges. The BOs not available due to security constraints may be discarded from further consideration with respect to the current query. At operation 820, the allowed set(s) available to the querying entity based on that entity'"'"'s role and corresponding security access levels or privileges are retained. At operation 820, the allowed sets will include the allowed BOs as determined at operation 815. The allowed set(s) will be retained and the other, non-allowed set(s) can be discarded from further consideration with respect to the current query.
At operation 825, a consolidated view of the relevant BOs and allowed set(s) may be presented to the end user that invoked the query. In some instances, the consolidated view is presented in a UI of the tool, application, or service that provided a point of interaction for the end user to initiate the query.
According to process 800, appropriate set containers of a given universe are collected at the semantic layer level based, at least in part, on the repository relationships of the given universe at the time the query is initiated and presented to the system. Further, the relevant sets are consolidated with the relevant BOs of the given universe for consumption of the end user. This consolidated universe including the semantic layer aspects of the relevant set(s) is transient and is referred to herein as a secured universe. The secured universe, as illustrated by the operations of
Process 800 may, in some embodiments, include all of the operations shown in
In some aspects, an end user may be presented with a view of the consolidated universe that is extended to include the security-cleared sets. In some embodiments, an end user may see the features, methods and other data representations (e.g., a new BO created in a newly created set). However, whether the features or methods are part of the universe created during a universe creation phase or part of a universe consolidation generated dynamically at the time of a query execution may not be revealed or otherwise indicated to the end user.
In some embodiments, the consolidated, secure universe is generated dynamically when needed (i.e., in response to a query). The consolidated or merged universe including the original universe and the relevant set(s) may be stored separate and apart from original universe. The merged universe may be implemented as an in-memory copy, decoupled from the original universe. In some aspects, the sets may be viewed as “filters”.
In some aspects, the BL objects 1075 generated as illustrated in
In some aspects, features disclosed herein may provide mechanisms for automatically providing business objects representing pre-determined analytics to a customer or other user.
In some aspects, sets may store some metadata and membership data in a customer'"'"'s database. A process referred to as materialization may issue data manipulation language (DML) and data definition language (DDL) SQL on the customer specified database to generate membership (i.e., lists of IDs) for each defined set. This data is stored in dedicated tables created automatically by the system.
For a customer to consume these tables in a Query Panel (or other reporting tool user interface), one would typically need to add the tables to their DF, as well as fully understand how these tables are related to their own (i.e., customer) tables. Best or suggested practices would also suggest that such process(es) ensure that no loops or other ambiguities are created and that the integrity of the DF is maintained. Additionally, relevant and meaningful Business Objects (BOs) would need to be created based on these set tables.
In some regards, this might be a complex and time-consuming process. Some embodiments herein operate to alleviate this complexity by auto-generating the DF and BO'"'"'s and providing access to the same to a customer, thereby, in some instances, providing a mechanism for a customer to access the set metadata and membership in a QP (or other reporting tool interface) to assist in creating analytics.
In some aspects, a set container is fully aware of what tables it contains or owns and stores this information internally. This table-related information is stored so the system can continue to manipulate (e.g., Insert, Update, Delete, etc.) the data and tables as needed.
In some embodiments, a DF table may be created for each set table based on the information stored in a set container and describing the set tables therein. In some embodiments, a process for creating a DF table is performed automatically based on the stored information, without intervention or assistance from a customer.
In some aspects, a DF table includes the metadata that is bound to a customer'"'"'s database schema, while the TableView is the UI aspect that surfaces the DT table on a display screen.
As an example, a table in a customer'"'"'s DF might appear in a MasterView, as well as a secondary view. The secondary view might be a Geography view. The Geography view might only show tables that are bound together by a geographic meaning or definition. Yet another view might be a “Products” view, wherein only tables having a products relationship are shown. In this present example, a table “Country” might be presented in three different views, including a MasterView, a GeopgraphyView, and a ProductsView. Depending on a context, the one table “Country” can appear in different contexts. A TableView created for each context addresses the UI graphical aspects corresponding to the table “Country”.
In some embodiments, particular tables referred to herein as “Subject” tables are used to store all set membership based on a specific subject. These tables are important as they are the only set tables to join directly to a customer table(s). Other set tables might have internal relationships. Subject tables provide a mechanism to link DF tables to a customer'"'"'s table.
A customer defines the Subject based on what category of sets they would like to build, for example, sets based on “customers” or “products”. In some aspects, one or more BO'"'"'s may be part of a Subject, where each BO is bound to a Primary key column in the DF. As an example and referring to
Based on an identified/determined subject BO for a customer database, the Subject table can be joined to the correct Customer table. A set table is joined to the primary key column of a customer table, where the customer has defined the primary key for their table. In the example illustrated in
In the example code shown in
Set tables other than Subject tables (i.e., other tables) are created in a same way as the subject table, but the joins are all defined between the set tables and not to external customer tables (e.g., a subject table). Given the joins between the set tables are internal to sets and do not change, joins of the other tables (i.e., tables other than Subject tables) can be programmatically created as needed.
In some aspects, a process of creating joins for set tables other than a Subject table may be the same as or similar to the process disclosed for a subject table. However, a difference does exist because a different list of left columns and right columns is specified to create the join depending on the known structure and connections between set tables. The structure and internal connections between the other set tables is fully known by a developer, administrator, etc. since they “own” all of the other set tables, in contrast to the Subject table scenario.
In some aspects, a consistent set or cluster of tables (i.e., other tables) may be created and then this set of tables may be attached to the customer'"'"'s table with one join from a created Subject table.
In accordance with some design practices and/or quality controls, loops might be avoided in the design of the DF by ensuring all paths within the DF are well defined so there are no ambiguities. Adhering to this design principle, may be particularly important in the context of auto-generating the DF, in some embodiments herein.
While there is one table per subject in some embodiments, the other tables that store metadata related to sets may be shared by all subjects. This aspect might cause loops between subjects, leading to errors in the DF and query generation. For example, multiple subjects might join to the same metadata tables, thereby causing an ambiguity.
In some embodiments, potential ambiguities may be addressed by using Alias tables to avoid loops, where the Alias tables seamlessly integrate with any existing customer design. Loops may be avoided by having a first subject that generates joins directly to the core metadata tables. Thereafter, subsequent subjects will join to alias tables of these core metadata tables and thereby avoid direct loops.
In some aspects, a table may be present just once. For example, a set “history” is created for a first subject. Here, no alias is needed. For a second subject, we again need to refer to the set “history”. Since the set “history’ is already present, an alias may be created to avoid a loop by joining to the set “history” again. The thus created alias of the set “history” may be referenced by the second subject. In some instances, additional aliases may be generated to accommodate additional subjects and avoid loops.
In some aspects, a database can have Views, where a View herein is a combination of multiple physical tables being displayed as one virtual table. In the context of the DF, these virtual tables are referred to as Derived Tables. In some embodiments, derived tables may be auto-generated in instances where it is determined there is no use-case to directly to include the physical tables. In some such scenarios, two or more physical tables may be combined into one derived table, where this derived table may be added to the DF instead of the multiple physical tables.
In some aspects, a SELECT statement may be used to define a derived table.
In some situations and use-cases, a simple join may not be sufficiently powerful or useful and a more complex mechanism may be needed. In some aspects, such scenarios might be addressed by using a SQL statement describing the complex join. For example,
At operation 2410, particular tables of the data foundation tables created at operation 2405 may be linked to a customer table in the customer'"'"'s database. The “particular” tables linked to a customer database in operation 2410 may be the Subject tables disclosed herein (e.g.,
At operation 2415, all of the created data foundation tables (i.e., data foundation fragments) are stored in a dedicated data structure hosted by the first (i.e., original) set container referenced in operation 2405. In some aspects, the DF tables created based on the set tables as disclosed in operation 2400 model the set tables and make them available in the augmented Universe and thereby expose them to the Query Panels.
Process 2400 may, in some embodiments, include all of the operations shown in
Referring again to
As disclosed hereinabove, a group of tables may be generated per set subject, as defined in a set container, wherein these table are only generated by the materialization process. To further provide for a consumption of these tables, a universe may be organized such that each subject has a root folder and all objects related to each respective subject are contained within the root folder. Referring to
In some embodiments, other methods of organization of folder and data structures might be used in addition to, instead of, or otherwise in combination with the aspects of
The creation of a folder may be accomplished by a process implemented in code, such as the example code sample shown in
In some aspects, generating simple BOs based on a DF includes generating one folder per table and then one object (i.e., BO) per column of the table. This task might be accomplished automatically in some embodiments herein.
As discussed above (e.g.,
In some instances, an expression as illustrated in
In some instances, adding many dimensions (e.g., one per column) may pollute a Universe generated herein. In such instances, attributes can be generated that are displayed under a more prominent dimension, as seen in
Another difference might be that an attribute is assigned to a parent, as demonstrated by the following:
Regarding the creating of measures, measures might be created in a manner similar to creating dimensions.
String expression∞“COUNT(37 +qualifiredTableName+”,“+col.getBusinessName( )+‘)’;
In some instances, other functions such as, for example, MIN, MAX, SUM, etc. might be used alone and/or in combination with each other and other functions to accomplish an aggregation.
In addition to BL objects being defined by dimensions, measures, attributes thereof, filters can also be added to the BOs. In some aspects, filters may act to constrain a result to be bound to a specific subject (e.g., “Products” “Customers”, etc.) In some embodiments, filters might be generated in a manner comparable to dimensions depending on requirements. In the sample code shown in
In some instances, a filter may be a “mandatory” filter, where mandatory filters are always applied to any query depending on their configuration. In some embodiments herein, mandatory filters are defined to ensure all objects within a given subject folder are filtered to only show results constrained to this specific subject. Accordingly, the mandatory filter is applied to the subject folder. This aspect is illustrated in
In some embodiments, other types of filters, referred to herein as business filters, may be implemented to generate a specific use-case and/or complex filters. These filters may also be defined by a using a query panel 3700, as shown in
In some embodiments, a business filter might rely on an XML representation of the Query Panel selection to be provided, which is referred to herein as a Query Specification (QS). In some instances, a QS might be constructed manually using a string or an API might be used (e.g., a “Query Technique” API) to build a query and then convert it into XML, as illustrated by the sample code of
In some aspects, the robustness and power of a customer'"'"'s BL might be more fully realized by creating more complex objects (e.g., BOs) than simple BOs. The complex objects may provide and/or facilitate greater flexibility and value to a customer—as well as their users.
In some aspects, complex objects might be created to further allow the creation of analytics for Sets. However, in accordance with some aspects herein the generation of the BL might be tailored for this and/or other objective(s).
In some aspects, the power of complex BO'"'"'s is provided in their SQL expression. For simple objects, we may completely auto-generate the expression, but in the case of complex expressions the corresponding SQL may need to be predefined based on the desired objective(s).
In some aspects, a BO created with a complex expression may be tailored to the database (DB) platform the customer runs on. However, due to the fact Sets may support multiple databases (e.g., Oracle, MS SQL Server, IBM Teradata, etc.) and each database uses varying syntax (e.g., for example date expressions), then the auto-generation of such objects may also need to account for all supported platforms. Accordingly, auto-generation functions may be made aware of which DB the BL is being generated for. Knowledge of the particular DB may be known or determined based on the connection attached to the Universe and as encapsulated in a class (e.g., Java) that abstracts the specific DB and substitutes the correct syntax when needed.
In some embodiments, a SQL expression should be as generic as possible to support as many DB platforms as possible. An example of such an expression can be seen in the example sample code shown in
In some aspects, once the generic expression is defined for multiple DB platforms, a method may be used to substitute the DB syntax specifics at runtime. An example of such a method is shown in
In some aspects, the novel and innovation aspects of auto-generating the BL herein for Sets is advantageous on a technical level. In an effort to address some usability and customer-friendly aspects, additional aspects may be considered. Such considerations might include, for example, allowing a customer to view what was generated before enabling it for end users; controlling which generated objects are displayed to end users; and customizing generated objects (if needed), where the customization might include, for example, renaming objects, SQL optimizations or refinements, testing object results in a local QP, and other functional improvements.
In some embodiments, the generated objects for the DF and BL may be stored as fragments in the Set container. Such storage supports the provisioning of user customizations such as those listed above. For example, a user interface including a Sets control panel (e.g., ‘Containers Management’) may be used without compromising the customer'"'"'s published universe.
From the Analytics tab 4305, the subject folders and all objects generated underneath them are shown. A user may also select a specific generated object to view/modify its SQL expression, rename it if needed, change its security policy, its visibility, and other refinements by modifying its properties at 4310. In this manner, BOs generated based on the DF additions herein may be configured in a robust and expansive manner.
In one aspect, the auto-generation of Sets Analytics herein may be selected or de-selected at 4315. If de-selected (i.e., turned off) then the subject universe will perform as usual without any augmented universe features/aspects.
In some aspects, the customization of BOs constructed based on DF additions is possible because an in-memory copy of the customer'"'"'s universe are operated on and the DF fragments are merged into it to create a transient universe. The transient universe is used to display BOs consistent with the customer'"'"'s DB. The process of merging the generated DF fragments into the original universe is referred to herein as ‘Augmentation Playback’ and is discussed in greater detail hereinbelow.
In some embodiments, in addition to viewing the BL, a user may also view the augmented DF and all of its generated objects as illustrated in the UI shown in
To achieve a reconstruction of a universe on every QP request (or other product application tool at runtime), the present disclosure includes a sophisticated mechanism that may include a number of constraints. In particular embodiments, this mechanism stores both data foundation (DF) and business layer (BL) generated objects outside of the published universe (e.g., so as not to perturb the published universe); it is able to surgically inject each auto-generated object into the correct location without disrupting the integrity of the universe; it is able to restore the universe to its initial state upon the completion of a QP (or other product application tool) since, for example, the universe will eventually be cached and could be used for other purposes that do not use the augmented sets-related data; and it should be sufficiently fast and efficient so that its impact on QP load times are minimal. This Augmentation Playback mechanism will now be described in detail below.
Augmentation Playback may be invoked in response to a query of a semantic layer universe involving at least one sets-related DF and BL auto-generated objects, in accordance with the present disclosure. As a prerequisite to an Augmentation Playback process herein, there is a generation and registration of DF and BL objects. When augmentation is being performed for a first time (i.e., nothing is stored), an initial generation is initiated. During this generation phase, every automatically created object is catalogued in a list of model fragments. These fragments may act as a reference as to how to build the final augmentation.
In some aspects, the above-described lists are to be persisted into an underlying model so they may be saved offline and restored in memory, as often as required.
The code sample depicted in
In some aspects, in order to perform an augmentation ‘playback’ herein, every reference stored in the persistence model is read from its storage location and injected into memory, rather than being generated repeatedly again and again when called upon/requested. In some aspects, this feature enables a fast and efficient operation that does not adversely impact QP load times.
The injection process for an augmentation playback is very complex, particularly with regards to the DF since it involves reattaching persisted model fragments to a complete ‘live’ model in a specific order. Herein, the injection of the persistence model to the in-memory universe may be automated at the code level. As such, any discrepancies in attaching or reattaching objects in the primary universe may result in errors that might be propagated through the universe. Accordingly, it is important that all generated objects be properly attached to the universe.
To achieve the desired aspect of injecting each generated object into a live DF, each object, depending on its nature, is retrieved from its storage fragment, before being reattached to the ‘live’ DF in a very specific order to ensure all aspects of the customer'"'"'s universe remain fully functional. That is, the nature of each type of object being ‘injected’ into the live DF is considered in order to ensure that the customer'"'"'s universe operates correctly after the injection process. Accordingly, there is a specific injecting process per each different type of object being injected into the DF of the universe.
In some aspects, a sorting process may be performed to ensure the DF objects are injected to the DF in a proper order so that, for example, the functionality of the universe is fully maintained. In some aspects, the DF objects are injected before the BL objects since the BL depends on the DF. Likewise, columns and tables are injected before joins since joins necessarily depend on tables and joins. As shown in
In some aspects, a sorting process herein may be implemented by the use of a coded processing algorithm. A sorting process herein may take into consideration design or model aspects of a universe. For example, a universe comprises columns, tables, joins, and views in a hierarchical configuration. In some embodiments, a sorting process herein may be supported by assigning different weights to different objects types. A weight is assigned to each object type, with the lowest weight being the most dependent. That is, the object type with the lowest weight is the last to be achieved and the object type with the highest weight is the first to be achieved. The sorting algorithm depicted in
An underlying model may impose specific constraints, such as, for example, “an object can only belong to one model”. Thus, if we want to remap reference points from their fragment to the ‘live’ DF, then we use copies of objects. Otherwise, original elements will be moved, thereby corrupting our references for future injections. The following sample code may be used to create copies in some embodiments.
Once the copies are generated, the sorted copies may be attached to the live DF. However, simply attaching copies to the live DF might not be sufficient in some cases, and for these cases we ensure that all objects are added (e.g., one by one) consistent with each other, as well as with the target DF. Accordingly, in many instances a sequence of operations is relied upon, with the sequence of operations including (1) attaching and (2) remapping, if need be. The specific aspects for a sequence of operations may vary depending on the type of object being injected into the DF. The present disclosure includes illustrative operations for attaching and remapping (if any) of different types of objects.
For tables, it is noted that all table types follow a basic attaching procedure. Then, depending on their subtype, additional computations may be performed for remapping them to the ‘live’ DF environment. The basic attaching procedure may be performed in accordance with the following:
For Derived tables (i.e., dynamic constructs based on SQL (actual) tables), the attaching may be the same as other tables, as seen above. For remapping of derived tables, a most important aspect is their SQL expression, from which the table definition (e.g. column instances) is deduced. The SQL expression of the table is to be bound to the DF in some manner not sure this is relevant right here as we are talking about DF related objects. The expression must be re-encoded to match the live DF and the data source remapped, as demonstrated below:
Here, re-encoding is needed since, although the string expression uses the same column names in both worlds I.e., customer'"'"'s live DF and the in-memory instance), the in-memory instances of such columns are different.
For SQL tables (i.e., standard tables coming from the DB'"'"'s catalogue), the attaching may be accomplished the same as other tables, as generally disclosed above. For remapping, only the SQL Table'"'"'s data source needs to be remapped, as shown by the example below:
Regarding alias tables (i.e., mirror images mimicking an original table; used to break loops), attaching may be accomplished like all tables, disclosed above. There may be an additional operation to consider however since, by their nature, aliases must “listen” to their original table in order to reflect all changes performed on the original table. Accordingly, the following code may be used for alias tables:
Regarding remapping of alias tables, since the original table of an alias table has been transported from one environment to the other via a copy, the alias needs to re-point to the copy of the original. It is noted that an alias table does not have a data source of its own, it instead uses the original table'"'"'s data source. Remapping of alias tables may be accomplished by the following example code:
For Data Foundation views (i.e., groupings of TableViews), several data foundation views may be created for the end-user to help their understanding of what was auto-generated by logically grouping associated DF elements together. One view is created per subject, plus one view that contains the Customer schema before injection (i.e., the fully augmented DF will be found in the Master view that stores all tables).
For the attaching operation, the following code sample demonstrates how data foundation views are dispatched in two separate buckets, based on their name and then added to the DF. In particular:
In some embodiments, a remapping for DF views is not needed.
For the object type Families (i.e., a UI concept used to alter the display of TableViews (e.g., text color, font, size, background, etc.)), an attaching procedure is straightforward and is applied to the sole family auto-generated in the following manner:
Regarding a remapping, only one autogenerated family is created. Accordingly, we only collect it for future use by Table Views (see next sub-section).
For TableViews (i.e., UI embodiments of Tables including positioning on-screen, families), TableViews (TV) may be particularly difficult to attach and remap since each TV belongs to one Data Foundation View (DFV). Accordingly, care may be taken to ensure that each TV is correctly attached to the correct DFV. The standard TV model does not really support extra pieces of information that might help with a remapping procedure. Therefore, pairing information may be stored by tagging the description of the TV with an ownership data during the generation process. This additional information may then be retrieved as a TableViewInfo. In some embodiments, there may be five potential locations a TV can belong to, including:
- CUSTOMER_IN_DEDICATED: This TV relates to a Customer'"'"'s subject table, in its dedicated DFV
- GENERATED_IN_DEDICATED: A fully-generated TV, in its dedicated DFV
- CUSTOMER_IN_MASTER: A Customer'"'"'s subject TV, in the Master view
- GENERATED_IN_MASTER: A fully-generated TV, in the Master view
- CUSTOMER_IN_ORIGINAL: A Customer TV in the pre-injection DFV
The code sample included in
Once we know where to look based on the associated tags, attaching TVs may be a matter of finding the right DFV based on what the TV'"'"'s description (filled at generation-time) specifies, as the code sample in
Regarding a remapping of TVs, the TableViewInfo introduced above also contains the identifier of the SQL Table of which the TV is the UI reflection. In some aspects, care is taken to make sure Customer related TV are not remapped since they already map to the correct SQL Table from the original DF created by the client. This aspect is addressed by the sample code listing in
For the object type of Joins (i.e., SQL relationships between two tables, through their columns), the attaching procedure is straightforward, common to all joins, and can be accomplished by the following:
For remapping of Joins, a most important aspect is the SQL expression from which involved column instances are deduced. The expression is re-encoded to match the live DF because although the string expression uses the same column names in both worlds, the in-memory instances of such columns are different. As such, the sample code below may be used:
In some aspects regarding a Business Layer Injection, the generated Business Layer objects are added on top of the generated DF. In some aspects, a BL injection herein is simpler than the DF injection process that is specific per object type. For the BL injection, the folder including the BL fragments or additions and all its contents, including sub-folders and Business Objects (BO) contained therein are copied, as demonstrated in the sample code below:
For remapping, each generated BO has an associated expression (i.e., binding). When attaching these back to the Universe, the BO needs have their expressions re-encoded according to the universe/DFX they are being attached to. This re-encoding process can be seen below:
The attaching procedure is straightforward and includes attaching the folder to the Universe root folder, as demonstrated bellow:
universe.gotRootFolder( ).getBusinessItems( ).add(blxAdditions);
In some aspects, it may be important to remove any augmentation and restore the universe back to its original state upon completion of a QP (or other) process using an augmented universe herein. This may be done so that, for example, other processes that require use of the universe without the sets-related augmentation data are not adversely affected by the augmentation. The process for restoring a universe back to its pre-augmentation original state is referred to herein as “clean-up”.
In some aspects, augmentations may be cleaned-up because a next process might not need the augmentation. In this manner, a system and method herein may avoid changing a universe and impacting a process that uses the universe but does not need to augmentations. In some aspects herein, when a process requests augmentation based on sets-related tables, a mapping is done based on the configuration of the universe. The augmentation playback runs to add all of the generated fragments to the universe. A user may complete an operation (i.e. QP query) and when the operation is complete, a rollback or clean-up process may be invoked to restore the universe to its original state prior to the augmentation. The universe may still be cached but it is restored to its original state that it was initially before the augmentation, without sets augmentation.
For Universe Clean-up (i.e., removing the augmented folder from the universe root), the augmented Universe is reviewed to identify the augmented folder by a property that that was assigned to this folder during augmentation generation. Namely, the root folder added during the augmentation process to contain all of the auto-generated fragments is searched for and identified. The following sample code may be used for this purpose.
Once this folder is identified, it can be removed from the Universe as shown below.
For DFX (DataFoundation) Clean-up (i.e., removing the augmented folder from the universe root), we first need to collect all generated objects from the DFX and add them to a list. Here too, we can identify each object by tags applied to the objects during the generation process.
For DFX Views, generated DFX views are retrieved and then added to the list. This may be accomplished by the sample code below.
From each DFX view, the corresponding generated tables need to be retrieved and collected. The specific procedure may vary for the different types of tables. For example, for SQL Tables, the retrieval and collection might be performed by the following sample code.
For Alias Tables, the retrieval and collection might be performed by the following sample code.
For Derived Tables, the retrieval and collection might be performed by the following sample code.
Regarding DFX clean-up of joins, as the generated tables are collected (e.g., as disclosed above), all of the joins attached to these same generated tables may be collected. Code encapsulating this feature might be implemented by, for example, the sample code depicted in
After collecting a list of generated objects, they may be removed from the DFX, for example, as shown in the code in
In some aspects, a general life-cycle of the generated objects may be considered. As disclosed herein, objects are generated based on Set Subjects. Accordingly, we may consider whether subject tables are renamed, new subjects are added, subjects are removed, whether the general metadata tables are renamed, or otherwise changed. Since these types of changes impact saved fragments related to changed subjects, the saved fragments need to be updated to reflect the changed subjects. The updating of saved fragments may entail the adding and/or deleting of tables and joins, the renaming of tables, etc. incrementally as necessitated by the changes.
For example, if a customer adds a new subject to their universe then a previous list of stored fragments will not include the new subject. Therefore, an incremental regeneration of objects for the newly added subject may be invoked to add updated objects to the existing fragments so that when a ‘playback’ is later executed, it runs with the latest version of subjects.
In some aspects for changes to a subject, the subject related objects may be incrementally regenerated by (1) identifying the “out of date” (i.e., changed) subjects; (2) ensuring their ID'"'"'s are recorded so newly generated object(s) can maintain these ID'"'"'s, where this is to ensure any reports based on these objects are still functional; and (3) only generate new objects for this subject and use the recorded ID'"'"'s to remap these new objects. For new subjects we only generate new objects and add them to the live DFX and universe.
Apparatus 5500 includes processor 5505 operatively coupled to communication device 5520, data storage device 5530, one or more input devices 5510, one or more output devices 5520 and memory 5525. Communication device 5515 may facilitate communication with external devices, such as a reporting client, or a data storage device. Input device(s) 5510 may comprise, for example, a keyboard, a keypad, a mouse or other pointing device, a microphone, knob or a switch, an infra-red (IR) port, a docking station, and/or a touch screen. Input device(s) 5510 may be used, for example, to enter information into apparatus 5500. Output device(s) 5520 may comprise, for example, a display (e.g., a display screen) a speaker, and/or a printer.
Data storage device 5530 may comprise any appropriate persistent storage device, including combinations of magnetic storage devices (e.g., magnetic tape, hard disk drives and flash memory), optical storage devices, Read Only Memory (ROM) devices, etc., while memory 5525 may comprise Random Access Memory (RAM), Storage Class Memory (SCM) or any other fast-access memory.
Services 5535 and application 5540 may comprise program code executed by processor 5505 to cause apparatus 5500 to perform any one or more of the processes (e.g., process 2400) described herein. Embodiments are not limited to execution of these processes by a single apparatus.
Data 5545 and metadata 5550 (either cached or a full database) may be stored in volatile memory such as memory 5525. Metadata 5550 may include information regarding fields, attributes, and methods of objects comprising a semantic layer. Data storage device 5530 may also store data and other program code and instructions for providing additional functionality and/or which are necessary for operation of apparatus 5500, such as device drivers, operating system files, etc.
The foregoing diagrams represent logical architectures for describing processes according to some embodiments, and actual implementations may include more or different components arranged in other manners. Other topologies may be used in conjunction with other embodiments. Moreover, each component or device described herein may be implemented by any number of devices in communication via any number of other public and/or private networks. Two or more of such computing devices may be located remote from one another and may communicate with one another via any known manner of network(s) and/or a dedicated connection. Each component or device may comprise any number of hardware and/or software elements suitable to provide the functions described herein as well as any other functions. For example, any computing device used in an implementation of a system according to some embodiments may include a processor to execute program code such that the computing device operates as described herein.
All systems and processes discussed herein may be embodied in program code stored on one or more non-transitory computer-readable media. Such media may include, for example, a floppy disk, a CD-ROM, a DVD-ROM, a Flash drive, magnetic tape, and solid state Random Access Memory (RAM) or Read Only Memory (ROM) storage units. Embodiments are therefore not limited to any specific combination of hardware and software.
Embodiments described herein are solely for the purpose of illustration. Those in the art will recognize other embodiments may be practiced with modifications and alterations to that described above.