Neo4j数据类型 #

数据类型：
├── 基本类型
│   ├── 数值类型
│   ├── 字符串
│   └── 布尔值
├── 集合类型
│   ├── 列表
│   └── 映射
├── 空间类型
│   ├── Point
│   └── 地理位置
├── 时间类型
│   ├── Date
│   ├── Time
│   ├── LocalTime
│   ├── DateTime
│   └── Duration
└── 特殊值
    └── NULL

CREATE (n:Number {
    small: 42,
    large: 9223372036854775807,
    negative: -100
})

CREATE (n:Number {
    pi: 3.14159,
    scientific: 1.5e10,
    negative: -0.5
})

MATCH (n:Number)
RETURN 
    n.small + 10 AS add,
    n.small - 10 AS subtract,
    n.small * 2 AS multiply,
    n.small / 2 AS divide,
    n.small % 3 AS modulo

RETURN 
    abs(-10) AS abs,
    ceil(3.2) AS ceil,
    floor(3.8) AS floor,
    round(3.5) AS round,
    sign(-5) AS sign,
    rand() AS random

RETURN 
    toInteger('42') AS int,
    toInteger(3.9) AS int_floor,
    toFloat('3.14') AS float

CREATE (n:Person {
    name: 'Tom',
    description: "It's a test",
    multiline: 'Line1
Line2
Line3'
})

MATCH (n:Person)
RETURN 
    n.name + ' Hanks' AS full_name,
    size(n.name) AS length,
    toUpper(n.name) AS upper,
    toLower(n.name) AS lower,
    trim('  hello  ') AS trimmed,
    ltrim('  hello  ') AS ltrimmed,
    rtrim('  hello  ') AS rtrimmed

RETURN 
    substring('Hello World', 0, 5) AS sub,
    left('Hello', 3) AS left_str,
    right('Hello', 3) AS right_str

RETURN 
    'Hello World' CONTAINS 'World' AS contains,
    'Hello' STARTS WITH 'He' AS starts,
    'Hello' ENDS WITH 'lo' AS ends,
    'Hello World' =~ 'He.*ld' AS regex

RETURN 
    replace('Hello World', 'World', 'Neo4j') AS replaced,
    split('a,b,c', ',') AS split_list

RETURN 
    'Hello' + ' ' + 'World' AS concat,
    apoc.text.join(['Hello', 'World'], ' ') AS joined

CREATE (n:Person {
    active: true,
    verified: false
})

RETURN 
    true AND false AS and_result,
    true OR false AS or_result,
    NOT true AS not_result,
    true XOR false AS xor_result

RETURN 
    5 > 3 AS greater,
    5 = 5 AS equal,
    5 <> 3 AS not_equal

CREATE (n:Person {
    tags: ['developer', 'designer', 'manager'],
    scores: [85, 90, 78, 92],
    mixed: [1, 'two', true, null]
})

WITH [1, 2, 3, 4, 5] AS list
RETURN 
    list[0] AS first,
    list[2] AS third,
    list[-1] AS last,
    list[1..3] AS range,
    list[0..] AS from_start,
    list[..3] AS to_third

WITH [1, 2, 3, 4, 5] AS list
RETURN 
    size(list) AS size,
    head(list) AS head,
    last(list) AS last,
    tail(list) AS tail

RETURN 
    [1, 2] + [3, 4] AS concat,
    [1, 2, 3, 2, 1] AS original,
    range(1, 10) AS range_list,
    range(1, 10, 2) AS step_range

WITH [1, 2, 3, 4, 5] AS list
RETURN [x IN list WHERE x > 2 | x * 2] AS filtered_doubled

MATCH (n:Person)
RETURN collect(n.name) AS names

WITH [1, 2, 3] AS list
UNWIND list AS item
RETURN item

CREATE (n:Person {
    name: 'Tom',
    address: {
        city: 'New York',
        country: 'USA',
        zip: '10001'
    }
})

MATCH (n:Person)
RETURN 
    n.address.city AS city,
    n.address['country'] AS country

WITH {name: 'Tom', age: 30} AS map
RETURN 
    keys(map) AS keys,
    values(map) AS values,
    map.name AS name

WITH {a: 1, b: 2} AS map1, {b: 3, c: 4} AS map2
RETURN map1 {.*}, map2 {.*} AS merged

CREATE (n:Location {
    point: point({latitude: 40.7128, longitude: -74.0060}),
    cartesian: point({x: 10, y: 20})
})

WITH 
    point({latitude: 40.7128, longitude: -74.0060}) AS nyc,
    point({latitude: 34.0522, longitude: -118.2437}) AS la
RETURN 
    point.distance(nyc, la) / 1000 AS distance_km

MATCH (n:Location)
WHERE point.distance(n.point, point({latitude: 40.7, longitude: -74.0})) < 10000
RETURN n

CREATE (n:Event {
    date: date('2024-01-15'),
    date_today: date(),
    date_components: date({year: 2024, month: 1, day: 15})
})

CREATE (n:Event {
    time: time('14:30:00'),
    time_tz: time('14:30:00+08:00'),
    time_now: time()
})

CREATE (n:Event {
    local_time: localtime('14:30:00'),
    local_time_now: localtime()
})

CREATE (n:Event {
    datetime: datetime('2024-01-15T14:30:00+08:00'),
    datetime_now: datetime(),
    datetime_components: datetime({
        year: 2024, 
        month: 1, 
        day: 15,
        hour: 14,
        minute: 30,
        second: 0,
        timezone: '+08:00'
    })
})

CREATE (n:Event {
    duration: duration('P1Y2M3DT4H5M6S'),
    duration_components: duration({years: 1, months: 2, days: 3})
})

WITH date('2024-01-15') AS d
RETURN 
    d + duration('P1M') AS next_month,
    d - duration('P1D') AS yesterday

WITH datetime() AS dt
RETURN 
    dt.year AS year,
    dt.month AS month,
    dt.day AS day,
    dt.hour AS hour,
    dt.minute AS minute,
    dt.second AS second,
    dt.dayOfWeek AS day_of_week,
    dt.week AS week

WITH datetime() AS dt
RETURN 
    apoc.temporal.format(dt, 'yyyy-MM-dd HH:mm:ss') AS formatted

CREATE (n:Person {
    name: 'Tom',
    middle_name: null
})

MATCH (n:Person)
WHERE n.middle_name IS NULL
RETURN n

MATCH (n:Person)
WHERE n.middle_name IS NOT NULL
RETURN n

MATCH (n:Person)
RETURN 
    n.name,
    n.middle_name,
    COALESCE(n.middle_name, 'N/A') AS middle_name_or_default,
    n.name + COALESCE(n.middle_name, '') AS full_name

RETURN 
    null + 1 AS result,
    null * 2 AS result2,
    null = null AS result3

RETURN 
    apoc.meta.type(42) AS int_type,
    apoc.meta.type('hello') AS string_type,
    apoc.meta.type([1, 2, 3]) AS list_type,
    apoc.meta.type({a: 1}) AS map_type

WITH 'hello' AS value
RETURN 
    apoc.meta.isType(value, 'STRING') AS is_string,
    apoc.meta.isType(value, 'INTEGER') AS is_integer

RETURN 
    toString(42) AS str,
    toInteger('42') AS int,
    toFloat('3.14') AS float,
    toBoolean('true') AS bool

RETURN 
    date('2024-01-15') AS date_val,
    datetime('2024-01-15T14:30:00') AS datetime_val,
    toString(date('2024-01-15')) AS date_str

WITH {name: 'Tom', age: 30} AS map
RETURN 
    apoc.convert.toJson(map) AS json_str,
    apoc.convert.fromJsonMap('{"name":"Tom","age":30}') AS json_map

MATCH (n:Person)
RETURN 
    n AS node,
    labels(n) AS labels,
    keys(n) AS properties,
    properties(n) AS property_map

MATCH ()-[r:KNOWS]->()
RETURN 
    r AS relationship,
    type(r) AS type,
    keys(r) AS properties,
    properties(r) AS property_map

MATCH p = (a)-[:KNOWS*1..3]->(b)
RETURN 
    p AS path,
    length(p) AS path_length,
    nodes(p) AS path_nodes,
    relationships(p) AS path_rels

建议：
├── 使用合适的最小类型
├── 时间使用原生时间类型
├── 地理位置使用Point类型
├── 避免在属性中存储大型列表
└── 保持类型一致性

建议：
├── 明确处理NULL值
├── 使用COALESCE提供默认值
├── 使用IS NULL/IS NOT NULL判断
└── 避免NULL参与计算