EP3262532A1 - Data type management - Google Patents
Data type managementInfo
- Publication number
- EP3262532A1 EP3262532A1 EP15910962.8A EP15910962A EP3262532A1 EP 3262532 A1 EP3262532 A1 EP 3262532A1 EP 15910962 A EP15910962 A EP 15910962A EP 3262532 A1 EP3262532 A1 EP 3262532A1
- Authority
- EP
- European Patent Office
- Prior art keywords
- data
- type
- data set
- identifier
- data type
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Ceased
Links
- 230000015654 memory Effects 0.000 claims abstract description 52
- 238000000034 method Methods 0.000 claims abstract description 48
- 238000013507 mapping Methods 0.000 claims description 2
- 239000002131 composite material Substances 0.000 description 7
- 238000010586 diagram Methods 0.000 description 6
- 238000012545 processing Methods 0.000 description 5
- 230000009471 action Effects 0.000 description 2
- 238000004891 communication Methods 0.000 description 2
- 230000006870 function Effects 0.000 description 2
- 230000014509 gene expression Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 238000004458 analytical method Methods 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 239000000470 constituent Substances 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000003780 insertion Methods 0.000 description 1
- 230000037431 insertion Effects 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/10—Address translation
- G06F12/1009—Address translation using page tables, e.g. page table structures
- G06F12/1018—Address translation using page tables, e.g. page table structures involving hashing techniques, e.g. inverted page tables
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/43—Checking; Contextual analysis
- G06F8/436—Semantic checking
- G06F8/437—Type checking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
- G06F3/0614—Improving the reliability of storage systems
- G06F3/0619—Improving the reliability of storage systems in relation to data integrity, e.g. data losses, bit errors
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0646—Horizontal data movement in storage systems, i.e. moving data in between storage devices or systems
- G06F3/0647—Migration mechanisms
- G06F3/0649—Lifecycle management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0646—Horizontal data movement in storage systems, i.e. moving data in between storage devices or systems
- G06F3/065—Replication mechanisms
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0668—Interfaces specially adapted for storage systems adopting a particular infrastructure
- G06F3/0671—In-line storage system
- G06F3/0673—Single storage device
- G06F3/0679—Non-volatile semiconductor memory device, e.g. flash memory, one time programmable memory [OTP]
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/40—Specific encoding of data in memory or cache
- G06F2212/401—Compressed data
Definitions
- Data processing includes generating data, storing data in memories and accessing stored data by a user or by an application. Accessing data may relate to reading data or modifying data. Various kinds of data may be used in data processing, and the kind of data is identified by a data type.
- FIG. 1 is a block diagram of an example system for data type management
- FIG. 2 is a flowchart of an example method for data type management
- FIG. 3 is a flowchart of an example method for determining compatibility between data types
- FIG. 4 is a block diagram of an example system for data type management
- FIG. 5 is a block diagram of an example system for data type management.
- Programs may have different lifecycies or lifetimes. For example, programs may have to deal with data that has been accumulated over long time periods. The programs (and corresponding data) may have been created at different times, by different teams of people using different names and/or structural forms for data types. This results in an inconsistent development of the data types for large long-lived datasets and for programs manipulating that data.
- Computer systems with structured data that is held persistently such as computer systems with massive non-volatile memories may utilize self-describing structured data to deal with this issue.
- the types and component types of structured data may be identified through hashes, such as compositional hashes. This hash information may be kept with the data through the use of a type table.
- An example method for data type management may include adding a first data to a first data set.
- the first data set may belong to a plurality of data sets stored in a memory and each data set in the plurality may correspond to a type table defining data types in the corresponding data set.
- the method may further include determining that a first data type of the first data is not in a first type table corresponding to the first data set and generating an identifier corresponding to the first data type.
- the identifier may identify uses of the first data type within each data set in the plurality and may be a standardized value that is used by each data set in the plurality.
- the method may also include inserting the identifier into the first type table.
- FIG. 1 is a block diagram of an example system 100 for data type management.
- System 100 may include a processor 102 and a memory 104 that may be coupled to each other through a communication link (e.g., a bus).
- Processor 02 may include a Central Processing Unit (CPU) or another suitable processor.
- memory 104 stores machine readable instructions executed by processor 102 for operating system 100.
- Memory 104 may include any suitable combination of volatile and/or non-volatile memory, such as combinations of Random Access Memory (RAM), Read-Only Memory (ROM), flash memory, and/or other suitable memory.
- Memory 104 may also include a random access non-volatile memory that can retain content when the power is off.
- Memory 104 stores instructions to be executed by processor 102 including instructions for a data set adder 110, a data type determiner 112, an identifier generator 114, a table inserter 116, a reachability handler 118, a user access handier 120, a reliability factor handier 122, a data mover 124, a compatibility handler 126, a cacher 128 and/or other components.
- data type management system 100 may be implemented in hardware and/or a combination of hardware and programming that configures hardware.
- FIG. 1 and other Figures described herein different numbers of components or entities than depicted may be used.
- Processor 02 may execute instructions of data set adder 1 10 to add a first data to a first data set.
- a data set such as the first data set, may comprise a collection of data (including the first data) that may be related through ownership or structure. Adding the first data to the first data set may include creating a record for the first data and/or copying the first data to a memory corresponding to the first data set.
- the first data set may belong to a plurality of data sets stored in a memory.
- the memory may be a volatile memory, a non- volatile memory, etc.
- the memory may also be distributed among a plurality of computer systems.
- the plurality of computer systems may be part of a duster of computer systems.
- Each data set in the plurality of data sets may correspond to a type table.
- a type table is data structure that defines data types in the corresponding data set.
- a data type is a description of a meaning and/or a layout of data.
- the data type may include a definition of the structure of the data.
- a data type may be represented by a type constructor and/or by a constructor argument associated with the type constructor.
- the type constructor of a data type may indicate the kind of the data type, e.g. set, list, record, union, and/or other data type.
- a type constructor for a "list” may comprise an array of fields comprising the same data type.
- the constructor argument of a data type may indicate a primitive data type or a composite data type that represents the field of the data type.
- a data type may be represented by the type constructor and by the arguments where the type is composite.
- a data type may comprise a type constructor for a "record" that may be associated with a constructor argument indicating a primitive data type and/or a composite data type.
- An example structural data type may look something like what is shown in Table 1 below.
- the example structural data type of table 1 introduces the structural data type person and may be used in programs to give a type to variables such as person: p1 , p2, p3,
- Data types may comprise a primitive data type or a composite data type.
- Primitive data types are atomic and may not have any fields.
- a primitive data type may have specific atomic constituents.
- Example primitive data types include integers, characters and enumerated types.
- An example enumerated type that is a primitive data type is a Boolean having certain named values (e.g. TRUE, FALSE etc.). .
- An example primitive data type may look something like what is shown in Table 2 below. Table 2:
- the example primitive data type of table 2 one field called "count" whose type is int.
- the primitive data type does not have any field.
- a composite data type may comprise a data type that comprises at least one field.
- a structured data type comprising one field may be called a singleton data type. Examples of a composite data type may be union, list, record, and/or other data types that comprise at least one field,
- a data type may comprise a type constructor and at least one constructor argument associated with the type constructor.
- Type constructors may be associated with collection types. Collection types (such as sets, lists, arrays, strings) may possess some way of adding, selecting and indexing entries.
- List(int) is a constructed type that may describe a list of integers
- the type constructor is "List” and its single argument is "Inf.
- Another example constructed type is Set(List(lnt)) that may describe a set of lists of integers.
- the type constructor is "Set” and the argument type is the structural composite type "List(lnt)" denoting a list of integers.
- the constructor argument may comprise a first constructor argument and a second constructor argument associated with the type constructor of a data type.
- the type constructor, the first constructor argument and the second constructor argument may represent the data type.
- a first predetermined code value may represent the first constructor argument and a second predetermined code value may represent the second constructor argument.
- the hardware processor may generate an identifier using the type constructor, the first predetermined code value and the second predetermined code value.
- Processor 102 may execute instructions of data type determiner 112 to determine whether a first data type of the first data is in a first type table corresponding to the first data set. Each data type may be represented by an identifier. The identifier may comprise a name, and/or other type of identifier. Data type determiner 112 may determine the identifier representing the first data type of the first data and determine if the determined identifier is in the first type table. Data type determiner 112 may determine that the first data type is in the first type table and take no further action. Data type determiner 112 may determine that the first data type is not in the first type table and pass the first data type to identifier generator 1 4.
- Processor 102 may execute instructions of identifier generator 114 to generate an identifier that identifies uses of the first data type within each data set in the plurality.
- the identifier may correspond to the first data type.
- the identifier may be consistent between each data set in the plurality.
- the identifier may be a standardized value that is used by each data set in the plurality.
- data types may comprise different type constructors and constructor arguments. Hashing the first data type may result in a first identifier.
- One type of hashing that may be used is compositional hashing.
- Compositional hashing is a form of structural hashing that preserves type in-equivalence.
- Identifier generator 114 may generate an identifier corresponding to the first data type using respective type constructors and predetermined code values.
- a standard set of identifiers may be used by the data sets in the plurality of data sets, such that the identifiers (i.e. a data type code value) remain consistent as the data is transferred, copied, moved, etc. from data set to data set (as will be discussed in further detail below in reference to data mover 124).
- Processor 102 may execute instructions of table inserter 116 to insert the identifier into the first type table.
- the identifier may be linked to the first data type.
- Table inserter 18 may store the identifier in the type table.
- Table inserter 1 16 may arrange the identifiers in the type table so as to obtain a canonical description of data types used.
- Processor 102 may execute instructions of reachability handier 118 to determine that a first data type is reachable and mark an identifier corresponding to the first data type as a reachable data type. Reachability handler 18 may further remove an unmarked data type from the first type table. Reachability handler 118 may perform at least one of these actions during garbage collection.
- Garbage collection is a process performed by a garbage collector to distinguish between data objects that are reachable and those that are unreachable, where an object is reachable if it is possible for any program code to make reference to the object.
- the garbage collector declares the space they occupy to be unallocated and returns the memory to an allocator for use in allocating new objects.
- An allocator manages unused space in memory and provides memory to programs for creating objects.
- Processor 102 may execute instructions of user access handler 120 to determine a first data set is protected from a user and prevent the user from accessing a first type table corresponding to the first data set.
- certain data may be accessible by certain users of a computer system.
- User access handler 120 may determine the permissions of a first data set in regards to a particular user and prevent the user from accessing the type table corresponding to the first data set. For example, user access handier 120 may make the type table corresponding to the first data set invisible to a user that does not have permission to access the first data set.
- Processor 102 may execute instructions of reliability factor handler 122 to store a first type table based on a first reliability factor corresponding to a first data set.
- Each data set in the plurality of data sets stored in the memory (e.g. as discussed in reference to data set adder 1 10) may have a reliability factor.
- the reliability factor may define requirements for storing data from the corresponding data set. For example, data with a high reliability factor may be stored in a certain critical area of memory or stored redundantly in multiple locations on the memory, whereas data with a low reliability factor may be stored in a single location in memory.
- Processor 102 may execute instructions of data mover 124 to move a first data to a second data set.
- the second data set may belong to a plurality of data sets (e.g. as discussed in reference to data set adder 1 10).
- Data mover 124 may determine that a first data type of the first data is not in a second type table corresponding to the second data set and insert an identifier into a second type table (e.g. as discussed in reference to identifier generator 114).
- Type-checking structural types may be computationally expensive, especially for larger structural types.
- type-check expressions can be performed by comparing the type hashes, such as the compositional type hashes, associated with each value.
- types that are related but not identical, such as in sub-type hierarchies may not be comparable in this way since two types may be compatible but may not be equivalent and thus not have the same hash.
- Data types that are compatible are interoperable with each other without any alteration. Although two data types may be different, they still may compatible. For example, data types may have super-types, sub-types, etc.
- an integer may be considered as a sub-type of a float and a record containing an integer may be considered as a sub-type of a similar record containing a float in the same field.
- a record containing an integer may be considered as a sub-type of a similar record containing a float in the same field.
- this is only a simple example and the compatibility may be applied to more complex types such as function, record, union, etc.
- An identifier (e.g. as discussed in reference to identifier generator 114) may be paired with a relationship label that provides information about relationships without having to inspect the type structures.
- the relationship label may at least one bit.
- the information can either be a general indication that such relationships can exist, or can be divided into different type of relationship - such as "may have super-types", “may have sub-types", “may have both”, etc.
- the handle may also include an arity of user- specified type constructors (i.e. type operators). In general, the arity of a function or operation symbol is the number of arguments needed to correctly form an acceptable expression.
- the relationship label may indicate a compatibility between a first data type and a second data type.
- the assembly of the identifier and the relationship label may be referred to as a "handle.” If a first identifier corresponding to a first data of a first data type does not match a second identifier corresponding to a second data of a second data type, a first relationship label corresponding to the first data may be compared to a second relationship label corresponding to the second data.
- Processor 102 may execute instructions of compatibility handler 126 to determine a potential compatibility between the first data type and the second data type based on the relationship label. If the compatibility handler 126 determines that the relationship labels of the first data and the second data do not match in the types being compared when they have different hashes, then the comparison may be considered as failed and that the first data and second data are not considered to be compatible.
- compatibility handler 126 may perform a detailed comparison of the first and/or second data types (i.e. the first and the second data types). For example, compatibility handier 126 may determine the structure of the data type, such as what types of constructor arguments and/or other parameters are associated with the type constructor of the data type. Compatibility handier 126 may also determine if the data type has any related data types. Processor 102 may execute instructions of cacher 128 to cache a result of the detailed comparison. The result may be cached in the type table. The relationships indicated by the result may be replicated, copied, moved and garbage collected along with the underlying types. A result indicating a relationship and a result indicating the lack of a relationship may be cached.
- Well known common relationships between data types may be pre- populated into a type table. For example, certain relationships may be included in a type table by default. An example pre-population is to add an integer variant of any data type that uses a float, and the appropriate relationship (be that sub-type or super- type). Relationships between built in types may also be included in the type table. Built in types are data types that are provided by a programming language.
- FIG. 2 is a flowchart of an example method 200 for data type management.
- Method 200 may be described below as being executed or performed by a system, for example, system 100 of FIG. 1 , system 400 of FIG. 4 or system 500 of FIG. 5. Other suitable systems and/or computing devices may be used as well.
- Method 200 may be implemented in the form of executable instructions stored on at least one machine- readable storage medium of the system and executed by at least one processor of the system.
- the machine-readable storage medium may be non-transitory.
- Method 200 may be implemented in the form of electronic circuitry (e.g., hardware). At least one block of method 200 may be executed substantially concurrently or in a different order than shown in FIG. 2.
- Method 200 may include more or less blocks than are shown in FIG. 2. Some of the blocks of method 200 may, at certain times, be ongoing and/or may repeat,
- Method 200 may start at block 202 and continue to block 204, where the method may include adding a first data to a first data set.
- the first data set may belong to a plurality of data sets stored in a memory.
- the memory may be a non-volatile memory.
- the memory may be distributed among a plurality of computer systems.
- Each data set in the plurality may correspond to a type table defining data types in the corresponding data set.
- the method may include determining that a first data type of the first data is not in a first type table corresponding to the first data set.
- the method may include generating an identifier that identifies uses of the first data type within each data set in the plurality. The identifier may correspond to the first data type.
- the identifier may be a standardized value that is used by each data set in the plurality.
- the identifier may be consistent between each data set in the plurality.
- the identifier may also include a hash value and the first type table may include a mapping between the hash value and the first data type.
- the identifier may include a relationship label indicating a compatibility between the first data type and a second data type.
- the method may include inserting the identifier into the first type table linked to the first data type. Method 200 may eventually continue to block 212, where method 200 may stop.
- FIG. 3 is a flowchart of an example method 300 for determining compatibility between data types.
- Method 300 may be described below as being executed or performed by a system, for example, system 100 of FIG. 1 , system 400 of FIG. 4 or system 500 of FIG. 5. Other suitable systems and/or computing devices may be used as well.
- Method 300 may be implemented in the form of executable instructions stored on at least one machine-readable storage medium of the system and executed by at least one processor of the system.
- the machine-readable storage medium may be non- transitory.
- Method 300 may be implemented in the form of electronic circuitry (e.g., hardware). At least one block of method 300 may be executed substantially concurrently or in a different order than shown in FIG. 3.
- Method 300 may include more or less blocks than are shown in FIG. 3. Some of the blocks of method 300 may, at certain times, be ongoing and/or may repeat.
- Method 300 may start at block 302 and continue to block 304, where the method may include determining a potential compatibility between a first data type and a second data type. The determination may be made based on a relationship label. The relationship label may indicate a compatibility between a first data type and a second data type.
- the method may include performing a detailed comparison between the first data type and the second data type. The detailed comparison may include an analysis of the structure of the first and second data type to determine if the first and second data types are compatible.
- the method may include caching a result of the detailed comparison. The result may be cached and/or otherwise stored with a type table. Method 300 may eventually continue to block 310, where method 300 may stop.
- FIG. 4 is a block diagram of an example system 400 for data type management.
- System 400 may include a processor 402 and a memory 404 that may be coupled to each other through a communication link (e.g., a bus).
- Processor 402 may include a Central Processing Unit (CPU) or another suitable processor.
- memory 404 stores machine readable instructions executed by processor 402 for operating system 400.
- Memory 404 may include any suitable combination of volatile and/or non-volatile memory, such as combinations of Random Access Memory (RAM), Read-Only Memory (ROM), flash memory, and/or other suitable memory.
- RAM Random Access Memory
- ROM Read-Only Memory
- flash memory and/or other suitable memory.
- Memory 404 stores instructions to be executed by processor 402 including instructions for a data identifier 408, a data handier 410, an identifier generator 412 and table inserter 414.
- the components of system 400 may be implemented in the form of executable instructions stored on at least one machine-readable storage medium of system 400 and executed by at least one processor of system 400.
- the machine- readable storage medium may be non-transitory.
- Each of the components of system 400 may be implemented in the form of at least one hardware device including electronic circuitry for implementing the functionality of the component.
- Processor 402 may execute instructions of data identifier 408 to identify a plurality of data sets stored on a memory. Each data set in the plurality may include a type table defining data types in the corresponding data set.
- the memory may be a non-volatile memory. The memory may be distributed among a plurality of computer systems.
- Processor 402 may execute instructions of data handler 410 to determine that a first data in a first data set belongs to the plurality.
- the first data may be of a first data type.
- Processor 402 may execute instructions of identifier generator 412 to generate an identifier that identifies uses of the first data type within each data set in the plurality.
- the identifier may correspond to the first data type.
- the identifier may be a standardized value that is used by each data set in the plurality.
- the identifier may be consistent between each data set in the plurality.
- the identifier may also include a hash value.
- the identifier may include a relationship label indicating a compatibility between the first data type and a second data type.
- Processor 402 may execute instructions of table inserter 414 to insert the identifier into a first type table corresponding to the first data set The identifier may be linked to the first data type.
- FIG. 5 is a block diagram of an example system 500 for data type management.
- System 500 may be similar to system 100 of FIG. 1 , for example.
- system 500 includes a processor 502 and a machine- readable storage medium 504.
- the following descriptions refer to a single processor and a single machine-readable storage medium, the descriptions may also apply to a system with multiple processors and multiple machine-readable storage mediums, in such examples, the instructions may be distributed (e.g., stored) across multiple machine-readable storage mediums and the instructions may be distributed (e.g., executed by) across multiple processors.
- Processor 502 may be at least one central processing unit (CPU), microprocessor, and/or other hardware devices suitable for retrieval and execution of instructions stored in machine-readable storage medium 504.
- processor 502 may fetch, decode, and execute instructions 506, 508, 510, 512 and 514 to perform data type management.
- Processor 502 may include at least one electronic circuit comprising a number of electronic components for performing the functionality of at least one of the instructions in machine-readable storage medium 504.
- executable instruction representations e.g., boxes
- executable instructions and/or electronic circuits included within one box may be included in a different box shown in the figures or in a different box not shown.
- Machine-readable storage medium 504 may be any electronic, magnetic, optical, or other physical storage device that stores executable instructions.
- machine-readable storage medium 504 may be, for example, Random Access Memory (RAM), an Electrically-Erasable Programmable Read-Only Memory (EEPROM), a storage drive, an optical disc, and the like.
- Machine-readable storage medium 504 may be disposed within system 500, as shown in FIG. 5. In this situation, the executable instructions may be "installed" on the system 500.
- Machine-readable storage medium 504 may be a portable, external or remote storage medium, for example, that allows system 500 to download the instructions from the portable/external/remote storage medium, in this situation, the executable instructions may be part of an "installation package".
- machine-readable storage medium 504 may be encoded with executable instructions for test session similarity determination.
- the machine-readable storage medium may be non-transitory.
- data add instructions 506 when executed by a processor (e.g., 502), may cause system 500 to add a first data to a first data set.
- the first data set may belong to a plurality of data sets stored in a memory.
- the memory may be a non-volatile memory.
- the memory may be distributed among a plurality of computer systems. Each data set in the plurality may correspond to a type fable defining data types in the corresponding data set.
- Data type determine instructions 508 when executed by a processor (e.g., 502), may cause system 500 to determine that a first data type of the first data is not in a first type table corresponding to the first data set.
- Hash value generate instructions 510 when executed by a processor (e.g., 502), may cause system 500 to generate a hash value that identifies uses of the first data type within each data set in the plurality.
- the hash value may correspond to the first data type.
- the hash value may be consistent between each data set in the plurality.
- the hash value may be a standardized value that is used by each data set in the plurality.
- the hash value may be paired with a relationship label indicating a compatibility between the first data type and a second data type.
- Table insert instructions 512 when executed by a processor (e.g., 502), may cause system 500 to insert the hash value into the first type table.
- Hash value map instructions 514 when executed by a processor (e.g., 502), may cause system 500 to map the hash value to the first data type in the first type table.
- the foregoing disclosure describes a number of examples for data type management.
- the disclosed examples may include systems, devices, computer- readable storage media, and methods for data type management.
- certain examples are described with reference to the components illustrated in FIGS. 1-5.
- the functionality of the illustrated components may overlap, however, and may be present in a fewer or greater number of elements and components. Further, all or part of the functionality of illustrated elements may co-exist or be distributed among several geographically dispersed locations. Further, the disclosed examples may be implemented in various environments and are not limited to the illustrated examples.
Abstract
Description
Claims
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
PCT/US2015/066758 WO2017105501A1 (en) | 2015-12-18 | 2015-12-18 | Data type management |
Publications (2)
Publication Number | Publication Date |
---|---|
EP3262532A1 true EP3262532A1 (en) | 2018-01-03 |
EP3262532A4 EP3262532A4 (en) | 2018-07-18 |
Family
ID=59057400
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
EP15910962.8A Ceased EP3262532A4 (en) | 2015-12-18 | 2015-12-18 | Data type management |
Country Status (4)
Country | Link |
---|---|
US (1) | US20180150405A1 (en) |
EP (1) | EP3262532A4 (en) |
CN (1) | CN107533546A (en) |
WO (1) | WO2017105501A1 (en) |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN108874873B (en) * | 2018-04-26 | 2022-04-12 | 北京空间科技信息研究所 | Data query method, device, storage medium and processor |
CN110711389B (en) * | 2019-09-29 | 2023-03-07 | 上海莉莉丝科技股份有限公司 | Data processing method, device, equipment and computer readable medium |
Family Cites Families (19)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5555409A (en) * | 1990-12-04 | 1996-09-10 | Applied Technical Sysytem, Inc. | Data management systems and methods including creation of composite views of data |
JP2927180B2 (en) * | 1994-06-22 | 1999-07-28 | 株式会社日立製作所 | Debugging method of information processing program and debugger therefor |
US6398105B2 (en) * | 1999-01-29 | 2002-06-04 | Intermec Ip Corporation | Automatic data collection device that intelligently switches data based on data type |
US6989820B1 (en) * | 1999-03-19 | 2006-01-24 | Avaya Technology Corp. | Automated administration system for state-based control of a terminal user interface |
US9218409B2 (en) * | 2002-06-04 | 2015-12-22 | Sap Se | Method for generating and using a reusable custom-defined nestable compound data type as database qualifiers |
US7143251B1 (en) * | 2003-06-30 | 2006-11-28 | Data Domain, Inc. | Data storage using identifiers |
US7350198B2 (en) * | 2003-09-09 | 2008-03-25 | Sap Aktiengesellschaft | Creating and checking runtime data types |
US8126900B1 (en) * | 2004-02-03 | 2012-02-28 | Teradata Us, Inc. | Transforming a data type of a column in a table |
EP1839172A2 (en) * | 2004-12-08 | 2007-10-03 | B-Obvious Ltd. | Bidirectional data transfer optimization and content control for networks |
US8126870B2 (en) * | 2005-03-28 | 2012-02-28 | Sybase, Inc. | System and methodology for parallel query optimization using semantic-based partitioning |
US20090327921A1 (en) * | 2008-06-27 | 2009-12-31 | Microsoft Corporation | Animation to visualize changes and interrelationships |
CN102063479A (en) * | 2010-12-22 | 2011-05-18 | 北京中电普华信息技术有限公司 | Method and system for controlling data access right |
US9165048B2 (en) * | 2012-05-16 | 2015-10-20 | Sap Se | Linked field table for databases |
US9378226B1 (en) * | 2012-10-10 | 2016-06-28 | Google Inc. | Method and system for a user-defined field type |
GB2513329A (en) * | 2013-04-23 | 2014-10-29 | Ibm | Method and system for scoring data in a database |
AU2015225694B2 (en) * | 2014-03-07 | 2019-06-27 | Ab Initio Technology Llc | Managing data profiling operations related to data type |
US10061834B1 (en) * | 2014-10-31 | 2018-08-28 | Amazon Technologies, Inc. | Incremental out-of-place updates for datasets in data stores |
US9817858B2 (en) * | 2014-12-10 | 2017-11-14 | Sap Se | Generating hash values |
US9430358B1 (en) * | 2015-06-23 | 2016-08-30 | Ca, Inc. | Debugging using program state definitions |
-
2015
- 2015-12-18 CN CN201580079044.0A patent/CN107533546A/en active Pending
- 2015-12-18 US US15/577,846 patent/US20180150405A1/en not_active Abandoned
- 2015-12-18 WO PCT/US2015/066758 patent/WO2017105501A1/en active Application Filing
- 2015-12-18 EP EP15910962.8A patent/EP3262532A4/en not_active Ceased
Also Published As
Publication number | Publication date |
---|---|
US20180150405A1 (en) | 2018-05-31 |
CN107533546A (en) | 2018-01-02 |
WO2017105501A1 (en) | 2017-06-22 |
EP3262532A4 (en) | 2018-07-18 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9851918B2 (en) | Copy-on-write by origin host in virtual machine live migration | |
CN107066498B (en) | Key value KV storage method and device | |
CN114154190A (en) | Managing sensitive production data | |
US20200167140A1 (en) | Automatic reference counting | |
JP6111441B2 (en) | Tracking application usage in computing environments | |
US20170351606A1 (en) | Persistent memory garbage collection | |
CN109661652A (en) | Use the abnormality detection of system call sequence | |
CN106528071A (en) | Selection method and device for target code | |
US10108402B2 (en) | Persistent pointers for programs running on NVRAM based computers | |
CN111414228B (en) | Method and related device for managing storage space based on Kubernetes | |
US20150052321A1 (en) | Minimally disruptive virtual machine snapshots | |
US20130318398A1 (en) | Method and system for leveraging page fault and page reclaim capabilities in debugging | |
US8359592B2 (en) | Identifying groups and subgroups | |
US20180150405A1 (en) | Data type management | |
CN107533614B (en) | Device for storing data and storage medium | |
CN107463638A (en) | File sharing method and equipment between offline virtual machine | |
CN104778087A (en) | Information processing method and information processing device | |
CN114416530A (en) | Byte code modification method and device, computer equipment and storage medium | |
US20110246542A1 (en) | System for lightweight objects | |
US20170286195A1 (en) | Information object system | |
CN112148746A (en) | Method and device for generating database table structure document, electronic device and storage medium | |
JP2015523633A (en) | How to delete information | |
CN104424238B (en) | A kind of method, apparatus that mass file generates | |
CN104794035A (en) | Memory test method and device based on RHEL7.0 | |
US20080162068A1 (en) | Evaluation of Access Control and Filter Conditions |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE INTERNATIONAL PUBLICATION HAS BEEN MADE |
|
PUAI | Public reference made under article 153(3) epc to a published international application that has entered the european phase |
Free format text: ORIGINAL CODE: 0009012 |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE |
|
17P | Request for examination filed |
Effective date: 20170925 |
|
AK | Designated contracting states |
Kind code of ref document: A1 Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR |
|
AX | Request for extension of the european patent |
Extension state: BA ME |
|
RIC1 | Information provided on ipc code assigned before grant |
Ipc: G06F 17/30 20060101ALI20180312BHEP Ipc: G06F 8/41 20180101AFI20180312BHEP |
|
A4 | Supplementary search report drawn up and despatched |
Effective date: 20180620 |
|
RIC1 | Information provided on ipc code assigned before grant |
Ipc: G06F 12/1018 20160101ALI20180614BHEP Ipc: G06F 17/30 20060101ALI20180614BHEP Ipc: G06F 8/41 20180101AFI20180614BHEP Ipc: G06F 3/06 20060101ALI20180614BHEP |
|
DAV | Request for validation of the european patent (deleted) | ||
DAX | Request for extension of the european patent (deleted) | ||
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: EXAMINATION IS IN PROGRESS |
|
17Q | First examination report despatched |
Effective date: 20190619 |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: EXAMINATION IS IN PROGRESS |
|
REG | Reference to a national code |
Ref country code: DE Ref legal event code: R003 |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE APPLICATION HAS BEEN REFUSED |
|
18R | Application refused |
Effective date: 20210814 |