;;; /home/ellis/comp/core/lisp/lib/dat/parquet/thrift.lisp --- Parquet Thrift Definitions -*- buffer-read-only:t -*-

 ;; input = /home/ellis/comp/core/.stash/parquet.json

 ;; This file was generated automatically by

 ;; DAT/PARQUET/GEN:PARSE-PARQUET-THRIFT-DEFINITIONS

 ;; Do not modify.

 ;;; Code:

 (in-package :dat/parquet)

           ((unencoded-byte-array-data-bytes :documentation

             "The number of physical bytes stored for BYTE_ARRAY data values assuming

 no encoding. This is exclusive of the bytes needed to store the length of

 each byte array. In other words, this field is equivalent to the `(size

 of PLAIN-ENCODING the byte array values) - (4 bytes * number of values

 written)`. To determine unencoded sizes of other types readers can use

 schema information multiplied by the number of non-null and null values.

 The number of null\\non-null values can be inferred from the histograms

 below.

 For example, if a column chunk is dictionary-encoded with dictionary

 [\\a\\, \\bc\\, \\cde\\], and a data page contains the indices [0, 0, 1, 2],

 then this value for that data page should be 7 (1 + 1 + 2 + 3).

 This field should only be set for types that use BYTE_ARRAY as their

 physical type.

 "

             :initarg :unencoded-byte-array-data-bytes :initform nil :type

             (or null (signed-byte 64)))

            (repetition-level-histogram :documentation

             "When present, there is expected to be one element corresponding to each

 repetition (i.e. size=max repetition_level+1) where each element

 represents the number of times the repetition level was observed in the

 data.

 This field may be omitted if max_repetition_level is 0 without loss

 of information.

 "

             :initarg :repetition-level-histogram :initform nil :type

             (or null (vector (signed-byte 64))))

            (definition-level-histogram :documentation

             "Same as repetition_level_histogram except for definition levels.

 This field may be omitted if max_definition_level is 0 or 1 without

 loss of information.

 "

             :initarg :definition-level-histogram :initform nil :type

             (or null (vector (signed-byte 64)))))

           (:documentation

            "A structure for capturing metadata for estimating the unencoded,

 uncompressed size of data written. This is useful for readers to estimate

 how much memory is needed to reconstruct data in their memory model and for

 fine grained filter pushdown on nested structures (the histograms contained

 in this structure can help determine the number of nulls at a particular

 nesting level and maximum length of lists).

 "))

           ((max :documentation

                 "DEPRECATED: min and max value of the column. Use min_value and max_value.

 Values are encoded using PLAIN encoding, except that variable-length byte

 arrays do not include a length prefix.

 These fields encode min and max values determined by signed comparison

 only. New files should use the correct order for a column's logical type

 and store the values in the min_value and max_value fields.

 To support older readers, these may be set when the column order is

 signed.

 "

                 :initarg :max :initform nil :type (or null octet-vector))

            (min :initarg :min :initform nil :type (or null octet-vector))

            (null-count :documentation "count of null value in the column

 "

             :initarg :null-count :initform nil :type

             (or null (signed-byte 64)))

            (distinct-count :documentation "count of distinct values occurring

 "

             :initarg :distinct-count :initform nil :type

             (or null (signed-byte 64)))

            (max-value :documentation

             "Lower and upper bound values for the column, determined by its ColumnOrder.

 These may be the actual minimum and maximum values found on a page or column

 chunk, but can also be (more compact) values that do not exist on a page or

 column chunk. For example, instead of storing \\Blart Versenwald III\\, a writer

 may set min_value=\\B\\, max_value=\\C\\. Such more compact values must still be

 valid values within the column's logical type.

 Values are encoded using PLAIN encoding, except that variable-length byte

 arrays do not include a length prefix.

 "

             :initarg :max-value :initform nil :type (or null octet-vector))

            (min-value :initarg :min-value :initform nil :type

             (or null octet-vector))

            (is-max-value-exact :documentation

             "If true, max_value is the actual maximum value for a column

 "

             :initarg :is-max-value-exact :initform nil :type (or null boolean))

            (is-min-value-exact :documentation

             "If true, min_value is the actual minimum value for a column

 "

             :initarg :is-min-value-exact :initform nil :type

             (or null boolean)))

           (:documentation "Statistics per row group and per page

 All fields are optional.

 "))

           (:documentation "Empty structs to use as logical type annotations

 "))

           (:documentation

            "Logical type to annotate a column that is always null.

 Sometimes when discovering the schema of existing data, values are always

 null and the physical type can't be determined. This annotation signals

 the case where the physical type was guessed from all null values.

 "))

           ((scale :initarg :scale :type (signed-byte 32))

            (precision :initarg :precision :type (signed-byte 32)))

           (:documentation "Decimal logical type annotation

 Scale must be zero or a positive integer less than or equal to the precision.

 Precision must be a non-zero positive integer.

 To maintain forward-compatibility in v1, implementations using this logical

 type must also set scale and precision on the annotated SchemaElement.

 Allowed for physical types: INT32, INT64, FIXED_LEN_BYTE_ARRAY, and BYTE_ARRAY.

 "))

           (:documentation "Time units for logical types

 "))

           ((millis :initarg :millis :initform nil :type

             (or null parquet-milli-seconds))

            (micros :initarg :micros :initform nil :type

             (or null parquet-micro-seconds))

            (nanos :initarg :nanos :initform nil :type

             (or null parquet-nano-seconds))))

           ((isadjustedtoutc :initarg :isadjustedtoutc :type boolean)

            (unit :initarg :unit :type parquet-time-unit))

           (:documentation "Timestamp logical type annotation

 Allowed for physical types: INT64

 "))

           ((isadjustedtoutc :initarg :isadjustedtoutc :type boolean)

            (unit :initarg :unit :type parquet-time-unit))

           (:documentation "Time logical type annotation

 Allowed for physical types: INT32 (millis), INT64 (micros, nanos)

 "))

           ((bitwidth :initarg :bitwidth)

            (issigned :initarg :issigned :type boolean))

           (:documentation "Integer logical type annotation

 bitWidth must be 8, 16, 32, or 64.

 Allowed for physical types: INT32, INT64

 "))

           (:documentation "Embedded JSON logical type annotation

 Allowed for physical types: BYTE_ARRAY

 "))

           (:documentation "Embedded BSON logical type annotation

 Allowed for physical types: BYTE_ARRAY

 "))

           ((string :initarg :string :initform nil :type

                    (or null parquet-string-type))

            (map :initarg :map :initform nil :type (or null parquet-map-type))

            (list :initarg :list :initform nil :type

                  (or null parquet-list-type))

            (enum :initarg :enum :initform nil :type

             (or null parquet-enum-type))

            (decimal :initarg :decimal :initform nil :type

             (or null parquet-decimal-type))

            (date :initarg :date :initform nil :type

             (or null parquet-date-type))

            (time

             :initarg

             :time

             :initform

             nil

             :type

             (or null parquet-time-type))

            (timestamp :initarg :timestamp :initform nil :type

             (or null parquet-timestamp-type))

            (integer :initarg :integer :initform nil :type

             (or null parquet-int-type))

            (unknown :initarg :unknown :initform nil :type

             (or null parquet-null-type))

            (json :initarg :json :initform nil :type

             (or null parquet-json-type))

            (bson :initarg :bson :initform nil :type

             (or null parquet-bson-type))

            (uuid :initarg :uuid :initform nil :type

             (or null parquet-uuid-type))

            (float16 :initarg :float16 :initform nil :type

             (or null parquet-float16-type)))

           (:documentation "LogicalType annotations to replace ConvertedType.

 To maintain compatibility, implementations using LogicalType for a

 SchemaElement must also set the corresponding ConvertedType (if any)

 from the following table.

 "))

           ((type :documentation

             "Data type for this field. Not set if the current element is a non-leaf node

 "

             :initarg :type :initform nil :type (or null parquet-type))

            (type-length :documentation

             "If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values.

 Otherwise, if specified, this is the maximum bit length to store any of the values.

 (e.g. a low cardinality INT col could have this set to 3).  Note that this is

 in the schema, and therefore fixed for the entire file.

 "

             :initarg :type-length :initform nil :type

             (or null (signed-byte 32)))

            (repetition-type :documentation

             "repetition of the field. The root of the schema does not have a repetition_type.

 All other nodes must have one

 "

             :initarg :repetition-type :initform nil :type

             (or null parquet-field-repetition-type))

            (name :documentation "Name of the field in the schema

 "

             :initarg :name :type string)

            (num-children :documentation

             "Nested fields.  Since thrift does not support nested fields,

 the nesting is flattened to a single list by a depth-first traversal.

 The children count is used to construct the nested relationship.

 This field is not set when the element is a primitive type

 "

             :initarg :num-children :initform nil :type

             (or null (signed-byte 32)))

            (converted-type :documentation

             "DEPRECATED: When the schema is the result of a conversion from another model.

 Used to record the original type to help with cross conversion.

 This is superseded by logicalType.

 "

             :initarg :converted-type :initform nil :type

             (or null parquet-converted-type))

            (scale :documentation

             "DEPRECATED: Used when this column contains decimal data.

 See the DECIMAL converted type for more details.

 This is superseded by using the DecimalType annotation in logicalType.

 "

             :initarg :scale :initform nil :type (or null (signed-byte 32)))

            (precision :initarg :precision :initform nil :type

             (or null (signed-byte 32)))

            (field-id :documentation

             "When the original schema supports field ids, this will save the

 original field id in the parquet schema

 "

             :initarg :field-id :initform nil :type (or null (signed-byte 32)))

            (logicaltype :documentation "The logical type of this SchemaElement

 LogicalType replaces ConvertedType, but ConvertedType is still required

 for some logical types to ensure forward-compatibility in format v1.

 "

             :initarg :logicaltype :initform nil :type

             (or null parquet-logical-type)))

           (:documentation "Represents a element inside a schema definition.

  - if it is a group (inner node) then type is undefined and num_children is defined

  - if it is a primitive type (leaf) then type is defined and num_children is undefined

 the nodes are listed in depth first traversal order.

 "))

           ((num-values :documentation

             "Number of values, including NULLs, in this data page.

 If a OffsetIndex is present, a page must begin at a row

 boundary (repetition_level = 0). Otherwise, pages may begin

 within a row (repetition_level > 0).

 "

             :initarg :num-values :type (signed-byte 32))

            (encoding :documentation "Encoding used for this data page *

 "

             :initarg :encoding :type parquet-encoding)

            (definition-level-encoding :documentation

             "Encoding used for definition levels *

 "

             :initarg :definition-level-encoding :type parquet-encoding)

            (repetition-level-encoding :documentation

             "Encoding used for repetition levels *

 "

             :initarg :repetition-level-encoding :type parquet-encoding)

            (statistics :documentation

             "Optional statistics for the data in this page *

 "

             :initarg :statistics :initform nil :type

             (or null parquet-statistics)))

           (:documentation "Data page header

 "))

           ((num-values :documentation "Number of values in the dictionary *

 "

             :initarg :num-values :type (signed-byte 32))

            (encoding :documentation "Encoding using this dictionary page *

 "

             :initarg :encoding :type parquet-encoding)

            (is-sorted :documentation

             "If true, the entries in the dictionary are sorted in ascending order *

 "

             :initarg :is-sorted :initform nil :type (or null boolean)))

           (:documentation

            "The dictionary page must be placed at the first position of the column chunk

 if it is partly or completely dictionary encoded. At most one dictionary page

 can be placed in a column chunk.

 "))

           ((num-values :documentation

             "Number of values, including NULLs, in this data page. *

 "

             :initarg :num-values :type (signed-byte 32))

            (num-nulls :documentation "Number of NULL values, in this data page.

 Number of non-null = num_values - num_nulls which is also the number of values in the data section *

 "

             :initarg :num-nulls :type (signed-byte 32))

            (num-rows :documentation

             "Number of rows in this data page. Every page must begin at a

 row boundary (repetition_level = 0): rows must **not** be

 split across page boundaries when using V2 data pages.

 "

             :initarg :num-rows :type (signed-byte 32))

            (encoding :documentation "Encoding used for data in this page *

 "

             :initarg :encoding :type parquet-encoding)

            (definition-levels-byte-length :documentation

             "Length of the definition levels

 "

             :initarg :definition-levels-byte-length :type (signed-byte 32))

            (repetition-levels-byte-length :documentation

             "Length of the repetition levels

 "

             :initarg :repetition-levels-byte-length :type (signed-byte 32))

            (is-compressed :documentation "Whether the values are compressed.

 Which means the section of the page between

 definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included)

 is compressed with the compression_codec.

 If missing it is considered compressed

 "

             :initarg :is-compressed :initform nil :type (or null boolean))

            (statistics :documentation

             "Optional statistics for the data in this page *

 "

             :initarg :statistics :initform nil :type

             (or null parquet-statistics)))

           (:documentation