Columndescribes properties such as name (key) and type of elements related to that
Column(e.g. the according elements of the
Columninstances, for example describing the elements of a CSV file (visually speaking the of the CSV file's header line), is represented by the
Headerpreserves an order for a list of
Headerprovides the semantics for related
Columninstances is explicitly required (similar to a DB table or a spread sheet, in contrast to a CSV file) then
Columninstances are grouped by a
Rowholds multiple data elements loosely coupled to a
Header. As a
Rowjust contains a list of data elements with no keys (names) directly associated to the elements, a
Headerwith the according list of key (name) and type definitions is required to give a
In terms of a CSV file, a
Row represents a
single line of comma separated values. The
Header stands for the header line (top line) of
the CSV file. The semantics for the content of a
Row is provided by the according
Row instances are contained in a
Rows instance which in turn requires a single
Header to give all the therein contained
Row instances their semantics (in terms of key
(name) and type information).
In contrast to a
Row does not relate a key (name) to its values.
To do this, a
Header is required. Similar to a
Column instances (provided by a
Header instance) to give the fields additional
Rowinstances is represented by a
Rowsinstance. As of efficiency reasons, a
Rowsinstance can be iterated through, returning a single
Rowwithin each iteration. This approach is making it possible to query a DB in the background and just hold the
Rowinstances being served next in the
Rowsinstance (in memory).
The way how
Rows instances manage their related
Row instances is implementation specific, a
plain java implementation might use some kind of collection for storing the
Row instances (this can get memory intensive and
not applicable when working with big data). A DB implementation might
Row instances in blocks one by one,
one after the other, by querying the DB accordingly (in terms of "next"
Fielddata structures with support for
Fieldinstances can be managed with the functionality provided by a
A value can be retrieved from a
providing an according
Column definition, which
verifies the value type. Also values can be converted to and from the
appropriate interchange and string formats by the according
In contrast to a
Record relates the key (name) to its values.
Similar to a
Record makes use of
Column instances (for example as provided by a
Header or a
instance) to give the fields additional semantics.
Recordinstances is represented by a
Recordsinstance. As of efficiency reasons, a
Recordsinstance can be iterated through, returning a single
Recordwithin each iteration. This approach is making it possible to query a DB in the background and just hold the
Recordinstances being served next in the
Recordsinstance (in memory).
The way how
Records instances manage their
Record instances is implementation
specific, a plain java implementation might use some kind of collection for
Record instances (this can get
memory intensive and not applicable when working with big data). A DB
implementation might retrieve the
instances in blocks one by one, one after the other, by querying the DB
accordingly (in terms of "next" result sets).
Copyright © 2015. All rights reserved.