View Source Adbc.Column (adbc v0.6.2)

Documentation for Adbc.Column.

Adbc.Column corresponds to a column in the table. It contains the column's name, type, and data. The data is a list of values of the column's data type.

Summary

Functions

A column that contains binary values.

A column that contains booleans.

A column that contains date represented as 32-bit signed integers in UTC.

A column that contains date represented as 64-bit signed integers in UTC.

A column that contains 128-bit decimals.

A column that contains 256-bit decimals.

Construct an array using dictionary encoding.

A column that contains durations represented as 64-bit signed integers.

A column that contains 16-bit half-precision floats.

A column that contains 32-bit single-precision floats.

A column that contains 64-bit double-precision floats.

A column that contains fixed size binaries.

Similar to list/2, but the length of the list is the same.

A column that contains durations represented as signed integers.

A column that contains large binary values.

Similar to list/2, but for large lists.

A column that contains UTF-8 encoded large strings.

A column that each row is a list of some type or nil.

materialize/1 converts a column's data from reference type to regular Elixir terms.

A column that contains signed 8-bit integers.

A column that contains signed 16-bit integers.

A column that contains 32-bit signed integers.

A column that contains 64-bit signed integers.

A column that contains UTF-8 encoded strings.

A column that contains time represented as signed integers in UTC.

A column that contains timestamps represented as signed integers in the given timezone.

Convert a list view, run-end encoding array or a dictionary to a list.

A column that contains unsigned 8-bit integers.

A column that contains unsigned 16-bit integers.

A column that contains un32-bit signed integers.

A column that contains un64-bit signed integers.

Types

@type data_type() ::
  :boolean
  | signed_integer()
  | unsigned_integer()
  | floating()
  | :list
  | :large_list
  | :list_view
  | :large_list_view
  | {:fixed_size_list, s32()}
  | :binary
  | :large_binary
  | :string
  | :large_string
  | decimal_t()
  | {:fixed_size_binary, non_neg_integer()}
  | :struct
  | :date32
  | :date64
  | time_t()
  | timestamp_t()
  | duration_t()
  | interval_t()
  | :run_end_encoded
  | :dictionary
@type decimal128() :: {:decimal, 128, precision128(), integer()}
@type decimal256() :: {:decimal, 256, precision256(), integer()}
@type decimal_t() :: decimal128() | decimal256()
@type dictionary_data_t() :: %{
  key: %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  },
  value: %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }
}
@type duration_t() ::
  {:duration, :seconds}
  | {:duration, :milliseconds}
  | {:duration, :microseconds}
  | {:duration, :nanoseconds}
@type floating() :: :f32 | :f64
@type interval_day_time() :: {s32(), s32()}
@type interval_month() :: s32()
Link to this type

interval_month_day_nano()

View Source
@type interval_month_day_nano() :: {s32(), s32(), s64()}
@type interval_t() ::
  {:interval, :month} | {:interval, :day_time} | {:interval, :month_day_nano}
@type interval_unit() :: :month | :day_time | :month_day_nano
@type list_view_data_t() :: %{
  validity: [boolean()],
  offsets: [non_neg_integer()],
  sizes: [non_neg_integer()],
  values: %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }
}
@type precision128() :: 1..38
@type precision256() :: 1..76
@type s8() :: -128..127
@type s16() :: -32768..32767
@type s32() :: -2_147_483_648..2_147_483_647
@type s64() :: -9_223_372_036_854_775_808..9_223_372_036_854_775_807
@type signed_integer() :: :s8 | :s16 | :s32 | :s64
@type time32_t() :: {:time32, :seconds} | {:time32, :milliseconds}
@type time64_t() :: {:time64, :microseconds} | {:time64, :nanoseconds}
@type time_t() :: time32_t() | time64_t()
@type time_unit() :: :seconds | :milliseconds | :microseconds | :nanoseconds
@type timestamp_t() ::
  {:timestamp, :seconds, String.t()}
  | {:timestamp, :milliseconds, String.t()}
  | {:timestamp, :microseconds, String.t()}
  | {:timestamp, :nanoseconds, String.t()}
@type u8() :: 0..255
@type u16() :: 0..65535
@type u32() :: 0..4_294_967_295
@type u64() :: 0..18_446_744_073_709_551_615
@type unsigned_integer() :: :u8 | :u16 | :u32 | :u64

Functions

Link to this function

binary(data, opts \\ [])

View Source
@spec binary([iodata() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains binary values.

Arguments

  • data: A list of binary values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.binary([<<0>>, <<1>>, <<2>>])
%Adbc.Column{
  name: nil,
  type: :binary,
  nullable: false,
  metadata: nil,
  data: [<<0>>, <<1>>, <<2>>]
}
Link to this function

boolean(data, opts \\ [])

View Source
@spec boolean([boolean()], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains booleans.

Arguments

  • data: A list of booleans
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.boolean([true, false, true])
%Adbc.Column{
  name: nil,
  type: :boolean,
  nullable: false,
  metadata: nil,
  data: [true, false, true]
}
Link to this function

column(type, data, opts \\ [])

View Source
@spec column(
  data_type(),
  list() | list_view_data_t() | dictionary_data_t(),
  Keyword.t()
) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }
Link to this function

date32(data, opts \\ [])

View Source
@spec date32([Date.t() | s32() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains date represented as 32-bit signed integers in UTC.

Arguments

  • data: a list, each element of which can be one of the following:
    • a Date.t()
    • a 32-bit signed integer representing the number of days since the Unix epoch.
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

date64(data, opts \\ [])

View Source
@spec date64([Date.t() | s64() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains date represented as 64-bit signed integers in UTC.

Arguments

  • data: a list, each element of which can be one of the following:
    • a Date.t()
    • a 64-bit signed integer representing the number of milliseconds since the Unix epoch.
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

decimal128(data, precision, scale, opts \\ [])

View Source
@spec decimal128(
  [Decimal.t() | integer() | nil],
  precision128(),
  integer(),
  Keyword.t()
) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains 128-bit decimals.

Arguments

  • data: a list, each element can be either
    • a Decimal.t()
    • an integer()
  • precision: The precision of the decimal values; precision should be between 1 and 38
  • scale: The scale of the decimal values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

decimal256(data, precision, scale, opts \\ [])

View Source
@spec decimal256(
  [Decimal.t() | integer() | nil],
  precision256(),
  integer(),
  Keyword.t()
) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains 256-bit decimals.

Arguments

  • data: a list, each element can be either
    • a Decimal.t()
    • an integer()
  • precision: The precision of the decimal values; precision should be between 1 and 76
  • scale: The scale of the decimal values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

delete_all_metadata(buffer)

View Source
@spec delete_all_metadata(%Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}
Link to this function

delete_metadata(buffer, key)

View Source
@spec delete_metadata(
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  },
  String.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}
Link to this function

dictionary(key, value, opts \\ [])

View Source
@spec dictionary(
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  },
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  },
  Keyword.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

Construct an array using dictionary encoding.

Dictionary encoding is a data representation technique to represent values by integers referencing a dictionary usually consisting of unique values. It can be effective when you have data with many repeated values.

Any array can be dictionary-encoded. The dictionary is stored as an optional property of an array. When a field is dictionary encoded, the values are represented by an array of non-negative integers representing the index of the value in the dictionary. The memory layout for a dictionary-encoded array is the same as that of a primitive integer layout. The dictionary is handled as a separate columnar array with its own respective layout.

As an example, you could have the following data:

Adbc.Column.string(["foo", "bar", "foo", "bar", nil, "baz"], nullable: true)

In dictionary-encoded form, this could appear as:

Adbc.Column.dictionary(
  Adbc.Column.string(["foo", "bar", "baz"], nullable: true),
  Adbc.Column.s32([0, 1, 0, 1, nil, 2], nullable: true)
)

Arguments

  • data: a list, each element of which can be one of the following:

    Note that each Adbc.Column in the list should have the same type.

  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

duration(data, unit, opts \\ [])

View Source
@spec duration([s64() | nil], time_unit(), Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains durations represented as 64-bit signed integers.

Arguments

  • data: a list of integer values representing the time in the specified unit

  • unit: specify the unit of the time value, one of the following:

    • :seconds
    • :milliseconds
    • :microseconds
    • :nanoseconds
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
@spec f16([float() | nil | :infinity | :neg_infinity | :nan], Keyword.t()) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains 16-bit half-precision floats.

Arguments

  • data: A list of 32-bit single-precision float values (will be converted to 16-bit floats in C)
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.f16([1.0, 2.0, 3.0])
%Adbc.Column{
  name: nil,
  type: :f16,
  nullable: false,
  metadata: nil,
  data: [1.0, 2.0, 3.0]
}
@spec f32([float() | nil | :infinity | :neg_infinity | :nan], Keyword.t()) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains 32-bit single-precision floats.

Arguments

  • data: A list of 32-bit single-precision float values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.f32([1.0, 2.0, 3.0])
%Adbc.Column{
  name: nil,
  type: :f32,
  nullable: false,
  metadata: nil,
  data: [1.0, 2.0, 3.0]
}
@spec f64([float() | nil | :infinity | :neg_infinity | :nan], Keyword.t()) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains 64-bit double-precision floats.

Arguments

  • data: A list of 64-bit double-precision float values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.f64([1.0, 2.0, 3.0])
%Adbc.Column{
  name: nil,
  type: :f64,
  nullable: false,
  metadata: nil,
  data: [1.0, 2.0, 3.0]
}
Link to this function

fixed_size_binary(data, nbytes, opts \\ [])

View Source
@spec fixed_size_binary([iodata() | nil], non_neg_integer(), Keyword.t()) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains fixed size binaries.

Similar to binary/2, but each binary value has the same fixed size in bytes.

Arguments

  • data: A list of binary values
  • nbytes: The fixed size of the binary values in bytes
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.fixed_size_binary([<<0>>, <<1>>, <<2>>], 1)
%Adbc.Column{
  name: nil,
  type: {:fixed_size_binary, 1},
  nullable: false,
  metadata: nil,
  data: [<<0>>, <<1>>, <<2>>]
}
Link to this function

fixed_size_list(data, fixed_size, opts \\ [])

View Source
@spec fixed_size_list(
  [
    %Adbc.Column{
      data: term(),
      length: term(),
      metadata: term(),
      name: term(),
      nullable: term(),
      offset: term(),
      type: term()
    }
    | nil
  ],
  s32(),
  Keyword.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

Similar to list/2, but the length of the list is the same.

Arguments

  • data: a list, each element of which can be one of the following:

    Note that each Adbc.Column in the list should have the same type and length.

  • fixed_size: The fixed size of the list.

  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

get_metadata(column, key, default \\ nil)

View Source
@spec get_metadata(
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  },
  String.t(),
  String.t() | nil
) :: String.t() | nil
Link to this function

interval(data, interval_unit, opts \\ [])

View Source
@spec interval(
  [interval_month() | interval_day_time() | interval_month_day_nano() | nil],
  interval_unit(),
  Keyword.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains durations represented as signed integers.

Arguments

  • data: a list, each element of which can be one of the following:

    • if unit is :month:

      • a 32-bit signed integer representing the number of months.
    • if unit is :day_time:

      • a 2-tuple, both the number of days and the number of milliseconds are in 32-bit signed integers.
    • if unit is :month_day_nano:

      • a 3-tuple, the number of months, days, and nanoseconds; the number of months and days are in 32-bit signed integers, and the number of nanoseconds is in 64-bit signed integers
  • unit: specify the unit of the time value, one of the following:

    • :month
    • :day_time
    • :month_day_nano
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

large_binary(data, opts \\ [])

View Source
@spec large_binary([iodata() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains large binary values.

Similar to binary/2, but for binary values larger than 2GB.

Arguments

  • data: A list of binary values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.large_binary([<<0>>, <<1>>, <<2>>])
%Adbc.Column{
  name: nil,
  type: :large_binary,
  nullable: false,
  metadata: nil,
  data: [<<0>>, <<1>>, <<2>>]
}
Link to this function

large_list(data, opts \\ [])

View Source
@spec large_list(
  [
    %Adbc.Column{
      data: term(),
      length: term(),
      metadata: term(),
      name: term(),
      nullable: term(),
      offset: term(),
      type: term()
    }
    | nil
  ],
  Keyword.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

Similar to list/2, but for large lists.

Arguments

  • data: a list, each element of which can be one of the following:

    Note that each Adbc.Column in the list should have the same type.

  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

large_string(data, opts \\ [])

View Source
@spec large_string([String.t() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains UTF-8 encoded large strings.

Similar to string/2, but for strings larger than 2GB.

Arguments

  • data: A list of UTF-8 encoded string values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.large_string(["a", "ab", "abc"])
%Adbc.Column{
  name: nil,
  type: :large_string,
  nullable: false,
  metadata: nil,
  data: ["a", "ab", "abc"]
}
@spec list(
  [
    %Adbc.Column{
      data: term(),
      length: term(),
      metadata: term(),
      name: term(),
      nullable: term(),
      offset: term(),
      type: term()
    }
    | nil
  ],
  Keyword.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that each row is a list of some type or nil.

Arguments

  • data: a list, each element of which can be one of the following:

    Note that each Adbc.Column in the list should have the same type.

  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
@spec materialize(%Adbc.Column{
  data: reference() | [reference()] | list() | map(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }
  | {:error, String.t()}

materialize/1 converts a column's data from reference type to regular Elixir terms.

@spec s8([s8() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains signed 8-bit integers.

Arguments

  • data: A list of signed 8-bit integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.s8([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :s8,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
@spec s16([s16() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains signed 16-bit integers.

Arguments

  • data: A list of signed 16-bit integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.s16([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :s16,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
@spec s32([s32() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains 32-bit signed integers.

Arguments

  • data: A list of 32-bit signed integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.s32([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :s32,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
@spec s64([s64() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains 64-bit signed integers.

Arguments

  • data: A list of 64-bit signed integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.s64([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :s64,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
Link to this function

set_metadata(buffer, key, value)

View Source
@spec set_metadata(
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  },
  String.t(),
  String.t()
) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}
Link to this function

string(data, opts \\ [])

View Source
@spec string([String.t() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains UTF-8 encoded strings.

Arguments

  • data: A list of UTF-8 encoded string values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.string(["a", "ab", "abc"])
%Adbc.Column{
  name: nil,
  type: :string,
  nullable: false,
  metadata: nil,
  data: ["a", "ab", "abc"]
}
Link to this function

time(data, unit, opts \\ [])

View Source
@spec time([Time.t() | nil] | [s64() | nil], time_unit(), Keyword.t()) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains time represented as signed integers in UTC.

Arguments

  • data:

    • a list of Time.t() value

    • a list of integer values representing the time in the specified unit

      Note that when using :seconds or :milliseconds as the unit, the time value is limited to the range of 32-bit signed integers.

      For :microseconds and :nanoseconds, the time value is limited to the range of 64-bit signed integers.

  • unit: specify the unit of the time value, one of the following:

    • :seconds
    • :milliseconds
    • :microseconds
    • :nanoseconds
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
Link to this function

timestamp(data, unit, timezone, opts \\ [])

View Source
@spec timestamp(
  [NaiveDateTime.t() | nil] | [s64() | nil],
  time_unit(),
  String.t(),
  Keyword.t()
) ::
  %Adbc.Column{
    data: term(),
    length: term(),
    metadata: term(),
    name: term(),
    nullable: term(),
    offset: term(),
    type: term()
  }

A column that contains timestamps represented as signed integers in the given timezone.

Arguments

  • data:

    • a list of NaiveDateTime.t() value
    • a list of 64-bit signed integer values representing the time in the specified unit
  • unit: specify the unit of the time value, one of the following:

    • :seconds
    • :milliseconds
    • :microseconds
    • :nanoseconds
  • timezone: the timezone of the timestamp

  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata
@spec to_list(%Adbc.Column{
  data: map(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

Convert a list view, run-end encoding array or a dictionary to a list.

Examples

iex> list_view = %Adbc.Column{
...>   name: nil,
...>   type: :list_view,
...>   nullable: true,
...>   metadata: nil,
...>   data: %{
...>     values: %Adbc.Column{
...>       name: "item",
...>       type: :s32,
...>       nullable: false,
...>       metadata: nil,
...>       data: [0, -127, 127, 50, 12, -7, 25]
...>     },
...>     validity: [true, false, true, true, true],
...>     offsets: [4, 7, 0, 0, 3],
...>     sizes: [3, 0, 4, 0, 2]
...>   }
...> }
%Adbc.Column{
  name: nil,
  type: :list_view,
  nullable: true,
  metadata: nil,
  data: %{
    offsets: [4, 7, 0, 0, 3],
    sizes: [3, 0, 4, 0, 2],
    validity: [true, false, true, true, true],
    values: %Adbc.Column{
      name: "item",
      type: :s32,
      nullable: false,
      metadata: nil,
      data: [0, -127, 127, 50, 12, -7, 25]
    }
  }
}
iex> Adbc.Column.to_list(list_view)
%Adbc.Column{
  name: nil,
  type: :list,
  nullable: true,
  metadata: nil,
  data: [
    %Adbc.Column{
      name: "item",
      type: :s32,
      nullable: false,
      metadata: nil,
      data: [12, -7, 25]
    },
    nil,
    %Adbc.Column{
      name: "item",
      type: :s32,
      nullable: false,
      metadata: nil,
      data: [0, -127, 127, 50]
    },
    %Adbc.Column{
      name: "item",
      type: :s32,
      nullable: false,
      metadata: nil,
      data: []
    },
    %Adbc.Column{
      name: "item",
      type: :s32,
      nullable: false,
      metadata: nil,
      data: ~c"2"
    }
  ]
}
@spec u8([u8() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains unsigned 8-bit integers.

Arguments

  • data: A list of unsigned 8-bit integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.u8([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :u8,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
@spec u16([u16() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains unsigned 16-bit integers.

Arguments

  • data: A list of unsigned 16-bit integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.u16([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :u16,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
@spec u32([u32() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains un32-bit signed integers.

Arguments

  • data: A list of un32-bit signed integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.u32([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :u32,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}
@spec u64([u64() | nil], Keyword.t()) :: %Adbc.Column{
  data: term(),
  length: term(),
  metadata: term(),
  name: term(),
  nullable: term(),
  offset: term(),
  type: term()
}

A column that contains un64-bit signed integers.

Arguments

  • data: A list of un64-bit signed integer values
  • opts: A keyword list of options

Options

  • :name - The name of the column
  • :nullable - A boolean value indicating whether the column is nullable
  • :metadata - A map of metadata

Examples

iex> Adbc.Column.u32([1, 2, 3])
%Adbc.Column{
  name: nil,
  type: :u32,
  nullable: false,
  metadata: nil,
  data: [1, 2, 3]
}