US20150205583A1 - Intelligently recommending schemas based on user input - Google Patents

Abstract

The present invention extends to methods, systems, and computer program products for intelligently recommending schemas based on user input that defines a portion of a data structure. An intelligent auto-complete function can identify characteristics of the user input and, based on these characteristics, recommend schemas that are most likely to be selected by the user to complete the data structure or portion of the data structure. The identified characteristics of the user input can be compared to characteristics of defined schemas or of other data structures to identify schemas that are most likely to match the user's intent. These schemas are then recommended to the user. Such schemas can define the recommended shape of the data structure being defined, including data types for a particular column, columns to add to the data structure, or can define additional data structures to be added such as additional tables to a database.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS
• This application is a continuation of U.S. patent application Ser. No. 13/326,645 filed on Dec. 15, 2011, entitled “INTELLIGENTLY RECOMMENDING SCHEMAS BASED ON USER INPUT,” which issued as U.S. Pat. No. ______ on ______, and which application is expressly incorporated herein by reference in its entirety.
BACKGROUND OF THEINVENTION1. Background and Relevant Art
• Many developers use integrated development environments (IDEs) to create applications. For example, developers and database administrators often use tools such as SQL Server Management Studio and Visual Studio to define database schemas for their data applications.
• Such IDEs facilitate the development of applications by providing a form of auto-complete while the applications are defined. For example, a form of auto-complete known as Intellisense is provided in Visual Studio. Other forms of auto-complete are also provided in other IDEs such as in the NetBeans IDE, or in the IBM Data Studio IDE.
• The auto-complete functionality provided by such IDEs is limited. The suggestions provided are extremely simple and pre-defined. For example, while a developer inputs an object name into an IDE, the auto-complete functionality can recognize the name as being an instance of a specific type of object and generate a pop-up window that displays every method or property defined for an object of that type. For example, if the object is of type “shape” and is named “square,” when the developer inputs “square.”, the auto-complete functionality can provide suggestions of all the possible ways to complete the expression.
• In another example, when defining a database, the developer may type in a name for a column. The auto-complete functionality can identify the input as a definition of a column name and in response display every possible data type to the user that can be used for the data type of a column. For example, the suggested data types may include INT, FLOAT, CHAR, and others.
• Such auto-complete functionality, however, is not intelligent. In other words, the auto-complete functionality can identify input as a column name and provide every possible data type regardless of any characteristics of the column name. For example, even if the column name were “person_name” indicating that the column is intended to contain names of people, the auto-complete functionality would still suggest all possible data types for a column including NT and FLOAT even though it would be very unlikely that a column with a name of “person_name” would contain INTs or FLOATs.
BRIEF SUMMARY
• The present invention extends to methods, systems, and computer program products for intelligently recommending schemas based on user input. An intelligent auto-complete function can identify characteristics of user input and recommend schemas that are most likely to be selected by the user to complete a data structure or portion of a data structure based on the identified characteristics.
• In one embodiment, user input is received at a development tool. The user input defines a portion of a data structure. One or more characteristics of the user input are identified by analyzing the user input. Based at least on the one or more identified characteristics, one or more schemas, out of a plurality of schemas, are recommended to the user. Each recommended schema is predictive of user intent for defining one or more additional portions of the data structure. Graphical data representing each of the one or more recommended schemas is displayed for user selection at the development tool. A user selection is received that selects a schema from among the one or more recommended schemas represented in the displayed graphical data. In response to the user selection of the selected schema, an additional portion of the data structure is defined in accordance with the selected schema.
• In another embodiment, input is received at a development tool. The input defines a name of a column of a database. Based on one or more portions of the name, one or more data types for the data of the column are recommended. The recommendation is based on matching the one or more portions of the name of the column to one or more portions of the name of other columns defined in other schemas. Upon receiving input that selects one of the one or more recommended data types, input is added to the development tool. The input defines the selected data type as the data type for the data of the column.
• This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.
• Additional features and advantages of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by the practice of the invention. The features and advantages of the invention may be realized and obtained by means of the instruments and combinations particularly pointed out in the appended claims. These and other features of the present invention will become more fully apparent from the following description and appended claims, or may be learned by the practice of the invention as set forth hereinafter.
BRIEF DESCRIPTION OF THE DRAWINGS
• In order to describe the manner in which the above-recited and other advantages and features of the invention can be obtained, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:
• FIG. 1 illustrates an example computer architecture that facilitates intelligently recommending schemas based on user input;
• FIGS. 2-5 illustrate examples of a user interface of a development tool for intelligently recommending schemas based on user input;
• FIG. 6 illustrates a flow chart of an example method for recommending schemas to a user during the development of a data structure; and
• FIG. 7 illustrates a flow chart of an example method for suggesting intelligent auto-completion to a user during the development of a data structure.
DETAILED DESCRIPTION
• The present invention extends to methods, systems, and computer program products for intelligently recommending schemas based on user input. An intelligent auto-complete function can identify characteristics of user input and recommend schemas that are most likely to be selected by the user to complete a data structure or portion of a data structure based on the identified characteristics.
• In one embodiment, user input is received at a development tool. The user input defines a portion of a data structure. One or more characteristics of the user input are identified by analyzing the user input. Based at least on the one or more identified characteristics, one or more schemas, out of a plurality of schemas, are recommended to the user. Each recommended schema is predictive of user intent for defining one or more additional portions of the data structure. Graphical data representing each of the one or more recommended schemas is displayed for user selection at the development tool. A user selection is received that selects a schema from among the one or more recommended schemas represented in the displayed graphical data. In response to the user selection of the selected schema, an additional portion of the data structure is defined in accordance with the selected schema.
• In another embodiment, input is received at a development tool. The input defines a name of a column of a database. Based on one or more portions of the name, one or more data types for the data of the column are recommended. The recommendation is based on matching the one or more portions of the name of the column to one or more portions of the name of other columns defined in other schemas. Upon receiving input that selects one of the one or more recommended data types, input is added to the development tool. The input defines the selected data type as the data type for the data of the column.
• Embodiments of the present invention may comprise or utilize a special purpose or general-purpose computer including computer hardware, such as, for example, one or more processors and system memory, as discussed in greater detail below. Embodiments within the scope of the present invention also include physical and other computer-readable media for carrying or storing computer-executable instructions and/or data structures. Such computer-readable media can be any available media that can be accessed by a general purpose or special purpose computer system. Computer-readable media that store computer-executable instructions are computer storage media (devices). Computer-readable media that carry computer-executable instructions are transmission media. Thus, by way of example, and not limitation, embodiments of the invention can comprise at least two distinctly different kinds of computer-readable media: computer storage media (devices) and transmission media.
• Computer storage media (devices) includes RAM, ROM, EEPROM, CD-ROM, solid state drives (“SSDs”) (e.g., based on RAM), Flash memory, phase-change memory (“PCM”), other types of memory, other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer.
• A “network” is defined as one or more data links that enable the transport of electronic data between computer systems and/or modules and/or other electronic devices. When information is transferred or provided over a network or another communications connection (either hardwired, wireless, or a combination of hardwired or wireless) to a computer, the computer properly views the connection as a transmission medium. Transmissions media can include a network and/or data links which can be used to carry desired program code means in the form of computer-executable instructions or data structures and which can be accessed by a general purpose or special purpose computer. Combinations of the above should also be included within the scope of computer-readable media.
• Further, upon reaching various computer system components, program code means in the form of computer-executable instructions or data structures can be transferred automatically from transmission media to computer storage media (devices) (or vice versa). For example, computer-executable instructions or data structures received over a network or data link can be buffered in RAM within a network interface module (e.g., a “NIC”), and then eventually transferred to computer system RAM and/or to less volatile computer storage media (devices) at a computer system. Thus, it should be understood that computer storage media (devices) can be included in computer system components that also (or even primarily) utilize transmission media.
• Computer-executable instructions comprise, for example, instructions and data which, when executed at a processor, cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, or even source code. Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the described features or acts described above. Rather, the described features and acts are disclosed as example forms of implementing the claims.
• Those skilled in the art will appreciate that the invention may be practiced in network computing environments with many types of computer system configurations, including, personal computers, desktop computers, laptop computers, message processors, hand-held devices, multi-processor systems, microprocessor-based or programmable consumer electronics, network PCs, minicomputers, mainframe computers, mobile telephones, PDAs, tablets, pagers, routers, switches, and the like. The invention may also be practiced in distributed system environments where local and remote computer systems, which are linked (either by hardwired data links, wireless data links, or by a combination of hardwired and wireless data links) through a network, both perform tasks. In a distributed system environment, program modules may be located in both local and remote memory storage devices.
• FIG. 1 illustrates anexample computer architecture100 that facilitates intelligently recommending schemas based on user input. Referring toFIG. 1,computer architecture100 includescomputer system101,computer system102, and acloud103 of computer systems.Computer system101 is connected tocomputer system102 and to cloud103 over (or is part of) a network, such as, for example, a Local Area Network (“LAN”), a Wide Area Network (“WAN”), and even the Internet. Accordingly, each of the depicted computer systems as well as any other connected computer systems and their components, can create message related data and exchange message related data (e.g., Internet Protocol (“IP”) datagrams and other higher layer protocols that utilize IP datagrams, such as, Transmission Control Protocol (“TCP”), Hypertext Transfer Protocol (“HTTP”), Simple Mail Transfer Protocol (“SMTP”), etc.) over the network.
• Computer system101 includesdevelopment tool104 for developing data structures. For example,development tool104 can be an IDE such as Microsoft's SQL Server Management Studio or Visual Studio, Java's NetBeans IDE, or IBM's Data Studio IDE.Development tool104 can also be any development tool for defining or manipulating structured data. For example, the aspects of the invention could be applied during the design of a spreadsheet, and thereforedevelopment tool104 can comprise a spreadsheet application such as Microsoft Excel. In short, the present invention extends to any development tool for defining or manipulating any form of structured data.
• Computer system101 includesdisplay101afor displaying user interface104aofdevelopment tool104. A user provides user input to user interface104ato define a data structure such as a database or spreadsheet. As is further described below,computer system101 can access a plurality of schemas in one or more data sources to identify one or more schemas to recommend to the user based on user input. These data sources can be stored locally oncomputer system101, and/or remotely oncomputer system102 or withincloud103. For example,FIG. 1 shows data source105aoncomputer system101,data source105boncomputer system102, anddata source105cwithincloud103. Accordingly, the present invention can be implemented using data sources stored anywhere accessible tocomputer system101.
• FIG. 2 illustrates an example of user interface104a. A user provides input202 to user interface104ato define a portion of adata structure201. For example, ifdata structure201 is a database, the portion defined by input202 can be a column name of a table. Similarly, ifdata structure201 is a spreadsheet, the portion defined by input202 can also be a column name of the spreadsheet. The invention applies to other types of structured data as well. Further, as described below, the invention can use any defined portion of a data structure to identify and recommend schemas.
• After user input202 is received,development tool104 analyzes user input202 to determine one or more characteristics of user input202. Based on this analysis,development tool104 accesses one or more data sources which store schemas. For example,development tool104 can access data source105astored locally oncomputer system101, and/or access one or more remotely stored data sources such asdata source105boncomputer system102 ordata source105cwithincloud103.
• Development tool104 uses the one or more characteristics of user input202 to identify one or more schemas within the one or more data sources that are likely to match the intent of the user. For example, the one or more characteristics can indicate that the user is likely attempting to define a database table, or a column of a database table of a certain type.Development tool104 can then display the identified one or more schemas as recommendedschemas203 within user interface104a.
• The user can then select one or more of recommendedschemas203. Upon selecting a recommended schema,development tool104 automatically completes at least a portion ofdata structure201 based on the selected schema.FIGS. 3-5 describe specific examples of howdevelopment tool104 identifies recommended schemas and automatically completes a portion of a data structure when a recommended schema is selected.
• FIG. 3 illustrates an example of user interface104awhen a user is attempting to define a database table301 withindevelopment tool104. As shown, the user has input “name” as thecolumn name302aofcolumn302 for database table301. The user's actual intention in inputting “name” is to create a column for containing names of persons. As described below, the techniques of the present invention enabledevelopment tool104 to intelligently identify and recommend schemas that are most likely to match this intent.
• Each column of a database table generally must define a data type for the data that the column will contain. Rather than provide a listing of all data types available for columns as is done by traditional auto-complete tools, the present invention bases its recommendations on the context of the previously supplied user input. For example, it may be allowable for any of the data types to be specified as the data type forcolumn302. However,development tool104 can identify recommended schemas to suggest one or more data types that are most likely to be selected by the user based on the context ofcolumn name302a.
• More specifically,development tool104 can identifycolumn name302aas “name” and compare this characteristic ofcolumn name302ato characteristics of a plurality of schemas stored in one or more data sources. This comparison can identify a schema that also includes a column having a name of “name” or a similar variation of this name.Development tool104 can also identify an additional feature of the identified schema such as that each column having a column name of “name” has a defined data type of CHAR.
• Accordingly,development tool104 can provide recommendedschema303 which recommends CHAR for the data type ofcolumn302 while not recommending NT, FLOAT, DATE, or the many other possible data types because it is unlikely that the user would select these data types as evidenced by the characteristics of the identified and recommended schemas. Of course, other schemas having different data types for columns named “name” could be identified and recommended, and therefore recommendedschema303 would include additional recommended schemas such as CHAR(30).
• Upon the user selecting recommendedschema303,development tool104 automatically completes a portion of the definition ofcolumn302 by defining CHAR as the data type ofcolumn302. Although this example is relatively simple, it can be seen that the present invention facilitates data structure definition by providing intelligent recommendations for auto-completion. As is described in more detail below, these recommendations can assist the user by ensuring the user that his design conforms to common design practices or policies used by other users. The recommendations can also assist the user by minimizing the number of options that are presented for auto-completion. Also, althoughFIG. 3 shows recommendedschema303 being a pop-up window within user interface104a, recommended schemas can be displayed to a user in many different ways as is known in the art.
• FIG. 4A illustrates another example of user interface104awhen a user is attempting to define a database table401 for containing credit card numbers. For example, database table401 can correspond to user accounts maintained by an online retail company. As shown, the user has input “visa_credit_card” as thecolumn name402aofcolumn402. As described above with respect toFIG. 3,development tool104 analyzes the user input to extract one or more characteristics. In this example, the characteristics can include the entire string “visa_credit_card,” or can include the individual presence of “visa,” “credit,” and/or “card” in the column name. These characteristics are used to identify one or more schemas that are likely to match the user's intent.
• In this example,development tool104 identifies three recommendedschemas403 that are likely to match the user's intent. For example, each of recommendedschemas403 can contain a column name similar to “visa_credit_card”. Afirst schema403acan define the data type of a column named with a similar name as “visa_credit_card” as CHAR(16). In contrast, asecond schema403bcan define the data type as CHAR(16), NOT NULL. Further, athird schema403ccan define the data type as CHAR(16), NOT NULL with a constraint of CONSTRAINT check_credit_card CHECK (visa_credit_card LIKE ‘4%)’. This constraint indicates that the number of a visa credit card must start with 4.
• Based on these three recommended schemas,development tool104 can display recommendedschemas403 to the user to allow the user to select one of recommendedschemas403 for auto-completion ofcolumn402. For example, if the user were to selectschema403c, the data type ofcolumn402 would be defined as CHAR(16), NOT NULL and the defined constraint would be added tocolumn402.
• As can be seen, the intelligent suggestions provided bydevelopment tool104 not only facilitate auto-completion, but also assist the user to develop better data structures. For example, the user may not know that a visa credit card must start with 4 or that it must be 16 characters long. However, the intelligent suggestion ofschema403cinforms the user of these requirements thus assisting the user to create a data structure that will only accept correctly formatted data.
• Although the above examples describe auto-completion to a column currently being defined, the present invention can provide further recommendations. For example, as shown inFIG. 4B, recommendedschemas403 also include arecommendation403dto add another column to table401 named “security_code”.Development tool104 can determine to recommend this additional column based on the analysis of recommendedschemas403a-403c. Specifically,development tool104 can determine that one or more of recommendedschemas403a-403cin addition to defining a column named similar to “visa_credit_card” also defines a column named “security_code”.
• Recommendation403dof the additional column can be associated with one or more of recommendedschemas403a-403cor can be a separate recommendation. In other words, if the recommendation of the additional column is based on recommendedschema403a, then the additional column can be added if the user selects recommendedschema403a. In contrast, if the recommendation is a separate recommendation as is shown inFIG. 4B, the user can be required to select one of recommendedschemas403a-403cin addition torecommendation403d.
• Although the above examples describe the analysis of a single column name,development tool104 can analyze any number of previously defined columns or other portions of a data structure. For example, referring to the credit card example above, if the column name were “visa” instead of “visa_credit_card”,development tool104 could determine that the column might refer to a government issued visa or a visa credit card. In this scenario,development tool104 can beneficially make use of other portions of a database table to determine the correct intent of the user. For example,development tool104 can determine that the database table also includes columns named “account_number” and “balance” and use these additional characteristics of the defined portion of the database table to determine that the column named “visa” is most likely a column for containing visa credit card numbers.
• Specifically,development tool104 can analyze a plurality of schemas in one or more data sources to identify schemas having columns with similar names as “account_number”, “balance”, and “visa”. Based on the identification of these schemas,development tool104 can recommend one or more schemas to the user for completing the definition of a portion of or the entire database table.
• FIG. 5 illustrates another example of user interface104awhen a user is attempting to define a database for implementing a fantasy football website. As shown, the user has commenced creating the database by defining database table501 withcolumn502 for containing an identifier of a fantasy league that a subscriber belongs to and column503 for containing the team name of the subscriber's team.Column502 is named “fantasy_league”502aand is defined to accept data having a data type ofCHAR502b. Column503 is named “team_name”503aand is defined to accept data of data type CHAR503b.
• Development tool104 can use characteristics of this input, such as the names of each column, to search for recommended schemas in one or more data sources. For example,development tool104 can accessdata source105cincloud103 to analyze a plurality of schemas indata source105c.Development tool104 can identify one or morerecommended schemas504 that include characteristics similar to those of the input provided by the user to define a portion of database table501.
• For example, afirst schema504a, named Schema A, of the identified schemas can define an entire database for storing user accounts for a fantasy football website. The entire database can include various tables. Accordingly,development tool104 can recommendfirst schema504afor auto-completing, not just portions of database table501, but for automatically including one or more additional tables, and any other features of a data structure including any configuration settings, triggers, enrichments to fetch data from remote data sources, visualization controls, or other features to the user's data structure definition.
• For example, as shown,development tool104 has displayedfirst schema504 as a recommendation for auto-completing the input of the user. This recommendation includes the addition of multiple tables (Table_1-Table_N) as well as other data and/or settings. One of the tables withinfirst schema504 can correspond to database table501 (e.g. the table can define one or more additional columns, or a data type or constraint to add to the definition ofcolumn502 or column503). Another of the tables withinfirst schema504acan be defined to store information of players available within a fantasy football league, another table can be defined to store stats of the players, another table can define payment information, such as credit cards or bank account numbers, for each subscriber, while another table can define viewing preferences for each subscriber. Each of these tables can be automatically added to a user's project for defining the database. These automatically created tables can also include the necessary relationships to associate the tables within the database.
• As can be seen, the present invention can provide recommended schemas that when selected auto-complete a small or a large portion of a table or database definition. Also, although the above examples refer to databases and database tables, the same inventive concepts can be applied when a spreadsheet or other structured data is being defined. For example, if a user defines one or more column names for a spreadsheet,development tool104, or a similar development tool, can use the one or more column names to identify and recommend schemas that are most likely to match the user's intent. These recommended schemas, when selected, can add columns to the spreadsheet, add additional sheets, define formulas within particular cells, apply formatting, or any other type of customization that can be made to a spreadsheet.
• For example, if a user has input names for three columns in a spreadsheet,development tool104 can identify that many other users have created spreadsheets with the same three columns in addition to other columns.Development tool104 can then recommend a schema that defines the other columns so that when selected, the other columns are automatically added to the spreadsheet.
• The above description of the invention describesdevelopment tool104 as accessing and analyzing a plurality of schemas to identify schemas to recommend.Development tool104 can function in this manner when the plurality of schemas is generated in advance for use bydevelopment tool104. For example, each of the accessed data sources can be a repository of defined schemas. In contrast, in some embodiments,development tool104 can generate schemas on the fly as described below.
• Pre-defined schemas can be generated in various ways. For example, a schema can be defined directly by administrators of the development platform. Such administrators can examine data structures (such as data structures stored within cloud103 (e.g. database definitions defined using Microsoft SQL Azure)) to determine common definitions used for specific types of data structures and create schemas accordingly. Alternatively, the development platform can provide a way for a community of developers to submit proposed schemas to be included in the plurality of schemas accessed bydevelopment tool104. In this scenario, the development platform can also provide a way for other developers in the community to review and critique the proposed schemas prior to their inclusion.
• In contrast, schemas can be generated automatically by examining many data structures accessible to the development platform. For example, the development platform may have access to data structures that are stored incloud103 or a portion ofcloud103. The development platform can analyze these data structures to identify common characteristics of the data structures and generate schemas based on these common characteristics. The generated schemas can then be included in the data sources for storing schemas. For example, the development platform can determine that many database tables include a column named with some variation of “visa_credit_card” and extract characteristics shared in common by such tables, such as columns that commonly appear in these tables (e.g. “security_code”), data types of columns, or constraints on data of columns.
• In one or more embodiments,development tool104 can also be configured to generate schemas on the fly such as in response to user input todevelopment tool104. For example, when user input is received that defines a column name,development tool104 can access data structures (such as data structures stored in cloud103) and analyze the data structures to determine if any of them also include a column having the same name as the column defined by the user input. Based on this analysis,development tool104 can identify that many data structures having a column with a similar name also define other columns.Development tool104 can then generate a schema that matches the common features of these other data structures, such as the columns that they share in common. This schema can then be displayed to the user.
• Accordingly, schemas used bydevelopment tool104 to make recommendations can be generated at different times, can be generated based on actual data structures, can be directly defined by administrators or a community of developers, or in any other suitable way. Additionally, the schemas and any data structures from which they are generated can be stored in any location. For example, a distributed data source, such as incloud103, can store the plurality of schemas accessed by many instances ofdevelopment tool104 being used in many locations around the world, and a localized data source can store an enterprise's recommended schemas within a LAN of the enterprise. Additionally,development tool104 can access multiple data sources to identify schemas to recommend such as a distributed general data source and an enterprise specific data source.
• Development tool104 can also be used to encourage conformance with various policies or to enforce such policies. For example, an enterprise can define schemas that are to apply to any data structure created by its employees. As an example, an enterprise can define a schema that is recommended anytime a column for storing a credit card number is defined. The recommended schema can require that the column be encrypted.
• Such policy schemas can be applied separately from other recommended schemas. For example, when creating a table for storing visa credit cards,development tool104 can suggest recommendedschemas403a-403cas described above, but can also provide a separate suggestion that a policy schema that recommends encrypting the data be applied to the table as well. Alternatively, policy schemas can be combined with any recommended schemas prior to presenting the recommended schemas to the user so that if the user selects a recommended schema, the policy schema will also be automatically applied.
• Development tool104 can also generate telemetry data for tracking the selection of recommended schemas (or similarly the conformance of a data structure to a recommended schema by examining defined data structures). With regards to enforcing polices,development tool104 can track when an enterprise's recommended schemas are selected (or otherwise conformed to), and when they are not, to monitor whether its employees are following the policy.Development tool104 can also automatically provide a warning to the user if the user chooses not to select an enterprise's recommended schema notifying the user that his data structure does not conform to a required policy.
• Similarly, tracking the selection or use of schemas in this manner enables the enterprise to more easily maintain consistency in its data structures. For example, if the enterprise has a policy that any table for storing credit card numbers in any application must conform to a particular schema,development tool104 can monitor and report whether the policy is being followed.
• The telemetry data can also be used to track which schemas are selected most often as well as which schemas are not selected. This telemetry data can subsequently be used bydevelopment tool104 to identify schemas to recommend.
• For example, if a particular schema is repeatedly ignored by users, the schema can be recommended less frequently, or not at all, even if it has characteristics that match characteristics of a user's input. On the other hand, if a particular schema is regularly selected, the schema can be recommended more frequently. In other words, the telemetry data can be used to improve the development tool's ability to recommend schemas that are most likely to match a user's intent.
• This use of telemetry data can be at an enterprise or at a platform-wide level. For example, an enterprise may desire to track telemetry data regarding its employees' use or selection of particular schemas. Similarly, the platform can generate telemetry data representing the use or selection of schemas by all users of the platform.
• FIG. 6 illustrates a flow chart of anexample method600 for recommending schemas to a user during the development of a data structure.Method600 will be described with respect to the components and data ofcomputer architecture100 as described inFIG. 2.
• Method600 includes anact601 of receiving user input at the development tool, the user input defining a portion of a data structure. For example,development tool104 can receive user input202 which defines a portion ofdata structure201.
• Method600 includes anact602 of identifying one or more characteristics of the user input by analyzing the user input. For example,development tool104 can identify user input202 as a name of a column ofdata structure201.
• Method600 includes anact603 of, based at least on the one or more identified characteristics, recommending one or more schemas, out of a plurality of schemas, to the user, each recommended schema predictive of user intent for defining one or more additional portions of the data structure. For example,development tool104 can determine thatschemas203a-203nmatch the predicted intent of the user and recommend any ofschemas203a-203nto the user.
• Method600 includes anact604 of displaying graphical data representing each of the one or more recommended schemas at the development tool, the graphical data displayed for user selection. For example,development tool104 can display recommendedschemas203 within user interface104a.
• Method600 includes anact605 of receiving a user selection of a selected schema from among the one or more recommended schemas represented in the displayed graphical data. For example,development tool104 can receive a user selection of recommendedschema203adisplayed within user interface104a.
• Method600 includes anact606 of in response to the user selection of the selected schema, defining an additional portion of the data structure in accordance with the selected schema. For example,development tool104 can add input to the definition ofdata structure201 to define a data type for a column, define one or more additional columns, define one or more additional tables, etc.
• FIG. 7 illustrates a flow chart of anexample method700 for suggesting intelligent auto-completion to a user during the development of a data structure.Method700 will be described with respect to the components and data ofcomputer architecture100 as described inFIG. 3.
• Method700 includes anact701 of receiving input at a development tool, the input defining a name of a column of a database. For example,development tool104 can receive user input that defines thename302aof acolumn302.
• Method700 includes anact702 of, based on one or more portions of the name, recommending one or more data types for the data of the column, wherein the recommendation is based on matching the one or more portions of the name of the column to one or more portions of the name of other columns defined in other schemas. For example,development tool104 can recommend CHAR as the data type forcolumn302 based on a comparison to schemas stored indata store105cthat also include a column with the same column name.
• Method700 includes anact703 of upon receiving input that selects one of the one or more recommended data types, adding input to the development tool that defines the selected data type as the data type for the data of the column. For example,development tool104 can receive user input that selects CHAR for the data type, and can automatically add input to the definition ofcolumn302 that defines the data type ofcolumn302 as CHAR.
• The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope.

Claims (20)

What is claimed is:

1. A computing system comprising:

one or more processors; and

one or more storage devices having stored computer-executable instructions which, when executed by the one or more processors, implement a method for recommending schemas to a user during the processing of a data structure, the method comprising:

receiving user input at a computer interface, the user input defining a portion of a data structure;

identifying one or more characteristics of the user input by analyzing the user input;

based at least on the one or more identified characteristics, recommending one or more schemas, out of a plurality of schemas, to the user, at least one recommended schema predictive of user intent for defining one or more additional portions of the data structure;

displaying graphical data representing each of the one or more recommended schemas at the interface, the graphical data displayed for user selection;

receiving a user selection of the at least one recommended schema; and

in response to the user selection of the selected schema, defining an additional portion of the data structure in accordance with the selected schema.

2. The computing system ofclaim 1, wherein the portion of the data structure defined by the input is a name of a column of the data structure.

3. The computing system ofclaim 2, wherein the data structure is one of a database or a spreadsheet.

4. The computing system ofclaim 2, wherein identifying one or more characteristics of the input comprises matching at least a portion of the name of the column to at least a portion of the name of one or more other columns used in the one or more recommended schemas.

5. The computing system ofclaim 1, wherein at least one of the plurality of schemas is stored in a dataset in a cloud of computing systems, the method further comprising accessing the dataset in the cloud of computer systems to analyze the at least one of the plurality of schemas to identify whether to recommend the at least one of the plurality of schemas.

6. The computing system ofclaim 1, wherein the method further comprising:

analyzing one or more characteristics of previous input that define other portions of the data structure; and

wherein recommending one or more schemas comprises recommending the one or more schemas based on one or more characteristics identified from previous user input.

7. The computing system ofclaim 6, wherein the previous user input comprises the name of another column of the data structure.

8. The computing system ofclaim 1, wherein defining the additional portion of the data structure comprises adding a definition of a data type of data that is to be stored within the additional portion of the data structure.

9. The computing system ofclaim 1, wherein defining the additional portion of the data structure comprises adding one or more constraints on data that is to be stored within the additional portion of the data structure.

10. The computing system ofclaim 1, wherein defining the additional portion of the data structure comprises adding input that defines one or more additional columns of the data structure.

11. The computing system ofclaim 1, wherein the method further comprises, prior to recommending the one or more schemas:

analyzing a store of schemas to determine common characteristics of schemas in the store; and

based on the common characteristics, generating the plurality of schemas.

12. The computing system ofclaim 1, wherein the at least one recommended schema is associated with a policy, the method further comprising:

in response to user selection of the selected schema, generating telemetry information that identifies the selected schema from among the one or more recommended schemas including identifying whether the user selected the at least one schema that is associated with the policy; and

using the telemetry information to refine the identification of recommended schemas during the creation of subsequent data structures and to determine whether the policy is being implemented.

13. A computing system comprising:

one or more processors; and

one or more storage devices having stored computer-executable instructions which, when executed by the one or more processors, implement a method for suggesting intelligent auto-completion to a user during the development of a data structure, the method comprising:

receiving input at an interface, the input defining a name of a column of a database;

based on one or more portions of the name, recommending one or more data types for the data of the column, wherein the recommendation is based on matching the one or more portions of the name of the column to one or more portions of the name of other columns defined in one or more schemas; and

upon receiving input that selects one of the one or more recommended data types, adding input to the interface that defines the selected data type as the data type for the data of the column.

14. The computing system ofclaim 13, wherein the method further includes recommending one or more additional columns to be included in the database, the one or more additional columns including a name and a data type.

15. The computing system ofclaim 13, wherein the method further comprises, based on the one or more portions of the name, recommending one or more constraints on data that is to be stored in the column.

16. A computing system comprising:

one or more processors; and

one or more storage devices having stored computer-executable instructions which, when executed by the one or more processors, implements a method for facilitating development of a data structure, the method comprising:

receiving input to an interface, the input defining the name of a column of a database;

comparing at least a portion of the name to names of columns in a plurality of schemas;

identifying one or more schemas, in the plurality of schemas, that each include a column having a name with at least a portion that matches the at least a portion of the name of the column input to the interface;

determining a data type of the data of each of the one or more identified columns;

determining one or more additional columns that are included in each of the one or more schemas; and

displaying information associated with the one or more identified columns.

17. The computing system ofclaim 16, wherein the displaying information associated with the one or more identified columns includes displaying data types of the one or more identified columns as recommended data types for the column of the database.

18. The computing system ofclaim 16, wherein the displaying information associated with the one or more identified columns includes displaying the one or more additional columns as recommended columns to be included in the database.

19. The method ofclaim 16, wherein the database is defined in the interface to include one or more other columns, and wherein identifying one or more schemas in the plurality of schemas that each include a column having a name with at least a portion that matches the at least a portion of the name of the column input to the interface further comprises:

identifying one or more schemas in the plurality of schemas that each include a column having a name with at least a portion that matches the at least a portion of the name of the column input to the interface, and that each include at least one of the one or more additional columns.

20. The method ofclaim 16, further comprising:

displaying the one or more schemas as recommended schemas for the database; and

upon the user selecting one of the one or more schemas, adding input to the interface that defines the database to conform to the selected schema.

Images