You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 75.101.128.0/17 has been blocked (disabled) by ‪JJMC89‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 05:39, 2 October 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪Jon Kolbert‬. The reason given is Open proxy/Webhost: See the help page if you are affected .
- Start of block: 05:40, 21 February 2024
- Expiry of block: 05:40, 21 February 2029
Your current IP address is 75.101.254.2. The blocked range is 75.101.128.0/17. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((More citations needed|date=September 2021))
((short description|Information block that is part of a database (data row)))
In [[computer science]], a '''record''' (also called a '''structure''',  '''[[struct (C programming language)|struct]]''', or '''compound data''') is a basic [[data structure]]. Records in a [[database]] or [[spreadsheet]] are usually called "[[row (database)|row]]s".<ref>((cite web|title=Computer Science Dictionary Definitions|url=http://www.computingstudents.com/dictionary/?word=Record|website=Computing Students|access-date=Jan 22, 2018))</ref><ref name="Radványi">((cite book |last1=Radványi |first1=Tibor |title=Database Management Systems |date=2014 |publisher=Eszterházy Károly College |page=19 |url=https://www.tankonyvtar.hu/en/tartalom/tamop412A/2011-0038_49_radvanyi_en/index.html |archive-url=https://web.archive.org/web/20180923085530/https://www.tankonyvtar.hu/en/tartalom/tamop412A/2011-0038_49_radvanyi_en/index.html |archive-date=2018-09-23 |access-date=23 September 2018))</ref><ref name="Kahate">((cite book |last1=Kahate |first1=Atul |title=Introduction to Database Management Systems |date=2006 |publisher=Pearson |isbn=978-81-317-0078-5 |page=3 |url=https://books.google.com/books?id=mxYESolfLfoC |access-date=23 September 2018))</ref><ref>((cite book |last1=Connolly |first1=Thomas |title=Database Solutions: A Step by Step Guide to Building Databases |url=https://archive.org/details/databasesolution00conn_535 |url-access=registration |date=2004 |publisher=Pearson |isbn=978-0-321-17350-8 |page=[https://archive.org/details/databasesolution00conn_535/page/n19 7] |edition=2nd ))</ref>

A record is a collection of ''[[Field (computer science)|fields]]'', possibly of different data types, typically in a fixed number and sequence.<ref>((cite book |last1=Felleisen |first1=Matthias |title=How To Design Programs |url=https://archive.org/details/howtodesignprogr00fell_231 |url-access=registration |date=2001 |publisher=MIT Press |isbn=978-0262062183 |pages=[https://archive.org/details/howtodesignprogr00fell_231/page/n528 53], 60 ))</ref> The fields of a record may also be called ''members'', particularly in [[object-oriented programming]]; fields may also be called ''elements'', though this risks confusion with the elements of a [[Collection (abstract data type)|collection]].

For example, a date could be stored as a record containing a [[Number|numeric]] <var>year</var> field, a <var>month</var> field represented as a string, and a numeric <var>day-of-month</var> field. A personnel record might contain a <var>name</var>, a <var>salary</var>, and a <var>rank</var>. A Circle record might contain a <var>center</var> and a <var>radius</var>—in this instance, the center itself might be represented as a <var>point</var> record containing <var>x</var> and <var>y</var> coordinates.

Records are distinguished from [[Array data type|arrays]] by the fact that their number of fields is determined in the definition of the record, and by the fact the records are a heterogenous data type; not all of the fields must contain the same type of data.<ref>((Cite journal |last1=Pape |first1=Tobias |last2=Kirilichev |first2=Vasily |last3=Bolz |first3=Carl Friedrich |last4=Hirschfeld |first4=Robert |date=2017-01-13 |title=Record data structures in racket: usage analysis and optimization |url=https://dl.acm.org/doi/10.1145/3040575.3040578 |journal=ACM SIGAPP Applied Computing Review |language=en |volume=16 |issue=4 |pages=25–37 |doi=10.1145/3040575.3040578 |s2cid=14306162 |issn=1559-6915))</ref>

A ''record type'' is a [[data type]] that describes such values and variables. Most modern computer languages allow the programmer to define new record types. The definition includes specifying the data type of each field and an [[identifier]] (name or label) by which it can be accessed.  In [[type theory]], [[product type]]s (with no field names) are generally preferred due to their simplicity, but proper record types are studied in languages such as [[System F-sub]].  Since type-theoretical records may contain [[first-class function]]-typed fields in addition to data, they can express many features of [[object-oriented programming]].

Records can exist in any storage medium, including [[main memory]] and [[mass storage devices]] such as [[magnetic tape]]s or [[hard disk]]s.  Records are a fundamental component of most data structures, especially [[linked data structure]]s.  Many [[computer file]]s are organized as arrays of [[storage record|logical record]]s, often grouped into larger physical records or [[block (data storage)|blocks]] for efficiency.

The parameters of a [[subroutine|function or procedure]] can often be viewed as the fields of a record variable; and the arguments passed to that function can be viewed as a record value that gets [[Assignment (computer science)|assigned]] to that variable at the time of the call. Also, in the [[call stack]] that is often used to implement procedure calls, each entry is an ''activation record'' or ''call frame'', containing the procedure parameters and local variables, the return address, and other internal fields.

An object in [[object-oriented]] language is essentially a record that contains procedures specialized to handle that record; and object types are an elaboration of record types. Indeed, in most object-oriented languages, records are just special cases of objects, and are known as [[plain old data structure]]s (PODSs), to contrast with objects that use OO features.

A record can be viewed as the computer analog of a [[mathematics|mathematical]] [[tuple]], although a [[tuple]] may or may not be considered a record, and vice versa, depending on conventions and the specific programming language.  In the same vein, a record type can be viewed as the computer language analog of the [[Cartesian product]] of two or more [[set (mathematics)|mathematical sets]], or the implementation of an abstract [[product type]] in a specific language.

==Keys==

A record may have zero or more ''key''s. A key maps an expression to a value, or a set of values, in the record. A primary key is unique throughout all stored records; only one of this key exists.<ref>((Cite web |title=Add or change a table's primary key in Access |url=https://support.microsoft.com/en-us/office/add-or-change-a-table-s-primary-key-in-access-07b4a84b-0063-4d56-8b00-65f2975e4379?ui=en-us&rs=en-us&ad=us |access-date=2022-03-01 |website=support.microsoft.com))</ref> In other words, no duplicate may exist for any primary key. For example an employee file might contain employee number, name, department, and salary. The employee number will be unique in the organization and would be the primary key. Depending on the storage medium and file organization the employee number might be ''[[Indexed file|indexed]]''—that is also stored in a separate file to make lookup faster. The department code is not necessarily unique; it may also be indexed, in which case it would be considered a ''secondary key'', or ''alternate key''.<ref>((Cite web |title=Alternate key - Oracle FAQ |url=http://www.orafaq.com/wiki/Alternate_key |access-date=2022-03-01 |website=www.orafaq.com))</ref> If it is not indexed the entire employee file would have to be scanned to produce a listing of all employees in a specific department. Keys are usually chosen in a way that minimizes the chances of multiple values being feasibly mapped to by one key. For example, the salary field would not normally be considered usable as a key since many employees will likely have the same salary. Indexing is one factor considered when designing a file.

==History==

[[File:1880 census Edison.gif|thumb|upright|Journal sheet from [[1880 United States Census]], showing tabular data with rows of data, each a record corresponding to a single person.]]
The concept of a record can be traced to various types of [[Table (information)|table]]s and [[ledger]]s used in [[accounting]] since remote times.  The modern notion of records in computer science, with fields of well-defined type and size, was already implicit in 19th century mechanical calculators, such as [[Charles Babbage|Babbage]]'s [[Analytical Engine]].<ref>((cite journal |last1=Bromley |first1=Allan |title=Charles Babbage's Analytical Engine, 1838 |journal=IEEE Annals of the History of Computing |date=October 1998 |volume=20 |issue=4 |pages=29–45 |doi=10.1109/85.728228 |s2cid=2285332 |url=https://dl.acm.org/citation.cfm?id=612744 |access-date=23 September 2018))</ref><ref>((cite web |last1=Swade |first1=Doron |title=Automatic Computation: Charles Babbage and Computational Method |url=http://www.rutherfordjournal.org/article030106.html |website=The Rutherford Journal |access-date=23 September 2018))</ref>

[[File:Hollerith Punched Card.jpg|thumb|Hollerith [[punched card]] (1895)]]
The original machine-readable medium used for data (as opposed to control) was [[punch card]] used for records in the [[1890 United States Census]]: each punch card was a single record. Compare the journal entry from 1880 and the punch card from 1895. Records were well-established in the first half of the 20th century, when most data processing was done using punched cards. Typically each record of a data file would be recorded in one punched card, with specific columns assigned to specific fields. Generally, a record was the smallest unit that could be read in from external storage (e.g. card reader, tape or disk). The contents of punchcard-style records were originally called "unit records" because since punchcards had pre-determined document lengths.<ref name=":0">((Cite book |title=Encyclopedia of computer science |date=2003 |publisher=Wiley |editor=Edwin D. Reilly |editor2=Anthony Ralston |editor3=David Hemmendinger |isbn=978-1-84972-160-8 |edition=4th |location=Chichester, UK |oclc=436846454))</ref> When storage systems became more advanced with the use of [[Hard disk drive|hard drives]] and [[magnetic tape]], variable-length records became the standard. A variable-length record is a record in which the size of the record in bytes is approximately equal to the sum of the sizes of its fields. This was not possible to do before more advanced storage hardware was invented because all of the punchcards had to conform to pre-determined document lengths that the computer could read, since at the time the cards had to be physically fed into a machine. 

Most [[machine language]] implementations and early [[assembly language]]s did not have special syntax for records, but the concept was available (and extensively used) through the use of [[index register]]s, [[indirect addressing]], and [[self-modifying code]]. Some early computers, such as the [[IBM 1620]], had hardware support for delimiting records and fields, and special instructions for copying such records.

The concept of records and fields was central in some early file [[sorting]] and [[tabulation|tabulating]] utilities, such as [[IBM RPG|IBM's Report Program Generator (RPG)]].

<!--- link from COBOL article -->
((Visible anchor|[[COBOL]])) was the first widespread programming language to support record types,<ref>((cite book |last1=Sebesta |first1=Robert W. |title=Concepts of Programming Languages |year=1996 |publisher=Addison-Wesley Publishing Company, Inc. |isbn=0-8053-7133-8 |page=[https://archive.org/details/conceptsofprogra00sebe/page/218 218] |edition=Third |url-access=registration |url=https://archive.org/details/conceptsofprogra00sebe/page/218 ))</ref> and its record definition facilities were quite sophisticated at the time. The language allows for the definition of nested records with alphanumeric, integer, and fractional fields of arbitrary size and precision, as well as fields that automatically format any value assigned to them (e.g., insertion of currency signs, decimal points, and digit group separators). Each file is associated with a record variable where data is read into or written from. COBOL also provides a <code>MOVE</code> <code>CORRESPONDING</code> statement that assigns corresponding fields of two records according to their names.

The early languages developed for numeric computing, such as [[FORTRAN]] (up to [[FORTRAN IV]]) and [[Algol 60]], did not have support for record types; but later versions of those languages, such as [[FORTRAN 77]] and [[Algol 68]] did add them. The original [[Lisp programming language]] too was lacking records (except for the built-in [[cons cell]]), but its [[S-expression]]s provided an adequate surrogate.<!--What about Common Lisp?--> The [[Pascal programming language]] was one of the first languages to fully integrate record types with other basic types into a logically consistent type system.<!-- not sure, Algol 68 or C may have come first?--> The [[PL/I]] programming language provided for COBOL-style records. The [[C (programming language)|C]] programming language initially provided the record concept as a kind of template (<code>[[struct (C programming language)|struct]]</code>) that could be laid on top of a memory area, rather than a true record data type.  The latter were provided eventually (by the <code>[[typedef]]</code> declaration), but the two concepts are still distinct in the language. Most languages designed after Pascal (such as [[Ada (programming language)|Ada]], [[Modula]], and [[Java programming language|Java]]), also supported records.

Although records are not often used in their original context anymore (i.e. being used solely for the purpose of containing data), records influenced  newer [[Object-oriented programming|object oriented programming]] languages and [[Relational database|relational database management systems]]. Since records provided more modularity in the way data was stored and handled, they are better suited at representing complex, real-world concepts than the [[Primitive data type|primitive data types]] provided by default in languages. This influenced later languages such as [[C++]], [[Python (programming language)|Python]], [[JavaScript]], and [[Objective-C]] which address the same modularity concerns of programmers.<ref>((Cite book |last1=Leavens |first1=Gary T. |last2=Weihl |first2=William E. |title=Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications - OOPSLA/ECOOP '90 |chapter=Reasoning about object-oriented programs that use subtypes |date=1990 |chapter-url=http://dx.doi.org/10.1145/97945.97970 |pages=212–223 |location=New York, New York, USA |publisher=ACM Press |doi=10.1145/97945.97970|isbn=0-201-52430-9 |s2cid=46526 |url=https://lib.dr.iastate.edu/cs_techreports/92 ))</ref> [[Object (computer science)|Objects]] in these languages are essentially records with the addition of [[Method (computer programming)|methods]] and [[Inheritance (object-oriented programming)|inheritance]], which allow programmers to manipulate the way data behaves instead of only the contents of a record. Many programmers regard records as obsolete now since object-oriented languages have features that far surpass what records are capable of. On the other hand, many programmers argue that the low overhead and ability to use records in [[assembly language]] make records still relevant when programming with low levels of [[Abstraction (computer science)|abstraction]]. Today, the most popular languages on the [[TIOBE index|TIOBE]] index, an indicator of the popularity of programming languages, have been influenced in some way by records due to the fact that they are object oriented.<ref>((Cite web |title=index ((!)) TIOBE - The Software Quality Company |url=https://www.tiobe.com/tiobe-index/ |access-date=2022-03-01 |website=www.tiobe.com))</ref> Query languages such as [[SQL]] and [[Object Query Language]] were also influenced by the concept of records. These languages allow the programmer to store sets of data, which are essentially records, in tables.<ref>((Cite web |title=What is a Relational Database (RDBMS)? |url=https://www.oracle.com/database/what-is-a-relational-database/ |access-date=February 28, 2022 |website=Oracle))</ref> This data can then be retrieved using a [[Unique key|primary key]]. The tables themselves are also records which may have a [[foreign key]]: a key that references data in another table.   

==Operations==

* Declaration of a new record type, including the position, type, and (possibly) name of each field;
* Declaration of variables and values as having a given record type;
* Construction of a record value from given field values and (sometimes) with given field names;
* Selection of a field of a record with an explicit name;
* Assignment of a record value to a record variable;
* Comparison of two records for equality;
* Computation of a standard [[hash function|hash value]] for the record.

The selection of a field from a record value yields a value.

Some languages may provide facilities that enumerate all fields of a record, or at least the fields that are references. This facility is needed to implement certain services such as [[debugger]]s, [[garbage collection (computing)|garbage collectors]], and [[serialization]]. It requires some degree of [[type polymorphism]].

In systems with record subtyping, operations on values of record type may also include:
* Adding a new field to a record, setting the value of the new field.
* Removing a field from a record.
In such settings, a specific record type implies that a specific set of fields are present, but values of that type may contain additional fields. A record with fields ''x'', ''y'', and ''z'' would thus belong to the type of records with fields ''x'' and ''y'', as would a record with fields ''x'', ''y'', and ''r''. The rationale is that passing an (''x'',''y'',''z'') record to a function that expects an (''x'',''y'') record as argument should work, since that function will find all the fields it requires within the record. Many ways of practically implementing records in programming languages would have trouble with allowing such variability, but the matter is a central characteristic of record types in more theoretical contexts.

===Assignment and comparison===
Most languages allow assignment between records that have exactly the same record type (including same field types and names, in the same order). Depending on the language, however, two record data types defined separately may be regarded as distinct types even if they have exactly the same fields.

Some languages may also allow assignment between records whose fields have different names, matching each field value with the corresponding field variable by their positions within the record; so that, for example, a [[complex data type|complex number]] with fields called <code>real</code> and <code>imag</code> can be assigned to a [[Cartesian coordinates|2D point]] record variable with fields <code>X</code> and <code>Y</code>.  In this alternative, the two operands are still required to have the same sequence of field types.  Some languages may also require that corresponding types have the same size and encoding as well, so that the whole record can be assigned as an uninterpreted [[bit string]].  Other languages may be more flexible in this regard, and require only that each value field can be legally assigned to the corresponding variable field; so that, for example, a [[short integer]] field can be assigned to a [[long integer]] field, or vice versa.

Other languages (such as [[COBOL]]) may match fields and values by their names, rather than positions.

These same possibilities apply to the comparison of two record values for equality.  Some languages may also allow order comparisons ('&lt;'and '&gt;'), using the [[lexicographic order]] based on the comparison of individual fields.((Citation needed|date=May 2009))

[[PL/I]] allows both of the preceding types of assignment, and also allows ''structure expressions'', such as <code>a = a+1;</code> where "a" is a record, or structure in PL/I terminology.

===Algol 68's distributive field selection===
In Algol 68, if <code>Pts</code> was an array of records, each with integer fields <code>X</code> and <code>Y</code>, one could write <code>Y '''of''' Pts</code> to obtain an array of integers, consisting of the <code>Y</code> fields of all the elements of <code>Pts</code>.  As a result, the statements <code>Y '''of''' Pts[3] := 7</code> and <code>(Y '''of''' Pts)[3] := 7</code> would have the same effect.

===Pascal's "with" statement===
In the [[Pascal programming language]], the command <code>with R do S</code> would execute the command sequence <code>S</code> as if all the fields of record <code>R</code> had been declared as variables. Similarly to entering a different [[namespace]] in an object-oriented language like [[C Sharp (programming language)|C#]], it is no longer necessary to use the record name as a prefix to access the fields. So, instead of writing <code>Pt.X := 5; Pt.Y := Pt.X + 3</code> one could write ((code|2=pascal|1=with Pt do begin X := 5; Y := X + 3 end)).

==Representation in memory==
The representation of records in memory varies depending on the programming languages. Usually the fields are stored in consecutive positions in memory, in the same order as they are declared in the record type. This may result in two or more fields stored into the same word of memory; indeed, this feature is often used in [[systems programming]] to access specific bits of a word. On the other hand, most compilers will add padding fields, mostly invisible to the programmer, in order to comply with alignment constraints imposed by the machine—say, that a [[floating point]] field must occupy a single word.

Some languages may implement a record as an array of addresses pointing to the fields (and, possibly, to their names and/or types). Objects in object-oriented languages are often implemented in rather complicated ways, especially in languages that allow [[class inheritance|multiple class inheritance]].

==Self-defining records==
A ''self-defining record'' is a type of record which contains information to identify the record type and to locate information within the record.  It may contain the offsets of elements; the elements can therefore be stored in any order or may be omitted.<ref>((cite web |last1=Kraimer |first1=Martin R. |title=EPICS Input / Output Controller (IOC) Application Developer's Guide |url=http://www.aps.anl.gov/epics/EpicsDocumentation/AppDevManuals/AppDevGuide/3.12BookFiles/AppDevGuide.book.html |website=Argonne National Laboratory |access-date=November 25, 2015 ))</ref> The information stored in a self-defining record can be interpreted as [[metadata]] for the record, which is similar to what one would expect to find in the [[Unix|UNIX]] [[metadata]] regarding a file, containing information such as the record's creation time and the size of the record in [[Byte|bytes]]. Alternatively, various elements of the record, each including an element identifier, can simply follow one another in any order.

==See also==
<!--These articles collectively need a cleanup and re-partition of their contents:-->
* [[Block (data storage)]]
* [[Composite data type]]
* [[Data hierarchy]]
* [[Object composition]]
* [[Passive data structure]]
* [[Union type]]

==References==
((Reflist))

((Data types))

((DEFAULTSORT:Record (Computer Science)))
[[Category:Data types]]
[[Category:Composite data types]]
[[Category:Articles with example Julia code]]

Pages transcluded onto the current version of this page (help):

Record (computer science) (edit)
Template:Ambox (view source) (template editor protected)
Template:Category handler (view source) (protected)
Template:Citation needed (view source) (protected)
Template:Cite book (view source) (protected)
Template:Cite journal (view source) (protected)
Template:Cite web (view source) (protected)
Template:Code (view source) (template editor protected)
Template:Data types (edit)
Template:Delink (view source) (protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Fix (view source) (protected)
Template:Fix/category (view source) (protected)
Template:Hlist/styles.css (view source) (protected)
Template:Main other (view source) (protected)
Template:More citations needed (view source) (template editor protected)
Template:Navbox (view source) (template editor protected)
Template:Pagetype (view source) (protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:SDcat (view source) (protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Template:Visible anchor (view source) (template editor protected)
Template:Visible anchor/styles.css (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Delink (view source) (protected)
Module:Disambiguation/templates (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (protected)
Module:Pagetype/setindex (view source) (protected)
Module:Pagetype/softredirect (view source) (protected)
Module:SDcat (view source) (protected)
Module:String (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Wikitext Parsing (view source) (protected)
Module:Yesno (view source) (protected)

Return to Record (computer science).

Retrieved from "https://en.wikipedia.org/wiki/Record_(computer_science)"