SELECT * FROM read_parquet('file.parquet');
SELECT r['id'], r['name'] FROM read_parquet('file.parquet') r WHERE r['age'] > 21;
SELECT COUNT(*) FROM read_parquet('file.parquet');

SELECT * FROM read_csv('file.csv');
SELECT r['id'], r['name'] FROM read_csv('file.csv') r WHERE r['age'] > 21;
SELECT COUNT(*) FROM read_csv('file.csv');

  SELECT * FROM read_parquet('file.parquet');
SELECT r['id'], r['name'] FROM read_parquet('file.parquet') r WHERE r['age'] > 21;
SELECT COUNT(*) FROM read_parquet('file.parquet');

SELECT * FROM iceberg_scan('data/iceberg/table');
SELECT r['id'], r['name'] FROM iceberg_scan('data/iceberg/table') r WHERE r['age'] > 21;
SELECT COUNT(*) FROM iceberg_scan('data/iceberg/table');

SELECT * FROM iceberg_snapshots('data/iceberg/table');

SELECT * FROM delta_scan('/path/to/delta/dataset');
SELECT r['id'], r['name'] FROM delta_scan('/path/to/delta/dataset') r WHERE r['age'] > 21;
SELECT COUNT(*) FROM delta_scan('/path/to/delta/dataset');

-- Извлечь строковое значение, если объединение содержит строку
SELECT union_extract(my_union_column, 'string') FROM my_table;

-- Извлечь целочисленное значение из объединения
SELECT union_extract(data_field, 'integer') AS extracted_int FROM mixed_data;

-- Получить активный тег для каждой строки
SELECT union_tag(my_union_column) AS active_type FROM my_table;

-- Отфильтровать строки, используя тег объединения
SELECT * FROM my_table WHERE union_tag(data_field) = 'string';

-- Получить количество записей в ассоциативном массиве
SELECT cardinality(r['map_col']) as size
FROM duckdb.query($$ SELECT MAP(['a', 'b', 'c'], [1, 2, 3]) as map_col $$) r;
-- Возвращает: 3

-- Пустой ассоциативный массив
SELECT cardinality(r['map_col']) as size
FROM duckdb.query($$ SELECT MAP([], []) as map_col $$) r;
-- Возвращает: 0

-- Получить значение для определённого ключа
SELECT element_at(r['map_col'], 'a') as value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: {1}

-- Несуществующий ключ
SELECT element_at(r['map_col'], 'c') as value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: {}

-- Объединить два ассоциативных массива
SELECT map_concat(r1['map1'], r2['map2']) as merged
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map1 $$) r1,
     duckdb.query($$ SELECT MAP(['b', 'c'], [3, 4]) as map2 $$) r2;
-- Возвращает: {a=1, b=3, c=4}

-- Примечание: значение 'b' из map2 (3) заменяет значение (2) из map1

-- Проверить, существует ли ключ
SELECT map_contains(r['map_col'], 'a') as has_key
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: t (true)

-- Проверить отсутствующий ключ
SELECT map_contains(r['map_col'], 'c') as has_key
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: f (false)

-- Проверить наличие пары ключ-значение
SELECT map_contains_entry(r['map_col'], 'a', 1) as has_entry
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: t (true)

-- Проверить наличие записи с неправильным значением у существующего ключа
SELECT map_contains_entry(r['map_col'], 'a', 2) as has_entry
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: f (false)

-- Проверить наличие значения
SELECT map_contains_value(r['map_col'], 1) as has_value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: t (true)

-- Проверить несуществующее значение
SELECT map_contains_value(r['map_col'], 3) as has_value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: f (false)

-- Получить все пары ключ-значение в виде struct
SELECT map_entries(r['map_col']) as entries
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: {"(a,1)","(b,2)"}

-- Получить доступ к отдельным полям типа struct
SELECT unnest(map_entries(r['map_col'])) as entry
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;

-- Извлечь значение из ассоциативного массива
SELECT map_extract(r['map_col'], 'a') as value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: {1}

-- Извлечь несуществующий ключ
SELECT map_extract(r['map_col'], 'c') as value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: {}

-- Извлечь одно значение (не в виде массива)
SELECT map_extract_value(r['map_col'], 'a') as value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: 1

-- Несуществующий ключ возвращает значение NULL
SELECT map_extract_value(r['map_col'], 'c') as value
FROM duckdb.query($$ SELECT MAP(['a', 'b'], [1, 2]) as map_col $$) r;
-- Возвращает: NULL

-- Создать ассоциативный массив из массива данных типа struct
SELECT map_from_entries(r['entries']) as new_map
FROM duckdb.query($$
    SELECT [{'k': 'a', 'v': 1}, {'k': 'b', 'v': 2}] as entries
$$) r;
-- Возвращает: {a=1, b=2}

-- Операция, обратная map_entries
SELECT map_from_entries(map_entries(r['map_col'])) as reconstructed
FROM duckdb.query($$ SELECT MAP(['x', 'y'], [10, 20]) as map_col $$) r;
-- Возвращает: {x=10, y=20}

-- Получить все ключи из ассоциативного массива
SELECT map_keys(r['map_col']) as keys
FROM duckdb.query($$ SELECT MAP(['a', 'b', 'c'], [1, 2, 3]) as map_col $$) r;
-- Возвращает: {a,b,c}

-- Пустой ассоциативный массив
SELECT map_keys(r['map_col']) as keys
FROM duckdb.query($$ SELECT MAP([], []) as map_col $$) r;
-- Возвращает: {}

-- Получить все значения из ассоциативного массива
SELECT map_values(r['map_col']) as values
FROM duckdb.query($$ SELECT MAP(['a', 'b', 'c'], [1, 2, 3]) as map_col $$) r;
-- Возвращает: {1,2,3}

-- Пустой ассоциативный массив
SELECT map_values(r['map_col']) as values
FROM duckdb.query($$ SELECT MAP([], []) as map_col $$) r;
-- Возвращает: {}

-- Приблизительное количество уникальных идентификаторов клиентов
SELECT approx_count_distinct(customer_id) FROM orders;

-- Сравнить с точным количеством
SELECT
    approx_count_distinct(customer_id) AS approx_distinct,
    COUNT(DISTINCT customer_id) AS exact_distinct
FROM orders;

-- Выбрать 10% строк из таблицы
SELECT * FROM large_table TABLESAMPLE SYSTEM(10);

-- Выбрать примерно 1000 строк
SELECT * FROM events TABLESAMPLE SYSTEM(1000 ROWS);

-- Выбрать из файлов озера данных
SELECT * FROM read_parquet('s3://datalake/**/*.parquet') TABLESAMPLE SYSTEM(5);

-- Использовать выборку для быстрого анализа данных
SELECT
    region,
    COUNT(*) as sample_count,
    AVG(revenue) as avg_revenue
FROM sales_data TABLESAMPLE SYSTEM(2)
GROUP BY region;

-- Выбрать из соединений для ускорения
SELECT c.name, COUNT(o.id) as order_count
FROM customers c
JOIN orders o TABLESAMPLE SYSTEM(10) ON c.id = o.customer_id
GROUP BY c.name;

-- Системная выборка (рекомендуется для больших таблиц)
SELECT * FROM huge_table TABLESAMPLE SYSTEM(1);

-- Выборка Bernoulli (точный процент)
SELECT * FROM medium_table TABLESAMPLE BERNOULLI(5);

-- Группировать события по часам
SELECT time_bucket(INTERVAL '1 hour', created_at) as hour_bucket, COUNT(*)
FROM events
GROUP BY hour_bucket
ORDER BY hour_bucket;

-- Группировать с интервалом 15 минут
SELECT time_bucket(INTERVAL '15 minutes', timestamp_col), AVG(value)
FROM sensor_data
WHERE timestamp_col >= '2024-01-01'
GROUP BY 1
ORDER BY 1;

-- Форматировать текущую временную метку
SELECT strftime(NOW(), '%Y-%m-%d %H:%M:%S') AS formatted_time;

-- Форматировать временные метки в разных форматах
SELECT
    order_id,
    strftime(created_at, '%Y-%m-%d') AS order_date,
    strftime(created_at, '%H:%M') AS order_time,
    strftime(created_at, '%A, %B %d, %Y') AS readable_date
FROM orders;

-- Использовать для секционирования экспорта в файлы
COPY (SELECT * FROM events WHERE event_date = '2024-01-01')
TO 's3://bucket/events/' || strftime('2024-01-01'::timestamp, '%Y/%m/%d') || '/events.parquet';

-- Разобрать строки с датами
SELECT strptime('2024-01-15 14:30:00', '%Y-%m-%d %H:%M:%S') AS parsed_timestamp;

-- Разобрать разные форматы
SELECT
    strptime('Jan 15, 2024', '%b %d, %Y') AS date1,
    strptime('15/01/2024', '%d/%m/%Y') AS date2,
    strptime('2024-01-15T14:30:00Z', '%Y-%m-%dT%H:%M:%SZ') AS iso_date;

-- Разобрать временные метки в журнале
SELECT
    log_id,
    strptime(timestamp_string, '%Y-%m-%d %H:%M:%S') AS parsed_time,
    message
FROM raw_logs;

-- Получить текущее время эпохи Unix
SELECT epoch(NOW()) AS current_epoch;

-- Преобразовать временные метки для использования в API
SELECT
    event_id,
    epoch(event_timestamp) AS epoch_seconds
FROM events;

-- Отфильтровать, используя время эпохи Unix
SELECT * FROM events
WHERE epoch(created_at) > 1640995200; -- After 2022-01-01

-- Высокоточная временная метка для JavaScript
SELECT epoch_ms(NOW()) AS timestamp_ms;

-- Для данных временных рядов
SELECT
    sensor_id,
    epoch_ms(reading_time) AS timestamp_ms,
    value
FROM sensor_readings;

-- Преобразовать миллисекунды эпохи Unix во временную метку
SELECT epoch_ms(1640995200000) AS timestamp_from_ms; -- 2022-01-01 00:00:00

-- Преобразовать сохранённые миллисекунды обратно во временные метки
SELECT
    event_id,
    epoch_ms(timestamp_ms) AS event_time
FROM events;

-- Временные метки с точностью до микросекунды
SELECT epoch_us(NOW()) AS timestamp_us;

-- Временные метки с точностью до наносекунды
SELECT epoch_ns(NOW()) AS timestamp_ns;

-- Создать временную метку из текущего времени в микросекундах эпохи Unix
SELECT make_timestamp(epoch_us(NOW())) AS reconstructed_timestamp;

-- Создать определённую временную метку
SELECT make_timestamp(1640995200000000) AS new_years_2022; -- 2022-01-01 00:00:00

-- Создать timestamptz из текущих микросекунд эпохи
SELECT make_timestamptz(epoch_us(NOW())) AS reconstructed_timestamptz;

-- Создать конкретную timestamptz
SELECT make_timestamptz(1640995200000000) AS new_years_2022_tz;

  SELECT duckdb.install_extension('iceberg');
SELECT duckdb.install_extension('avro', 'community');

  GRANT ALL ON FUNCTION duckdb.install_extension(TEXT, TEXT) TO my_admin;

SELECT duckdb.load_extension('iceberg');

-- Отключить автозагрузку расширения
SELECT duckdb.autoload_extension('iceberg', false);

-- Включить автозагрузку расширения
SELECT duckdb.autoload_extension('iceberg', true);

В этом запросе FROM помещён перед SELECT и используется списковое включение (list comprehension). Обе эти функциональности не поддерживаются Postgres Pro.

  SELECT * FROM duckdb.query('FROM range(10) as a(a) SELECT [a for i in generate_series(0, a)] as arr');

  CALL duckdb.recycle_ddb();

-- Создать секрет S3
SELECT duckdb.create_simple_secret(
    type := 'S3',
    key_id := 'your_access_key',
    secret := 'your_secret_key',
    region := 'us-east-1'
);

-- Создать секрет S3 с токеном сеанса
SELECT duckdb.create_simple_secret(
    type := 'S3',
    key_id := 'your_access_key',
    secret := 'your_secret_key',
    region := 'us-east-1',
    session_token := 'your_session_token'
);