PolarDB:Agtype

NULL

In Cypher, a null is used to represent a missing or undefined value. Conceptually, null represents "a missing unknown value" and it is treated differently from other values. For example, if you try to get a property from a vertex but that property does not exist, null is returned. Most expressions that take null as input produce null. This includes Boolean expressions used as predicates in WHERE clauses. In this case, anything that is not true is interpreted as being false. Note that null is not equal to null. Not knowing two values does not mean that they are the same value. Therefore, the expression null = null returns null instead of true.

Input and output formats

SELECT * FROM cypher('graph_name', $$
    RETURN NULL
$$) AS (null_result agtype);

A null is returned as an empty space. Sample result:

 null_result 
-------------
 
(1 row)

Agtype NULL and Postgres NULL

The concept of NULL in Agtype and Postgres is the same as it is in Cypher.

Integer

The integer data type stores whole numbers (numbers without decimal parts). The integer data type is a 64-bit field that can store values ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Attempts to store values outside this range result in errors.

The integer type is commonly used because it offers the best balance between range, storage size, and performance. The smallint type is generally used only if disk space is insufficient. The bigint type is designed to be used when the range of the integer type is insufficient.

Input and output formats

SELECT * FROM cypher('graph_name', $$
    RETURN 1
$$) AS (int_result agtype);

Sample result:

 int_result 
------------
 1
(1 row)

Float

The Float data type is an inexact, variable-precision numeric type, conforming to the IEEE-754 Standard.

Inexact means that some values cannot be converted exactly to the internal format and are stored as approximations, so that storing and retrieving a value might show slight discrepancies. Managing these errors and how they propagate through calculations is the subject of an entire branch of mathematics and computer science and will not be discussed here, except for the following points:

• If you require exact storage and calculations (such as for monetary amounts), use the numeric data type.

• If you want to perform complicated calculations with these types for important tasks, especially if you rely on certain behavior in boundary cases (infinity, underflow), you must evaluate the implementation carefully.

• Comparing two floating-point values for equality might not always work as expected.

Values that are too large or too small cause errors. Rounding may occur if the precision of an input number is too high Numbers too close to zero that are not representable as distinct from zero cause underflow errors.

In addition to ordinary numeric values, the float data type have several special values:

• Infinity

• -Infinity

• NaN

When writing these values as constants in a Cypher command, you must put quotes around them and typecast them, for example:

SET x.float_value = '-Infinity'::float

On input, these strings are recognized in a case-insensitive manner.

Input and output formats

Use the float type to represent a number with a decimal part.

SELECT * FROM cypher('graph_name', $$
    RETURN 1.0
$$) AS (float_result agtype);

Sample result:

 float_result 
--------------
 1.0
(1 row)

Numeric

The numeric data type is used to store numbers with a very large number of digits. It is especially recommended for storing monetary amounts and other quantities where exactness is required. Calculations with numeric values yield exact results via basic calculations including addition, subtraction, and multiplication. However, calculations on numeric values are very slow compared to the integer or float data types.

Terms

• Precision: The precision of a numeric is the total count of significant digits in the whole number, that is, the number of digits to both sides of the decimal point.

• Scale: The scale of a numeric is the count of decimal digits in the fractional part (to the right of the decimal point).

So the number 23.5141 has a precision of 6 and a scale of 4. Integers can be considered to have a scale of zero.

Without any precision or scale creates a column in which numeric values of any precision and scale can be stored, up to the implementation limit on precision. A column of this kind will not coerce input values to any particular scale, whereas numeric columns with a declared scale will coerce input values to that scale.

If the scale of a value to be stored is greater than the declared scale of the column, the system will round the value to the specified number of fractional digits. Then, if the number of digits to the left of the decimal point exceeds the declared precision minus the declared scale, an error is returned.

numeric values are physically stored without any extra leading or trailing zeroes. Therefore, the declared precision and scale of a column are maximums, not fixed allocations. (In this sense the numeric type is more akin to varchar(n) than to char(n)). The actual storage requirement is two bytes for each group of four decimal digits, plus three to eight bytes overhead.

In addition to ordinary numeric values, the numeric type allows the special value NaN, meaning not-a-number. Any operation on NaN yields another NaN. When writing this value as a constant in an SQL command, you must put quotes around it, for example:

UPDATE table SET x = 'NaN'

When rounding values, the numeric type rounds ties away from zero, while (on most machines) the real and double types round ties to the nearest even number.

Input and output formats

When you create data of the numeric type, the ::numeric annotation is required.

SELECT * FROM cypher('graph_name', $$
    RETURN 1.0::numeric
$$) AS (numeric_result agtype);

Sample result:

 numeric_result 
----------------
 1::numeric
(1 row)

Bool

AGE provides the standard Cypher type boolean. The boolean type can have several states: "true", "false", and a third state, "unknown", which is represented by the Agtype null value.

Boolean constants can be represented in Cypher queries by the keywords TRUE, FALSE, and NULL.

Input and output formats

SELECT * FROM cypher('graph_name', $$
    RETURN TRUE
$$) AS (boolean_result agtype);

Unlike PostgreSQL, AGE's boolean outputs as the full word such as true and false, rather than t and f. Sample result:

 boolean_result 
----------------
 true
(1 row)

String

An Agtype string literal can contain the following escape sequences:

Input and output formats

Use single quotes 'to identify a string. The output uses double quotes ".

SELECT * FROM cypher('graph_name', $$
    RETURN 'This is a string'
$$) AS (string_result agtype);

Sample result:

   string_result    
--------------------
 "This is a string"
(1 row)