A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
The present disclosure relates to providing custom settings in an on-demand service environment and, in particular, to creating and editing custom settings for users and organizations.
The subject matter discussed in the background section should not be assumed to be prior art merely as a result of its mention in the background section. Similarly, a problem mentioned in the background section or associated with the subject matter of the background section should not be assumed to have been previously recognized in the prior art. The subject matter in the background section merely represents different approaches, which in and of themselves may also be inventions.
In conventional database systems, users access their data resources in one logical database. A user of such a conventional system typically retrieves data from and stores data on the system using the user's own systems. A user system might remotely access one of a plurality of server systems that might in turn access the database system. Data retrieval from the system might include the issuance of a query from the user system to the database system. The database system might process the request for information received in the query and send to the user system information relevant to the request. The rapid and efficient retrieval of accurate information and subsequent delivery of this information to the user system in a manner that is easy to understand has been and continues to be a goal of administrators of database systems.
Unfortunately, conventional database approaches might confuse the user or be difficult to use if the data is not presented in a convenient way and combined with other data from other sources or from additional searches. While such benefits can be provided with powerful and additional searches, the database system may process a query relatively slowly if, for example, a relatively large number of users substantially concurrently demand deeper and wider levels of information presented in an easier to user form.
Accordingly, it is desirable to provide techniques enabling applications to call custom objects that can access supplemental data from local cache to combine with the query results from the database system.
In accordance with embodiments, there are provided mechanisms and methods for providing custom settings in an on-demand service environment. These mechanisms and methods for providing custom settings in an on-demand service environment can enable embodiments to provide fast and ready access to custom views and functions using a cache from the application for which the custom setting were created. The ability of embodiments to provide custom setting from a cache can enable more efficient and reduced database querying and use.
In accordance with embodiments, there are provided mechanisms and methods for providing custom settings in an on-demand service environment. In an embodiment and by way of example, a method providing custom settings in an on-demand service environment is provided. The method embodiment includes naming the custom object, creating fields for the custom object, assigning a behavior for each field, setting the custom object to a specified type, and if the custom object is of a hierarchical type, then assigning permissions to users with regarding the created fields.
While one or more implementations and techniques are described with reference to an embodiment in which method and systems for providing custom settings in an on-demand service environment is implemented in a system having an application server providing a front end for an on-demand database service capable of supporting multiple tenants, the one or more implementations and techniques are not limited to multi-tenant databases nor deployment on application servers. Embodiments may be practiced using other database architectures, i.e., ORACLE®, DB2® by IBM and the like without departing from the scope of the embodiments claimed.
Any of the above embodiments may be used alone or together with one another in any combination. The one or more implementations encompassed within this specification may also include embodiments that are only partially mentioned or alluded to or are not mentioned or alluded to at all in this brief summary or in the abstract. Although various embodiments may have been motivated by various deficiencies with the prior art, which may be discussed or alluded to in one or more places in the specification, the embodiments do not necessarily address any of these deficiencies. In other words, different embodiments may address different deficiencies that may be discussed in the specification. Some embodiments may only partially address some deficiencies or just one deficiency that may be discussed in the specification, and some embodiments may not address any of these deficiencies.
In the following drawings like reference numbers are used to refer to like elements. Although the following figures depict various examples of the invention, the invention is not limited to the examples depicted in the figures.
General Overview
Systems and methods are provided providing custom settings in an on-demand service environment. These systems and methods are particularly valuable in the context of a multi-tenant database.
As used herein, the term multi-tenant database system refers to those systems in which various elements of hardware and software of the database system may be shared by one or more customers. For example, a given application server may simultaneously process requests for a great number of customers, and a given database table may store rows for a potentially much greater number of customers. As used herein, the term query plan refers to a set of steps used to access information in a database system.
Database applications are enhanced using metadata for service. Metadata can allow users to add custom fields, create custom objects, and to control create, read, update and delete access across the system based on profiles, identities and user groups.
With some metadata-rich platforms, developers package a custom object or set of custom objects that control the behavior of an application for users within their application. A packaged custom object can inhibit a user's access to the custom objects and increase the number of queries performed on the database. In other cases, a packaged custom object might not preserve security access rights.
The custom setting structure described below uses two mechanisms. First, custom settings lists are created at the application level. These lists can be stored as application caches accessible through an API.
Second, the actual settings are created and associated with users at organization, profile, and user levels. When the application invokes a custom setting it can make a call into the API. The API can then traverse the users, profiles, and organizations within the cache to determine the values of the custom settings for the current status of the application.
Both mechanisms will expose the data within the application cache to the application and possibly to the user. This enables efficient access to these objects without the cost of a query to the system. Examples of where these objects will be accessible include: Apex Code; Scontrols; Apex Pages; Validation Rules; and Formula Fields.
The custom settings correspond to objects accessible by particular applications through an API. The API is used to enable the association to applications. In other words, the API abstracts the caller, which is the application, from the settings hierarchy. By storing these settings in an application cache, the cache can be traversed before an application accesses the database. This allows any database query to be more carefully focused for the particular user's needs. This reduces the amount of database resources consumed by the application overall.
A further benefit of using custom settings through an API is that the application is separate from the API and from the cache. The application can be changed, in some ways, without affecting the custom settings and the custom settings can be changed without affecting the application. The cache for the settings can even be restricted for application developers without interfering with the development of the application. Similarly, users and developers can modify the custom setting without any knowledge of the underlying application code. The API between the application and the cache allows the application code and the cache to be completely segregated.
Structure
Embodiment of the present invention provide an ability for customers to add custom fields, create custom objects, control create, read, update and delete access across their system on a profile level, etc, all with a point and click interface. This can be an enabling technology to simplify management of applications by a wide range of administrators and users.
In the example described herein there are two types of custom settings: 1) Application Settings, 2) Hierarchy Settings. The Application type may be used to provide the ability to create 1:N Settings at the Organizational level. Alternatively, the Application type may be applied to a different level. The Application settings affect the operation of an application. The Hierarchy type may be used to create settings at that differ at different levels within a hierarchy. Hierarchy levels can include the Organization, Profile, and User level. In the described example, the Hierarchy type is a singleton, that is for a given profile or user, there can only be one instance.
User Interface
The resource and services are grouped under a heading labeled “App Setup” 102. Different labels may be used and more headers may be used to provide more or fewer options. The application setup heading includes sub-headings for customizing 104, creating 106 and developing 108. Under the “Develop” heading 108, the user is offered an opportunity to view any installed packages 110. From a list of installed packages, the user or developer may then be able to apply other resources to customize the package, or create or develop new packages. Each header may have multiple sub-headers or specific choices within the hierarchical directory. While a hierarchical directory is shown, the directory may take any of a variety of other forms.
On the main part of the display, the user interface presents title bar 112, which identifies the displayed view as a main Custom Settings view in the title. The title bar also present a help option. The Custom Setting view includes main window 114 which contains an Action list 116 to display a choice of different actions to take, such as configure or delete custom settings. A Custom Setting Name list 118 allows the user to view and select any desired set of custom settings. In the illustrated example, there is only one choice, labeled AccountMap Preferences. A Setting type list 120 allows the user to see the type for each displayed custom setting. In the described example, a Custom Setting can be an application type or an hierarchical type, however, other types may also be developed to suit particular examples. Last a Description list 122 is shown to provide a short description of each listed custom setting. The description can be provided by the developer to aid in identifying a particular custom setting. In the illustrated example, the custom setting “AccountMap preferences” is described by “This setting drives the Account Map Functionality.”
The Custom Setting View also provides a second window 124 to show additional custom settings from other sources. The illustrated example is a window for “Custom Settings installed from Appexchange.” These custom settings have been installed from an external source, in this case an application exchange provided by the database service provider to allow users to enhance the usability of the database system. There may be more windows to show custom settings from more sources or multiple sources may be shown in a single window.
Like the Custom Settings window 114, the additional custom settings window 124 includes a lists for actions 126 to perform on each custom setting, the names 128 for each custom setting, a type 130 for each custom setting, and a description 132.
From the main Custom Settings window 112, a user or developer has an overview of all of the available custom settings and is able to modify or delete each one. In addition, the user or developer can create new custom settings as shown in
To create a new custom setting, the user may be presented with a Custom Settings Definition window 144. In this window, the user can provide a label for the custom setting in a label window 146. The label may be used when viewing the custom setting in any application to which it relates. The user may also provide a name for the new setting in a custom setting name window 148. The name may be used when referencing the setting via a formula field, an application, an API (Application Programming Interface) or in the main custom settings view of
Referring to the custom setting called AccountMap Preferences of
Account Map Preferences for a label in the label box 146. For the name box 148, the user would have entered AccountMap Preferences. For the type, the user would have selected hierarchical, and for the description box 152, the user would have entered, “This setting drives the Account Map functionality.”
In the illustrated example of
Within the directory shown for Setup-Create-Custom Settings, administrators, with customize application permissions, may be allowed to have the ability to create Custom Settings definitions. Creating a Custom Settings definition is similar to creating a custom object definition. Depending on the implementation there can be several differences provided. In one example, there is no name field, there are no help settings, there are no reports on these objects, and the standard related objects are not supported. The standard related objects may include activities, notes and attachments. In addition, custom tabs may be excluded from a Custom Settings definition.
Additional differences between standard custom object definitions and Custom Settings object definitions can be provided depending on the particular implementation. In one example, there is no owner field, standard objects and standard custom objects cannot be related to Custom Settings objects, and custom buttons and links are not supported. In addition, search layouts and record types may also be excluded. These simplifications together with a single page layout allow Custom Settings, as described herein to be create, modified, used, and supported simply and easily.
The example user interface of
Currency allows users to enter a dollar or other currency amount and it automatically formats the field as a currency amount. The formatting is useful for exporting data to other programs.
Date allow users to enter a date or pick a date from a popup calendar.
Date/Time allows users to enter a date and time, or to pick a date from a popup calendar. When users click a date in the popup calendar, the date and time are entered into this field.
Email allows user to enter and email address. The entered address is validated to ensure that it is in the proper format. Users can then click on the field to automatically launch their email programs and send an email to that address.
Number allows user to enter any number. Leading zeroes may be removed.
Percent allows user to enter a percentage number, for example, 10 and the field automatically adds the percent sign to the number.
Phone allows user to enter any telephone number. The number is automatically formatted as a telephone number.
Picklist allows users to select a value from a list that is defined by the developer.
Picklist (Multi-Select) allows users to select multiple values from a list defined by the developer.
Text allows user to enter any combination of letters and numbers.
Text Area allows user to enter up to 255 characters on separate lines. The particular size of the text area and the types and number of characters supported can be adapted to suit different applications.
URL allows user to enter any valid website address. When users click on the field, the URL will open in a separate or a framed browser window.
After the user or developer makes a selection from the custom settings field window, the system moves to establish the features of the new field.
In this example, the user is provided with an interface to enter a field label using a text input box 236. The maximum length of the text field can be specified in another text box 238. A name can be specified for the field in another text box 240 and a description of the newly created text field can be specified in another text box 242. A variety of other features can also be presented depending on the particular implementation. In the illustrate example, the user may select several features using selection boxes. These may include that a value is required for this field before a record is saved 244. Duplicate values are prohibited or allowed 246. Case sensitivity can be turned on or off for duplicate values. An external identifier can be used as the unique record identifier suing a selection box 248 and a default value can be provided by the developer in a specified text box 250, if desired.
The example features shown in the custom setting window of
In one example, users with customize application permissions may be allowed to have the ability to update metadata objects. In addition to the displayed user interface, custom settings objects may also be managed through, Apex pages, and APIs.
A tile bar 312 identifies the level in the process of configuring a new custom setting as “Configure Custom Settings.” A further detail window 314 is labeled as “Organization Custom Settings.” This window allows for edit and cancel options. The window provides custom setting information 316 at the top of the window. This may include a geographic location and functions to be performed such as display a map, show a legend, and show a satellite view. Additional or different information may be provided, depending on the particular implementation. This information is useful for the AccountMap Preferences custom setting referred to earlier.
An overrides view 318 can be used to allow the user or developer to control any overrides. In the illustrated example, the user has selected to show all overrides. The window then lists all of the overrides in a list 322 by user name. For each named user, the override may be edited or deleted using selection boxes and selection icons. The overrides also all feature an override type list 324 for each user. The override type may be based on the particular user identity or a profile. The develop can also select to add an override 320. This user interface, accordingly, allows the developer to add, remove and edit overrides of different types for each user.
Org level values can also be overridden through the “add override” action 320. This action will render the user interface display of
Rather than the individual settings, org level values allows the mass selection of users and profiles. The settings associated to the selected user and profile can then be mass overridden. The user is provided with a first window 344 that allows the user to select users or profiles to override.
A user can begin to add overrides by searching for particular users or groups. In a pick list 346, a user can select a particular group of users to provide an override or to search within. In the illustrated example, the user has selected to search within the Public Groups. A text box 348, allows the user to search for a particular name or group within the selected group. In this example, the search box is not used and the results are shown in a list of results 350. The results show available members that match the search, in this case all of the users within the public group. Any one or more of these users can be added to a second box 352 that is the selected members. If any members had been selected already, then they could be removed from the list of selected members.
A second window 354 “Override Org Level Defaults” allows the user to pick the features of the class that will be overridden for the selected group. In the example class of
For List Settings, unlike Hierarchy settings, an override feature may not be desired. As shown in
For any particular view, the window allows the user to view the selected settings by name in a settings list 368 and see values for the setting 370. For each setting the user may edit or delete the setting or create new settings.
Access to the customization windows of
Use Cases
In a first example, a developer may desire that an application allow users the ability to retrieve preferences at both the organization level and the user level. This is then used to provide personalization for features of an organizational map. This date may normally be stored within the organization's hosted infrastructure. However, storing the organization map and its features in another location requires the organization to query both its internal setup tables and the database to render the customized Map pages. This is inefficient and presents design concerns if the hosted pages are ported to the database platform. With the custom map setting, described above, the map preferences can be stored within the database platform as custom settings.
In a second example, a developer may provide a scheduling feature, providing customers the ability to define the level of scheduling at either an individual day or time of day. By leveraging the custom settings, the developer could set these preferences at the organization level and, for particular cases, override some of those preferences at the profile or user level. In addition, the developer may provide a visual map component of the scheduling feature which can be turned on or off within an individual organization. This feature could be managed through a custom preferences table. However, the custom settings approach described above, allows the developer to set and access the visual map component more efficiently, while the end result requires less processing resources. The custom settings approach can also be used to track and store user session attributes. These features may include a “view last seen” feature which tracks the last view rendered within a user session.
In a third example, a developer may maintain a list of country codes in a custom object within the application in which the country codes are used. By using custom settings instead of a data table query, for example, direct access to these values is provided directly from the cache.
Process
Once the process is initiated, the user can name the custom object at block 512, the naming can include defining labels and descriptions and associating the custom object with an application or an API. Typically the application will call the API which will then refer to the custom settings to respond to the call from the application.
At block 514, the user or developer creates or edits fields for the custom object. The user interface as shown in
At block 516 a behavior is assigned for each field. This will typically be in the form of an action, however, the invention is not so limited. The behaviors may resemble those shown in
At block 518, a user sets the custom object to a specified type. In the provided examples, there are two types, list or application and hierarchical. Other and additional types may be used depending on the particular implementation. At block 520, if the custom object is of a hierarchical type, then the user permissions to users regarding the created fields. On the other hand, at block 522, if the custom object is of a list type then the user may configure a list for the object
As to assigning permissions, for a hierarchical type of custom setting, the permissions may also be hierarchical. In one example, permission values are first assigned to a primary level such as an organizational or group level. Then overrides are assigned at a second level, such as a group or individual user level.
System Overview
Environment 610 is an environment in which an on-demand database service exists. User system 612 may be any machine or system that is used by a user to access a database user system. For example, any of user systems 612 can be a handheld computing device, a mobile phone, a laptop computer, a work station, and/or a network of computing devices. As illustrated in
An on-demand database service, such as system 616, is a database system that is made available to outside users that do not need to necessarily be concerned with building and/or maintaining the database system, but instead may be available for their use when the users need the database system (e.g., on the demand of the users). Some on-demand database services may store information from one or more tenants stored into tables of a common database image to form a multi-tenant database system (MTS). Accordingly, “on-demand database service 616” and “system 616” will be used interchangeably herein. A database image may include one or more database objects. A relational database management system (RDMS) or the equivalent may execute storage and retrieval of information against the database object(s). Application platform 618 may be a framework that allows the applications of system 616 to run, such as the hardware and/or software, e.g., the operating system. In an embodiment, on-demand database service 616 may include an application platform 618 that enables creation, managing and executing one or more applications developed by the provider of the on-demand database service, users accessing the on-demand database service via user systems 612, or third party application developers accessing the on-demand database service via user systems 612.
The users of user systems 612 may differ in their respective capacities, and the capacity of a particular user system 612 might be entirely determined by permissions (permission levels) for the current user. For example, where a salesperson is using a particular user system 612 to interact with system 616, that user system has the capacities allotted to that salesperson. However, while an administrator is using that user system to interact with system 616, that user system has the capacities allotted to that administrator. In systems with a hierarchical role model, users at one permission level may have access to applications, data, and database information accessible by a lower permission level user, but may not have access to certain applications, database information, and data accessible by a user at a higher permission level. Thus, different users will have different capabilities with regard to accessing and modifying application and database information, depending on a user's security or permission level.
Network 614 is any network or combination of networks of devices that communicate with one another. For example, network 614 can be any one or any combination of a LAN (local area network), WAN (wide area network), telephone network, wireless network, point-to-point network, star network, token ring network, hub network, or other appropriate configuration. As the most common type of computer network in current use is a TCP/IP (Transfer Control Protocol and Internet Protocol) network, such as the global internetwork of networks often referred to as the “Internet” with a capital “I,” that network will be used in many of the examples herein. However, it should be understood that the networks that the present invention might use are not so limited, although TCP/IP is a frequently implemented protocol.
User systems 612 might communicate with system 616 using TCP/IP and, at a higher network level, use other common Internet protocols to communicate, such as HTTP, FTP, AFS, WAP, etc. In an example where HTTP is used, user system 612 might include an HTTP client commonly referred to as a “browser” for sending and receiving HTTP messages to and from an HTTP server at system 616. Such an HTTP server might be implemented as the sole network interface between system 616 and network 614, but other techniques might be used as well or instead. In some implementations, the interface between system 616 and network 614 includes load sharing functionality, such as round-robin HTTP request distributors to balance loads and distribute incoming HTTP requests evenly over a plurality of servers. At least as for the users that are accessing that server, each of the plurality of servers has access to the MTS' data; however, other alternative configurations may be used instead.
In one embodiment, system 616, shown in
One arrangement for elements of system 616 is shown in
Several elements in the system shown in
According to one embodiment, each user system 612 and all of its components are operator configurable using applications, such as a browser, including computer code run using a central processing unit such as an Intel Pentium® processor or the like. Similarly, system 616 (and additional instances of an MTS, where more than one is present) and all of their components might be operator configurable using application(s) including computer code to run using a central processing unit such as processor system 617, which may include an Intel Pentium® processor or the like, and/or multiple processor units. A computer program product embodiment includes a machine-readable storage medium (media) having instructions stored thereon/in which can be used to program a computer to perform any of the processes of the embodiments described herein. Computer code for operating and configuring system 616 to intercommunicate and to process webpages, applications and other data and media content as described herein are preferably downloaded and stored on a hard disk, but the entire program code, or portions thereof, may also be stored in any other volatile or non-volatile memory medium or device as is well known, such as a ROM or RAM, or provided on any media capable of storing program code, such as any type of rotating media including floppy disks, optical discs, digital versatile disk (DVD), compact disk (CD), microdrive, and magneto-optical disks, and magnetic or optical cards, nanosystems (including molecular memory ICs), or any type of media or device suitable for storing instructions and/or data. Additionally, the entire program code, or portions thereof, may be transmitted and downloaded from a software source over a transmission medium, e.g., over the Internet, or from another server, as is well known, or transmitted over any other conventional network connection as is well known (e.g., extranet, VPN, LAN, etc.) using any communication medium and protocols (e.g., TCP/IP, HTTP, HTTPS, Ethernet, etc.) as are well known. It will also be appreciated that computer code for implementing embodiments of the present invention can be implemented in any programming language that can be executed on a client system and/or server or server system such as, for example, C, C++, HTML, any other markup language, Java™, JavaScript, ActiveX, any other scripting language, such as VBScript, and many other programming languages as are well known may be used. (Java™ is a trademark of Sun Microsystems, Inc.).
According to one embodiment, each system 616 is configured to provide webpages, forms, applications, data and media content to user (client) systems 612 to support the access by user systems 612 as tenants of system 616. As such, system 616 provides security mechanisms to keep each tenant's data separate unless the data is shared. If more than one MTS is used, they may be located in close proximity to one another (e.g., in a server farm located in a single building or campus), or they may be distributed at locations remote from one another (e.g., one or more servers located in city A and one or more servers located in city B). As used herein, each MTS could include one or more logically and/or physically connected servers distributed locally or across one or more geographic locations. Additionally, the term “server” is meant to include a computer system, including processing hardware and process space(s), and an associated storage system and database application (e.g., OODBMS or RDBMS) as is well known in the art. It should also be understood that “server system” and “server” are often used interchangeably herein. Similarly, the database object described herein can be implemented as single databases, a distributed database, a collection of distributed databases, a database with redundant online or offline backups or other redundancies, etc., and might include a distributed database or storage network and associated processing intelligence.
User system 612, network 614, system 616, tenant data storage 622, and system data storage 624 were discussed above in
Application platform 618 includes an application setup mechanism 738 that supports application developers' creation and management of applications, which may be saved as metadata into tenant data storage 622 by save routines 736 for execution by subscribers as one or more tenant process spaces 704 managed by tenant management process 710 for example. Invocations to such applications may be coded using PL/SOQL 734 that provides a programming language style interface extension to API 732. A detailed description of some PL/SOQL language embodiments is discussed in commonly owned U.S. Pat. No. 7,730,478 entitled, METHOD AND SYSTEM FOR ALLOWING ACCESS TO DEVELOPED APPLICATIONS VIA A MULTI-TENANT DATABASE ON-DEMAND DATABASE SERVICE issued Jun. 1, 2010 to Craig Weissman, which is incorporated in its entirety herein for all purposes. Invocations to applications may be detected by one or more system processes, which manages retrieving application metadata 716 for the subscriber making the invocation and executing the metadata as an application in a virtual machine.
Each application server 700 may be communicably coupled to database systems, e.g., having access to system data 625 and tenant data 623, via a different network connection. For example, one application server 7001 might be coupled via the network 614 (e.g., the Internet), another application server 700N-1 might be coupled via a direct network link, and another application server 700N might be coupled by yet a different network connection. Transfer Control Protocol and Internet Protocol (TCP/IP) are typical protocols for communicating between application servers 700 and the database system. However, it will be apparent to one skilled in the art that other transport protocols may be used to optimize the system depending on the network interconnect used.
In certain embodiments, each application server 700 is configured to handle requests for any user associated with any organization that is a tenant. Because it is desirable to be able to add and remove application servers from the server pool at any time for any reason, there is preferably no server affinity for a user and/or organization to a specific application server 700. In one embodiment, therefore, an interface system implementing a load balancing function (e.g., an F5 Big-IP load balancer) is communicably coupled between the application servers 700 and the user systems 612 to distribute requests to the application servers 700. In one embodiment, the load balancer uses a least connections algorithm to route user requests to the application servers 700. Other examples of load balancing algorithms, such as round robin and observed response time, also can be used. For example, in certain embodiments, three consecutive requests from the same user could hit three different application servers 700, and three requests from different users could hit the same application server 700. In this manner, system 616 is multi-tenant, wherein system 616 handles storage of, and access to, different objects, data and applications across disparate users and organizations.
As an example of storage, one tenant might be a company that employs a sales force where each salesperson uses system 616 to manage their sales process. Thus, a user might maintain contact data, leads data, customer follow-up data, performance data, goals and progress data, etc., all applicable to that user's personal sales process (e.g., in tenant data storage 622). In an example of a MTS arrangement, since all of the data and the applications to access, view, modify, report, transmit, calculate, etc., can be maintained and accessed by a user system having nothing more than network access, the user can manage his or her sales efforts and cycles from any of many different user systems. For example, if a salesperson is visiting a customer and the customer has Internet access in their lobby, the salesperson can obtain critical updates as to that customer while waiting for the customer to arrive in the lobby.
While each user's data might be separate from other users' data regardless of the employers of each user, some data might be organization-wide data shared or accessible by a plurality of users or all of the users for a given organization that is a tenant. Thus, there might be some data structures managed by system 616 that are allocated at the tenant level while other data structures might be managed at the user level. Because an MTS might support multiple tenants including possible competitors, the MTS should have security protocols that keep data, applications, and application use separate. Also, because many tenants may opt for access to an MTS rather than maintain their own system, redundancy, up-time, and backup are additional functions that may be implemented in the MTS. In addition to user-specific data and tenant specific data, system 616 might also maintain system level data usable by multiple tenants or other data. Such system level data might include industry reports, news, postings, and the like that are sharable among tenants.
In certain embodiments, user systems 612 (which may be client systems) communicate with application servers 700 to request and update system-level and tenant-level data from system 616 that may require sending one or more queries to tenant data storage 622 and/or system data storage 624. System 616 (e.g., an application server 700 in system 616) automatically generates one or more SQL statements (e.g., one or more SQL queries) that are designed to access the desired information. System data storage 624 may generate query plans to access the requested data from the database.
Each database can generally be viewed as a collection of objects, such as a set of logical tables, containing data fitted into predefined categories. A “table” is one representation of a data object, and may be used herein to simplify the conceptual description of objects and custom objects according to the present invention. It should be understood that “table” and “object” may be used interchangeably herein. Each table generally contains one or more data categories logically arranged as columns or fields in a viewable schema. Each row or record of a table contains an instance of data for each category defined by the fields. For example, a CRM database may include a table that describes a customer with fields for basic contact information such as name, address, phone number, fax number, etc. Another table might describe a purchase order, including fields for information such as customer, product, sale price, date, etc. In some multi-tenant database systems, standard entity tables might be provided for use by all tenants. For CRM database applications, such standard entities might include tables for Account, Contact, Lead, and Opportunity data, each containing pre-defined fields. It should be understood that the word “entity” may also be used interchangeably herein with “object” and “table”.
While the invention has been described by way of example and in terms of the specific embodiments, it is to be understood that the invention is not limited to the disclosed embodiments. To the contrary, it is intended to cover various modifications and similar arrangements as would be apparent to those skilled in the art. Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements.
This application claims the benefit of U.S. Provisional Patent Application No. 61/325,488 entitled Methods and Systems for Appending Providing Custom Settings In An On-Demand Service Environment, by Unger et al., filed Apr. 19, 2010, the entire contents of which are incorporated herein by reference.
Number | Name | Date | Kind |
---|---|---|---|
5577188 | Zhu | Nov 1996 | A |
5608872 | Schwartz et al. | Mar 1997 | A |
5649104 | Carleton et al. | Jul 1997 | A |
5715450 | Ambrose et al. | Feb 1998 | A |
5761419 | Schwartz et al. | Jun 1998 | A |
5819038 | Carleton et al. | Oct 1998 | A |
5821937 | Tonelli et al. | Oct 1998 | A |
5831610 | Tonelli et al. | Nov 1998 | A |
5873096 | Lim et al. | Feb 1999 | A |
5918159 | Fomukong et al. | Jun 1999 | A |
5963953 | Cram et al. | Oct 1999 | A |
6092083 | Brodersen et al. | Jul 2000 | A |
6169534 | Raffel et al. | Jan 2001 | B1 |
6178425 | Brodersen et al. | Jan 2001 | B1 |
6189011 | Lim et al. | Feb 2001 | B1 |
6216135 | Brodersen et al. | Apr 2001 | B1 |
6233617 | Rothwein et al. | May 2001 | B1 |
6266669 | Brodersen et al. | Jul 2001 | B1 |
6295530 | Ritchie et al. | Sep 2001 | B1 |
6324568 | Diec | Nov 2001 | B1 |
6324693 | Brodersen et al. | Nov 2001 | B1 |
6336137 | Lee et al. | Jan 2002 | B1 |
D454139 | Feldcamp | Mar 2002 | S |
6367077 | Brodersen et al. | Apr 2002 | B1 |
6393605 | Loomans | May 2002 | B1 |
6405220 | Brodersen et al. | Jun 2002 | B1 |
6434550 | Warner et al. | Aug 2002 | B1 |
6446089 | Brodersen et al. | Sep 2002 | B1 |
6535909 | Rust | Mar 2003 | B1 |
6549908 | Loomans | Apr 2003 | B1 |
6553563 | Ambrose et al. | Apr 2003 | B2 |
6560461 | Fomukong et al. | May 2003 | B1 |
6574635 | Stauber et al. | Jun 2003 | B2 |
6577726 | Huang et al. | Jun 2003 | B1 |
6601087 | Zhu et al. | Jul 2003 | B1 |
6604117 | Lim et al. | Aug 2003 | B2 |
6604128 | Diec | Aug 2003 | B2 |
6609150 | Lee et al. | Aug 2003 | B2 |
6621834 | Scherpbier et al. | Sep 2003 | B1 |
6654032 | Zhu et al. | Nov 2003 | B1 |
6665648 | Brodersen et al. | Dec 2003 | B2 |
6665655 | Warner et al. | Dec 2003 | B1 |
6684438 | Brodersen et al. | Feb 2004 | B2 |
6711565 | Subramaniam et al. | Mar 2004 | B1 |
6724399 | Katchour et al. | Apr 2004 | B1 |
6728702 | Subramaniam et al. | Apr 2004 | B1 |
6728960 | Loomans | Apr 2004 | B1 |
6732095 | Warshavsky et al. | May 2004 | B1 |
6732100 | Brodersen et al. | May 2004 | B1 |
6732111 | Brodersen et al. | May 2004 | B2 |
6754681 | Brodersen et al. | Jun 2004 | B2 |
6763351 | Subramaniam et al. | Jul 2004 | B1 |
6763501 | Zhu et al. | Jul 2004 | B1 |
6768904 | Kim | Jul 2004 | B2 |
6782383 | Subramaniam et al. | Aug 2004 | B2 |
6804330 | Jones et al. | Oct 2004 | B1 |
6826565 | Ritchie et al. | Nov 2004 | B2 |
6826582 | Chatterjee et al. | Nov 2004 | B1 |
6826745 | Coker et al. | Nov 2004 | B2 |
6829655 | Huang et al. | Dec 2004 | B1 |
6842748 | Warner et al. | Jan 2005 | B1 |
6850895 | Brodersen et al. | Feb 2005 | B2 |
6850949 | Warner et al. | Feb 2005 | B2 |
7340411 | Cook | Mar 2008 | B2 |
7620655 | Larsson et al. | Nov 2009 | B2 |
20010044791 | Richter et al. | Nov 2001 | A1 |
20020022986 | Coker et al. | Feb 2002 | A1 |
20020029161 | Brodersen et al. | Mar 2002 | A1 |
20020029376 | Ambrose et al. | Mar 2002 | A1 |
20020035577 | Brodersen et al. | Mar 2002 | A1 |
20020042264 | Kim | Apr 2002 | A1 |
20020042843 | Diec | Apr 2002 | A1 |
20020072951 | Lee et al. | Jun 2002 | A1 |
20020082892 | Raffel et al. | Jun 2002 | A1 |
20020129352 | Brodersen et al. | Sep 2002 | A1 |
20020140731 | Subramaniam et al. | Oct 2002 | A1 |
20020143997 | Huang et al. | Oct 2002 | A1 |
20020152102 | Brodersen et al. | Oct 2002 | A1 |
20020161734 | Stauber et al. | Oct 2002 | A1 |
20020162090 | Parnell et al. | Oct 2002 | A1 |
20020165742 | Robins | Nov 2002 | A1 |
20030004971 | Gong et al. | Jan 2003 | A1 |
20030018705 | Chen et al. | Jan 2003 | A1 |
20030018830 | Chen et al. | Jan 2003 | A1 |
20030066031 | Laane | Apr 2003 | A1 |
20030066032 | Ramachadran et al. | Apr 2003 | A1 |
20030069936 | Warner et al. | Apr 2003 | A1 |
20030070000 | Coker et al. | Apr 2003 | A1 |
20030070004 | Mukundan et al. | Apr 2003 | A1 |
20030070005 | Mukundan et al. | Apr 2003 | A1 |
20030074418 | Coker | Apr 2003 | A1 |
20030088545 | Subramaniam et al. | May 2003 | A1 |
20030120675 | Stauber et al. | Jun 2003 | A1 |
20030151633 | George et al. | Aug 2003 | A1 |
20030159136 | Huang et al. | Aug 2003 | A1 |
20030187921 | Diec | Oct 2003 | A1 |
20030189600 | Gune et al. | Oct 2003 | A1 |
20030191743 | Brodersen et al. | Oct 2003 | A1 |
20030204427 | Gune et al. | Oct 2003 | A1 |
20030206192 | Chen et al. | Nov 2003 | A1 |
20030225730 | Warner et al. | Dec 2003 | A1 |
20040001092 | Rothwein et al. | Jan 2004 | A1 |
20040010489 | Rio | Jan 2004 | A1 |
20040015981 | Coker et al. | Jan 2004 | A1 |
20040027388 | Berg et al. | Feb 2004 | A1 |
20040128001 | Levin et al. | Jul 2004 | A1 |
20040186860 | Lee et al. | Sep 2004 | A1 |
20040193510 | Catahan, Jr. et al. | Sep 2004 | A1 |
20040199489 | Barnes-Leon et al. | Oct 2004 | A1 |
20040199536 | Barnes Leon et al. | Oct 2004 | A1 |
20040199543 | Braud et al. | Oct 2004 | A1 |
20040249854 | Barnes-Leon et al. | Dec 2004 | A1 |
20040260534 | Pak et al. | Dec 2004 | A1 |
20040260659 | Chan et al. | Dec 2004 | A1 |
20040268299 | Lei et al. | Dec 2004 | A1 |
20050050555 | Exley et al. | Mar 2005 | A1 |
20050091098 | Brodersen et al. | Apr 2005 | A1 |
20080082540 | Weissman et al. | Apr 2008 | A1 |
20110276892 | Jensen-Horne et al. | Nov 2011 | A1 |
Number | Date | Country | |
---|---|---|---|
20110258233 A1 | Oct 2011 | US |
Number | Date | Country | |
---|---|---|---|
61325488 | Apr 2010 | US |