Välj kolumndatatyper

Om du väljer rätt datatyp för varje kolumn påverkas datakvaliteten, lagringseffektiviteten och frågeprestandan direkt. När du väljer en olämplig typ riskerar du att förlora precision, slösa lagringsutrymme eller blockera åtgärder som kräver specifika typegenskaper. I den här lektionen får du lära dig hur du utvärderar dina data och väljer de lämpligaste kolumntyperna i Azure Databricks.

Förstå kategorier för datatyper

Azure Databricks organiserar datatyper i kategorier baserat på deras egenskaper och användningsfall. Om du förstår de här kategorierna kan du begränsa dina alternativ när du väljer en typ för en specifik kolumn.

Numeriska typer hanterar matematiska värden och beräkningar. Du har flera alternativ:

Datum-tidstyper representerar tidsdata:

Text- och binärtyper lagrar tecken och bytesekvenser:

• STRING för text med variabel längd
• BINARY för råbytesekvenser

Komplexa typer organiserar kapslade eller upprepade data:

• ARRAY för ordnade sekvenser av element
• MAP för nyckel/värde-par
• STRUCT för poster med namngivna fält

Välj rätt numerisk typ

Numeriska data kräver noggrann typval eftersom olika typer har olika precisions-, intervall- och lagringsegenskaper. Ditt val påverkar både dataintegritet och prestanda.

För heltal matchar du typen med ditt värdeintervall:

När du skapar tabeller anger du lämplig typ för varje kolumn:

CREATE TABLE orders (
    order_id INT,
    status_code TINYINT,
    total_items SMALLINT,
    transaction_id BIGINT
);

För decimaltal beror valet mellan DECIMAL och flyttalstyper på dina precisionskrav:

-- DECIMAL(p,s): exact precision for financial calculations
-- p = total digits, s = digits after decimal point
CREATE TABLE transactions (
    transaction_id INT,
    amount DECIMAL(10,2),         -- Exact: up to 99,999,999.99
    tax_rate DECIMAL(5,4)         -- Exact: up to 9.9999
);

-- DOUBLE: approximate, suitable for scientific calculations
CREATE TABLE measurements (
    sensor_id INT,
    temperature DOUBLE,           -- Approximate, large range
    pressure DOUBLE
);

Välj temporala typer korrekt

Valet av tidsdatatyp beror på om du behöver tidszonsmedvetenhet och vilken precision ditt program kräver.

Använd DATE när du bara behöver kalenderdatum utan tidskomponenter:

CREATE TABLE employees (
    employee_id INT,
    hire_date DATE,
    birth_date DATE
);

För tidsstämplar väljer du mellan tidszonsmedvetna och tidszonsnaiva typer:

-- TIMESTAMP: normalizes to UTC internally, applies session timezone on read
-- Use when tracking events across time zones
CREATE TABLE audit_log (
    log_id BIGINT,
    event_time TIMESTAMP,
    user_id INT
);

-- TIMESTAMP_NTZ: no timezone conversion
-- Use when the time should remain as entered
CREATE TABLE schedules (
    schedule_id INT,
    local_meeting_time TIMESTAMP_NTZ
);

Typen TIMESTAMP konverterar värden till UTC för lagring och tillämpar sessionstidszonen när värden hämtas. Det här beteendet säkerställer konsekvent ordning mellan tidszoner, men kan orsaka förvirring om du förväntar dig att värdena förblir oförändrade.

Arbeta med komplexa typer

Med komplexa typer kan du lagra strukturerade, kapslade eller upprepade data i en enda kolumn. De är användbara när dina data inte passar en platt relationsmodell.

Använd ARRAY när du har flera värden av samma typ:

-- Store a list of tags for each product
CREATE TABLE products (
    product_id INT,
    name STRING,
    tags ARRAY<STRING>
);

-- Query array elements
SELECT product_id, tags[0] AS primary_tag FROM products;

Används MAP för nyckel/värde-par med dynamiska nycklar:

-- Store flexible attributes as key-value pairs
CREATE TABLE devices (
    device_id INT,
    properties MAP<STRING, STRING>
);

-- Access map values by key
SELECT device_id, properties['firmware_version'] AS firmware FROM devices;

Använd STRUCT när du har en fast uppsättning namngivna fält:

-- Store address as a structured type
CREATE TABLE customers (
    customer_id INT,
    address STRUCT<street: STRING, city: STRING, postal_code: STRING>
);

-- Access struct fields
SELECT customer_id, address.city FROM customers;

Tillämpa metodtips för typval

När du utvärderar data för typval bör du tänka på följande praktiska riktlinjer:

Matcha typen med datans natur och intervall. Använd inte BIGINT för värden som aldrig överstiger några tusen. De extra byteen multipliceras över miljontals rader.

Överväg möjligheten till nullvärden. Om en kolumn aldrig ska innehålla null-värden dokumenterar du den här begränsningen. Även om datatyper inte framtvingar nullbarhet som standard kan du lägga till NOT NULL begränsningar i tabelldefinitioner.

Verifiera typer under inmatning. Skicka inkommande data till måltypen tidigt i pipelinen för att fånga typmatchningar innan de sprids:

-- Cast during data loading
INSERT INTO target_table
SELECT 
    CAST(raw_id AS INT) AS id,
    CAST(raw_amount AS DECIMAL(10,2)) AS amount,
    CAST(raw_date AS DATE) AS transaction_date
FROM staging_table;

Använd explicita typecasts när du konverterar typer. Implicita konverteringar kan lyckas tyst även när data går förlorade. Explicita avgjutningar gör dina avsikter tydliga och hjälper till att identifiera problem under testningen.

Dessa metoder hjälper dig att skapa pipelines där datatyper fungerar som en form av dokumentation och validering, vilket fångar fel tidigt i stället för att låta dem påverka nedströmsanalyser.