bool_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

datetime_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

date_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

/**
 * @param class-string<\UnitEnum> $type
 */
enum_schema(string $name, string $type, bool $nullable, ?Metadata $metadata) : Definition

float_schema(string $name, bool $nullable, int $precision, ?Metadata $metadata) : Definition

integer_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

/**
 * Alias for `int_schema`.
 */
int_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

json_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

list_schema(string $name, ListType $type, ?Metadata $metadata) : Definition

map_schema(string $name, MapType $type, ?Metadata $metadata) : Definition

null_schema(string $name, ?Metadata $metadata) : Definition

print_schema(Schema $schema, ?SchemaFormatter $formatter) : string

schema(Definition $definitions) : Schema

schema_evolving_matcher() : EvolvingSchemaMatcher

schema_from_json(string $schema) : Schema

schema_strict_matcher() : StrictSchemaMatcher

schema_to_json(Schema $schema, int $json_flags) : string

string_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

structure_schema(string $name, StructureType $type, ?Metadata $metadata) : Definition

struct_schema(string $name, StructureType $type, ?Metadata $metadata) : Definition

/**
 * Alias for `string_schema`.
 */
str_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

time_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

uuid_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

xml_element_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

xml_schema(string $name, bool $nullable, ?Metadata $metadata) : Definition

type_array(bool $empty, bool $nullable) : ArrayType

type_boolean(bool $nullable) : BooleanType

type_callable(bool $nullable) : CallableType

type_date(bool $nullable) : DateType

type_datetime(bool $nullable) : DateTimeType

/**
 * @param class-string<\UnitEnum> $class
 */
type_enum(string $class, bool $nullable) : EnumType

type_float(bool $nullable, int $precision) : FloatType

type_int(bool $nullable) : IntegerType

type_integer(bool $nullable) : IntegerType

type_json(bool $nullable) : JsonType

/**
 * @param Type<mixed> $element
 */
type_list(Type $element, bool $nullable) : ListType

/**
 * @param Type<mixed> $value_type
 */
type_map(StringType|IntegerType $key_type, Type $value_type, bool $nullable) : MapType

type_null() : NullType

/**
 * @param class-string $class
 */
type_object(string $class, bool $nullable) : ObjectType

type_resource(bool $nullable) : ResourceType

type_string(bool $nullable) : StringType

/**
 * @param array<string, Type<mixed>> $elements
 */
type_structure(array $elements, bool $nullable) : StructureType

type_time(bool $nullable) : TimeType

type_uuid(bool $nullable) : UuidType

type_xml(bool $nullable) : XMLType

type_xml_element(bool $nullable) : XMLElementType

boolean_entry(string $name, ?bool $value) : BooleanEntry

bool_entry(string $name, ?bool $value) : BooleanEntry

datetime_entry(string $name, DateTimeInterface|string|null $value) : DateTimeEntry

date_entry(string $name, DateTimeInterface|string|null $value) : DateEntry

enum_entry(string $name, ?UnitEnum $enum) : EnumEntry

float_entry(string $name, ?float $value, int $precision) : FloatEntry

integer_entry(string $name, ?int $value) : IntegerEntry

int_entry(string $name, ?int $value) : IntegerEntry

json_entry(string $name, array|string|null $data) : JsonEntry

/**
 * @throws InvalidArgumentException
 */
json_object_entry(string $name, array|string|null $data) : JsonEntry

/**
 * @param list<mixed> $value
 */
list_entry(string $name, ?array $value, ListType $type) : ListEntry

map_entry(string $name, ?array $value, MapType $mapType) : MapEntry

/**
 * This functions is an alias for creating string entry from null.
 * The main difference between using this function an simply str_entry with second argument null
 * is that this function will also keep a note in the metadata that type might not be final.
 * For example when we need to guess column type from rows because schema was not provided,
 * and given column in the first row is null, it might still change once we get to the second row.
 * That metadata is used to determine if string_entry was created from null or not.
 *
 * By design flow assumes when guessing column type that null would be a string (the most flexible type).
 */
null_entry(string $name) : StringEntry

string_entry(string $name, ?string $value) : StringEntry

structure_entry(string $name, ?array $value, StructureType $type) : StructureEntry

struct_entry(string $name, ?array $value, StructureType $type) : StructureEntry

str_entry(string $name, ?string $value) : StringEntry

time_entry(string $name, DateInterval|string|null $value) : TimeEntry

uuid_entry(string $name, Uuid|string|null $value) : UuidEntry

xml_element_entry(string $name, DOMElement|string|null $value) : XMLElementEntry

xml_entry(string $name, DOMDocument|string|null $value) : XMLEntry

append() : SaveMode

/**
 * @param array<array<mixed>>|array<mixed|string> $data
 * @param array<Partition>|Partitions $partitions
 */
array_to_row(array $data, EntryFactory $entryFactory, Partitions|array $partitions, ?Schema $schema) : Row

/**
 * @param array<array<mixed>>|array<mixed|string> $data
 * @param array<Partition>|Partitions $partitions
 */
array_to_rows(array $data, EntryFactory $entryFactory, Partitions|array $partitions, ?Schema $schema) : Rows

/**
 * An alias for `ref`.
 */
col(string $entry) : EntryReference

compare_entries_by_name(Order $order) : Comparator

compare_entries_by_name_desc() : Comparator

/**
 * @param array<class-string<Entry<mixed, mixed>>, int> $priorities
 */
compare_entries_by_type(array $priorities, Order $order) : Comparator

/**
 * @param array<class-string<Entry<mixed, mixed>>, int> $priorities
 */
compare_entries_by_type_and_name(array $priorities, Order $order) : Comparator

/**
 * @param array<class-string<Entry<mixed, mixed>>, int> $priorities
 */
compare_entries_by_type_desc(array $priorities) : Comparator

config() : Config

config_builder() : ConfigBuilder

data_frame(Config|ConfigBuilder|null $config) : Flow

/**
 * Alias for data_frame() : Flow.
 */
df(Config|ConfigBuilder|null $config) : Flow

dom_element_to_string(DOMElement $element, bool $format_output, bool $preserver_white_space) : string|false

/**
 * @param Entry<mixed, mixed> ...$entries
 */
entries(Entry $entries) : Entries

exception_if_exists() : SaveMode

execution_context(?Config $config) : FlowContext

filesystem_cache(Path|string|null $cache_dir, Filesystem $filesystem, Serializer $serializer) : FilesystemCache

flow_context(?Config $config) : FlowContext

generate_random_int(int $start, int $end, NativePHPRandomValueGenerator $generator) : int

generate_random_string(int $length, NativePHPRandomValueGenerator $generator) : string

/**
 * @return Type<mixed>
 */
get_type(?mixed $value) : Type

ignore() : SaveMode

ignore_error_handler() : IgnoreError

/**
 * @param array<string|Type<mixed>> $types
 * @param mixed $value
 */
is_type(array $types, ?mixed $value) : bool

join_on(Comparison|array $comparisons, string $join_prefix) : Expression

overwrite() : SaveMode

print_rows(Rows $rows, int|bool $truncate, ?Formatter $formatter) : string

random_string(ScalarFunction|int $length, RandomValueGenerator $generator) : RandomString

/**
 * @param Entry<mixed, mixed> ...$entry
 */
row(Entry $entry) : Row

rows(Row $row) : Rows

rows_partitioned(array $rows, Partitions|array $partitions) : Rows

row_number() : RowNumber

skip_rows_handler() : SkipRows

throw_error_handler() : ThrowError

/**
 * @param array<mixed> $data
 *
 * @return Entry<mixed, mixed>
 */
to_entry(string $name, ?mixed $data, EntryFactory $entryFactory) : Entry

window() : Window

/**
 * @param int<1, max> $chunk_size
 */
chunks_from(Extractor $extractor, int $chunk_size) : ChunkExtractor

files(Path|string $directory) : FilesExtractor

from_all(Extractor $extractors) : ChainExtractor

/**
 * @param iterable $array
 * @param null|Schema $schema - @deprecated use withSchema() method instead
 */
from_array(iterable $array, ?Schema $schema) : ArrayExtractor

/**
 * @param string $id - cache id from which data will be extracted
 * @param null|Extractor $fallback_extractor - extractor that will be used when cache is empty - @deprecated use withFallbackExtractor() method instead
 * @param bool $clear - clear cache after extraction - @deprecated use withClearOnFinish() method instead
 */
from_cache(string $id, ?Extractor $fallback_extractor, bool $clear) : CacheExtractor

from_data_frame(DataFrame $data_frame) : DataFrameExtractor

from_memory(Memory $memory) : MemoryExtractor

from_path_partitions(Path|string $path) : PathPartitionsExtractor

from_pipeline(Pipeline $pipeline) : PipelineExtractor

from_rows(Rows $rows) : RowsExtractor

from_sequence_date_period(string $entry_name, DateTimeInterface $start, DateInterval $interval, DateTimeInterface $end, int $options) : SequenceExtractor

from_sequence_date_period_recurrences(string $entry_name, DateTimeInterface $start, DateInterval $interval, int $recurrences, int $options) : SequenceExtractor

from_sequence_number(string $entry_name, string|int|float $start, string|int|float $end, int|float $step) : SequenceExtractor

average(EntryReference|string $ref) : Average

collect(EntryReference|string $ref) : Collect

collect_unique(EntryReference|string $ref) : CollectUnique

count(EntryReference $function) : Count

first(EntryReference|string $ref) : First

last(EntryReference|string $ref) : Last

max(EntryReference|string $ref) : Max

min(EntryReference|string $ref) : Min

string_agg(EntryReference|string $ref, string $separator, ?SortOrder $sort) : StringAggregate

sum(EntryReference|string $ref) : Sum

all(ScalarFunction $functions) : All

any(ScalarFunction $values) : Any

array_exists(ScalarFunction|array $ref, ScalarFunction|string $path) : ArrayPathExists

/**
 * Expands each value into entry, if there are more than one value, multiple rows will be created.
 * Array keys are ignored, only values are used to create new rows.
 *
 * Before:
 *   +--+-------------------+
 *   |id|              array|
 *   +--+-------------------+
 *   | 1|{"a":1,"b":2,"c":3}|
 *   +--+-------------------+
 *
 * After:
 *   +--+--------+
 *   |id|expanded|
 *   +--+--------+
 *   | 1|       1|
 *   | 1|       2|
 *   | 1|       3|
 *   +--+--------+
 */
array_expand(ScalarFunction $function, ArrayExpand $expand) : ArrayExpand

array_get(ScalarFunction $ref, ScalarFunction|string $path) : ArrayGet

array_get_collection(ScalarFunction $ref, ScalarFunction|array $keys) : ArrayGetCollection

array_get_collection_first(ScalarFunction $ref, string $keys) : ArrayGetCollection

array_keys_style_convert(ScalarFunction $ref, StringStyles|string $style) : ArrayKeysStyleConvert

array_key_rename(ScalarFunction $ref, ScalarFunction|string $path, ScalarFunction|string $newName) : ArrayKeyRename

array_merge(ScalarFunction|array $left, ScalarFunction|array $right) : ArrayMerge

array_merge_collection(ScalarFunction|array $array) : ArrayMergeCollection

array_reverse(ScalarFunction|array $function, ScalarFunction|bool $preserveKeys) : ArrayReverse

array_sort(ScalarFunction $function, ScalarFunction|Sort|null $sort_function, ScalarFunction|int|null $flags, ScalarFunction|bool $recursive) : ArraySort

/**
 * Unpacks each element of an array into a new entry, using the array key as the entry name.
 *
 * Before:
 * +--+-------------------+
 * |id|              array|
 * +--+-------------------+
 * | 1|{"a":1,"b":2,"c":3}|
 * | 2|{"d":4,"e":5,"f":6}|
 * +--+-------------------+
 *
 * After:
 * +--+-----+-----+-----+-----+-----+
 * |id|arr.b|arr.c|arr.d|arr.e|arr.f|
 * +--+-----+-----+-----+-----+-----+
 * | 1|    2|    3|     |     |     |
 * | 2|     |     |    4|    5|    6|
 * +--+-----+-----+-----+-----+-----+
 */
array_unpack(ScalarFunction|array $array, ScalarFunction|array $skip_keys, ScalarFunction|string|null $entry_prefix) : ArrayUnpack

between(?mixed $value, ?mixed $lower_bound, ?mixed $upper_bound, ScalarFunction|Boundary $boundary) : Between

capitalize(ScalarFunction|string $value) : Capitalize

/**
 * @param ScalarFunction|string|Type<mixed> $type
 */
cast(?mixed $value, ScalarFunction|Type|string $type) : Cast

coalesce(ScalarFunction $values) : Coalesce

combine(ScalarFunction|array $keys, ScalarFunction|array $values) : Combine

/**
 * Concat all values. If you want to concatenate values with separator use concat_ws function.
 */
concat(ScalarFunction|string $functions) : Concat

/**
 * Concat all values with separator.
 */
concat_ws(ScalarFunction|string $functions) : ConcatWithSeparator

date_time_format(ScalarFunction $ref, string $format) : DateTimeFormat

/**
 * An alias for `ref`.
 */
entry(string $entry) : EntryReference

exists(ScalarFunction $ref) : Exists

greatest(?mixed $values) : Greatest

hash(?mixed $value, Algorithm $algorithm) : Hash

least(?mixed $values) : Least

list_ref(string $entry) : ListFunctions

lit(?mixed $value) : Literal

lower(ScalarFunction|string $value) : ToLower

not(ScalarFunction $value) : Not

now(DateTimeZone|ScalarFunction $time_zone) : Now

number_format(ScalarFunction|int|float $value, ScalarFunction|int $decimals, ScalarFunction|string $decimal_separator, ScalarFunction|string $thousands_separator) : NumberFormat

optional(ScalarFunction $function) : Optional

ref(string $entry) : EntryReference

refs(Reference|string $entries) : References

regex(ScalarFunction|string $pattern, ScalarFunction|string $subject, ScalarFunction|int $flags, ScalarFunction|int $offset) : Regex

regex_all(ScalarFunction|string $pattern, ScalarFunction|string $subject, ScalarFunction|int $flags, ScalarFunction|int $offset) : RegexAll

regex_match(ScalarFunction|string $pattern, ScalarFunction|string $subject, ScalarFunction|int $flags, ScalarFunction|int $offset) : RegexMatch

regex_match_all(ScalarFunction|string $pattern, ScalarFunction|string $subject, ScalarFunction|int $flags, ScalarFunction|int $offset) : RegexMatchAll

regex_replace(ScalarFunction|string $pattern, ScalarFunction|string $replacement, ScalarFunction|string $subject, ScalarFunction|int|null $limit) : RegexReplace

round(ScalarFunction|int|float $value, ScalarFunction|int $precision, ScalarFunction|int $mode) : Round

sanitize(ScalarFunction|string $value, ScalarFunction|string $placeholder, ScalarFunction|int|null $skipCharacters) : Sanitize

size(?mixed $value) : Size

split(ScalarFunction|string $value, ScalarFunction|string $separator, ScalarFunction|int $limit) : Split

sprintf(ScalarFunction|string $format, ScalarFunction|string|int|float|null $args) : Sprintf

structure_ref(string $entry) : StructureFunctions

to_date(?mixed $ref, ScalarFunction|string $format, ScalarFunction|DateTimeZone $timeZone) : ToDate

to_date_time(?mixed $ref, ScalarFunction|string $format, ScalarFunction|DateTimeZone $timeZone) : ToDateTime

to_timezone(ScalarFunction|DateTimeInterface $value, ScalarFunction|DateTimeZone|string $timeZone) : ToTimeZone

ulid(ScalarFunction|string|null $value) : Ulid

upper(ScalarFunction|string $value) : ToUpper

uuid_v4() : Uuid

uuid_v7(ScalarFunction|DateTimeInterface|null $value) : Uuid

when(?mixed $condition, ?mixed $then, ?mixed $else) : When

dense_rank() : DenseRank

dens_rank() : DenseRank

rank() : Rank

compare_all(Comparison $comparisons) : All

compare_any(Comparison $comparisons) : Any

equal(Reference|string $left, Reference|string $right) : Equal

identical(Reference|string $left, Reference|string $right) : Identical

/**
 * Advanced type casting mechanism.
 * Usage:
 *
 * caster()->to(type_float(precision: 2))->value("1.1234") // 1.12
 *
 * Options can be also passed to "to" function to override default options.
 *
 * caster()->to(type_float(precision: 2), caster_options())->value("1.1234") // 1.12
 */
caster(?Options $options) : Caster

caster_options() : Options

date_interval_to_microseconds(DateInterval $interval) : int

date_interval_to_milliseconds(DateInterval $interval) : int

date_interval_to_seconds(DateInterval $interval) : int

/**
 * Convert rows to an array and store them in passed array variable.
 *
 * @param-out array<array<mixed>> $array
 */
to_array(array $array) : ArrayLoader

to_branch(ScalarFunction $condition, Loader $loader) : Loader

to_callable(callable $callable) : CallbackLoader

to_memory(Memory $memory) : MemoryLoader

to_output(int|bool $truncate, Output $output, Formatter $formatter, SchemaFormatter $schemaFormatter) : StreamLoader

to_stderr(int|bool $truncate, Output $output, Formatter $formatter, SchemaFormatter $schemaFormatter) : StreamLoader

to_stdout(int|bool $truncate, Output $output, Formatter $formatter, SchemaFormatter $schemaFormatter) : StreamLoader

to_stream(string $uri, int|bool $truncate, Output $output, string $mode, Formatter $formatter, SchemaFormatter $schemaFormatter) : StreamLoader

to_transformation(Transformer $transformer, Loader $loader) : TransformerLoader