ISO/IEC 39075:2024 Standard

// Declarative: what to find
MATCH (u:User)-[:FRIEND]->(f:User)
WHERE u.name = 'Alice'
RETURN f.name

// Not imperative: how to find it
// (Query optimizer determines execution plan)

// Pattern syntax mirrors graph structure
(node1)-[relationship]->(node2)

// Example
(alice:Person)-[:KNOWS]->(bob:Person)-[:LIVES_IN]->(city:City)

// Simple patterns compose into complex queries
MATCH (u:User)
WHERE u.age > 25
WITH u, SIZE((u)-[:FRIEND]->()) AS friends
WHERE friends > 10
RETURN u.name, friends
ORDER BY friends DESC
LIMIT 10

// Node pattern
(variable:Label1:Label2 {prop1: value1, prop2: value2})

// Relationship pattern
-[variable:TYPE1|TYPE2 {prop: value}]->

// Path pattern
path = (a)-[:KNOWS*1..3]-(b)

// Shortest path
path = SHORTEST (a)-[:KNOWS*]-(b)

// CREATE
CREATE (n:Label {property: value})

// DELETE
DELETE n
DETACH DELETE n

// SET
SET n.property = value
SET n:Label

// REMOVE
REMOVE n.property
REMOVE n:Label

// MERGE
MERGE (n:Label {key: value})
ON CREATE SET n.created = NOW()
ON MATCH SET n.updated = NOW()

// MATCH - pattern matching
MATCH (n:Label)

// OPTIONAL MATCH - optional patterns
OPTIONAL MATCH (n)-[:REL]->(m)

// WHERE - filtering
WHERE condition

// WITH - pipeline processing
WITH expression AS alias

// RETURN - result projection
RETURN expression AS alias

// ORDER BY - sorting
ORDER BY expression ASC|DESC

// LIMIT/OFFSET - pagination
LIMIT count OFFSET skip

// UNION - combine results
query1 UNION query2

CREATE INDEX FOR (n:Label) ON (n.property)
CREATE INDEX index_name FOR (n:Label) ON (n.prop1, n.prop2)
DROP INDEX index_name
SHOW INDEXES

CREATE CONSTRAINT ON (n:Label) ASSERT n.property IS UNIQUE
CREATE CONSTRAINT ON (n:Label) ASSERT EXISTS(n.property)
DROP CONSTRAINT constraint_name
SHOW CONSTRAINTS

BEGIN TRANSACTION
  // statements
COMMIT

// Or
ROLLBACK

// Savepoints
SAVEPOINT savepoint_name
ROLLBACK TO SAVEPOINT savepoint_name

{
  "code": "42000",
  "message": "Syntax error: unexpected token",
  "position": 12,
  "sqlstate": "42000"
}

<graph_pattern> ::=
    <node_pattern> [ <relationship_pattern> <node_pattern> ]*

<node_pattern> ::=
    '(' [ <variable> ] [ <label_expression> ] [ <property_specification> ] ')'

<label_expression> ::=
    ':' <label_name> [ ':' <label_name> ]*

<property_specification> ::=
    '{' <property> [ ',' <property> ]* '}'

<property> ::=
    <property_name> ':' <expression>

<relationship_pattern> ::=
    '-' '[' [ <variable> ] [ <type_expression> ] [ <property_specification> ] ']' '->'
    | '<-' '[' [ <variable> ] [ <type_expression> ] [ <property_specification> ] ']' '-'
    | '-' '[' [ <variable> ] [ <type_expression> ] [ <property_specification> ] ']' '-'

<type_expression> ::=
    ':' <type_name> [ '|' <type_name> ]*

<variable_length> ::=
    '*' [ <min_hops> ] [ '..' [ <max_hops> ] ]

Type System Hierarchy
=====================

Value Types:
├── NULL
├── Scalar Types
│   ├── Boolean
│   ├── Numeric
│   │   ├── Integer (64-bit signed)
│   │   ├── Float (IEEE 754 double)
│   │   └── Decimal (arbitrary precision)
│   ├── String (UTF-8)
│   └── Bytes
├── Temporal Types
│   ├── Date (ISO 8601)
│   ├── Time (with timezone)
│   ├── DateTime (ISO 8601 with timezone)
│   └── Duration (ISO 8601 duration)
├── Spatial Types
│   └── Point (2D/3D with CRS)
├── Collection Types
│   ├── List [ordered, allows duplicates]
│   ├── Set [unordered, no duplicates]
│   └── Map {key: value pairs}
└── Graph Types
    ├── Node (entity reference)
    ├── Relationship (edge reference)
    └── Path (node-relationship sequence)

-- String Functions (§11.3)
FUNCTION substring(
    str: STRING,
    start: INTEGER,
    length: INTEGER?
) RETURNS STRING

-- Behavior:
-- - start is 0-indexed
-- - length is optional (defaults to end of string)
-- - Returns empty string if start > string length
-- - NULL propagation: NULL input → NULL output

MATCH (p:Person)
RETURN substring(p.name, 0, 3) AS initials;

-- Mathematical Functions (§11.5)
FUNCTION round(
    value: NUMERIC,
    precision: INTEGER DEFAULT 0
) RETURNS NUMERIC

-- Behavior:
-- - Rounds to nearest integer by default
-- - precision > 0: decimal places
-- - precision < 0: rounds before decimal point
-- - Banker's rounding (round half to even)

MATCH (p:Product)
RETURN round(p.price, 2) AS rounded_price;

-- Aggregation Functions (§11.7)
FUNCTION count(
    expression: ANY
) RETURNS INTEGER

-- Behavior:
-- - count(*): counts all rows including NULL
-- - count(expr): counts non-NULL values
-- - DISTINCT optional: count(DISTINCT expr)

MATCH (u:User)
RETURN count(u) AS total_users,
       count(u.email) AS users_with_email,
       count(DISTINCT u.country) AS unique_countries;

-- Organizational hierarchy traversal
WITH RECURSIVE hierarchy AS (
    -- Base case
    MATCH (emp:Employee {id: $start_id})
    RETURN emp, 0 AS level

    UNION ALL

    -- Recursive case
    MATCH (h.emp)-[:REPORTS_TO]->(manager:Employee)
    FROM hierarchy h
    WHERE h.level < $max_depth
    RETURN manager AS emp, h.level + 1 AS level
)
SELECT emp.name, level
FROM hierarchy
ORDER BY level, emp.name;

-- Running totals and moving averages
MATCH (sale:Sale)
WHERE sale.date >= date('2025-01-01')
RETURN sale.date,
       sale.amount,
       sum(sale.amount) OVER (
           ORDER BY sale.date
           ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
       ) AS running_total,
       avg(sale.amount) OVER (
           ORDER BY sale.date
           ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
       ) AS moving_avg_7day
ORDER BY sale.date;

-- Ranking functions
MATCH (product:Product)
RETURN product.name,
       product.sales,
       rank() OVER (ORDER BY product.sales DESC) AS sales_rank,
       dense_rank() OVER (
           PARTITION BY product.category
           ORDER BY product.sales DESC
       ) AS category_rank,
       percent_rank() OVER (ORDER BY product.sales) AS percentile;

-- Multi-step query with CTEs
WITH active_users AS (
    MATCH (u:User)
    WHERE u.last_login >= datetime() - duration('P30D')
    RETURN u
),
power_users AS (
    MATCH (u:User)-[:PURCHASED]->(p:Product)
    WITH u, count(p) AS purchase_count
    WHERE purchase_count > 10
    RETURN u
),
targeted_segment AS (
    SELECT *
    FROM active_users
    INTERSECT
    SELECT *
    FROM power_users
)
MATCH (u:User)
WHERE u IN targeted_segment
RETURN u.email, u.name
ORDER BY u.last_login DESC;

class ProductionComplianceMonitor:
    """Monitor ISO compliance in production environment."""

    def __init__(self, client):
        self.client = client
        self.violations = []

    async def monitor_query_compliance(self, query, params):
        """Check if query follows ISO standards."""

        violations = []

        # Check 1: Use of vendor-specific syntax
        vendor_patterns = [
            r'CALL apoc\.',
            r'CALL gds\.',
            r'CREATE FULLTEXT INDEX',  # Vendor extension
        ]

        for pattern in vendor_patterns:
            if re.search(pattern, query, re.IGNORECASE):
                violations.append({
                    'type': 'vendor_syntax',
                    'pattern': pattern,
                    'message': 'Query uses vendor-specific syntax'
                })

        # Check 2: Parameter usage (should use $param, not string concat)
        if any(f"'{param}'" in query or f'"{param}"' in query for param in params):
            violations.append({
                'type': 'sql_injection_risk',
                'message': 'Parameters embedded in query string'
            })

        # Check 3: ISO-compliant NULL handling
        if re.search(r'= NULL|!= NULL', query):
            violations.append({
                'type': 'incorrect_null_handling',
                'message': 'Should use IS NULL/IS NOT NULL'
            })

        if violations:
            self.violations.extend(violations)
            logger.warning(f"ISO compliance violations detected: {violations}")

        return len(violations) == 0

    async def generate_compliance_report(self):
        """Generate production compliance report."""

        report = {
            'total_queries': len(self.violations) + 1000,  # Example
            'violations': len(self.violations),
            'compliance_rate': 1.0 - (len(self.violations) / 1000),
            'violation_types': {}
        }

        for violation in self.violations:
            vtype = violation['type']
            report['violation_types'][vtype] = \
                report['violation_types'].get(vtype, 0) + 1

        return report

# Usage in production
monitor = ProductionComplianceMonitor(client)

@app.middleware("http")
async def check_query_compliance(request, call_next):
    """Middleware to monitor query compliance."""
    if hasattr(request.state, 'query'):
        await monitor.monitor_query_compliance(
            request.state.query,
            request.state.params
        )

    response = await call_next(request)
    return response

class LegacyToISOConverter:
    """Convert legacy graph queries to ISO GQL."""

    def __init__(self):
        self.conversions = {}
        self.warnings = []

    def convert_neo4j_cypher(self, cypher_query):
        """Convert Neo4j Cypher to ISO GQL."""

        iso_query = cypher_query

        # Conversion 1: DETACH DELETE → DELETE
        iso_query = re.sub(
            r'\bDETACH DELETE\b',
            'DELETE',
            iso_query,
            flags=re.IGNORECASE
        )

        # Conversion 2: exists(n.prop) → n.prop IS NOT NULL
        iso_query = re.sub(
            r'\bexists\s*\(\s*(\w+)\.(\w+)\s*\)',
            r'\1.\2 IS NOT NULL',
            iso_query
        )

        # Conversion 3: APOC functions (warn - no direct equivalent)
        if re.search(r'\bapoc\.', iso_query, re.IGNORECASE):
            self.warnings.append({
                'type': 'unsupported_function',
                'message': 'APOC functions have no ISO equivalent',
                'suggestion': 'Implement logic in application code'
            })

        # Conversion 4: Variable-length path syntax
        iso_query = re.sub(
            r'-\[(\w+):(\w+)\*(\d+)\.\.(\d+)\]->',
            r'-[\1:\2*\3..\4]->',
            iso_query
        )

        return iso_query, self.warnings

    def convert_gremlin(self, gremlin_query):
        """Convert Apache Gremlin to ISO GQL."""

        # This is more complex due to imperative nature of Gremlin
        # Simplified example:

        patterns = {
            r"g\.V\(\)\.hasLabel\('(\w+)'\)": r"MATCH (n:\1)",
            r"\.has\('(\w+)',\s*'([^']+)'\)": r"WHERE \1 = '\2'",
            r"\.values\('(\w+)'\)": r"RETURN \1",
        }

        iso_query = gremlin_query
        for gremlin_pattern, gql_pattern in patterns.items():
            iso_query = re.sub(gremlin_pattern, gql_pattern, iso_query)

        return iso_query

# Usage
converter = LegacyToISOConverter()

cypher_query = """
    MATCH (n:Person)
    WHERE exists(n.email)
    DETACH DELETE n
"""

iso_query, warnings = converter.convert_neo4j_cypher(cypher_query)
print(iso_query)
# Output:
# MATCH (n:Person)
# WHERE n.email IS NOT NULL
# DELETE n

for warning in warnings:
    print(f"Warning: {warning['message']}")

-- Temporal graph queries (proposed for ISO amendment)
MATCH (p:Person)
FOR SYSTEM_TIME AS OF '2025-01-01T00:00:00Z'
WHERE p.status = 'active'
RETURN p.name;

-- Graph pattern matching with quantification
MATCH (user:User)
WHERE ALL x IN (user)-[:PURCHASED]->(products) SATISFIES (x.rating >= 4)
RETURN user.name;

-- Multi-graph queries
MATCH (p:Product) IN GRAPH production_graph,
      (s:Sale) IN GRAPH analytics_graph
WHERE s.product_id = p.id
RETURN p.name, sum(s.amount) AS total_sales;

class ISOStandardsTracker:
    """Track and notify about ISO GQL standard updates."""

    def __init__(self):
        self.subscription_endpoint = "https://www.iso.org/committee/45342/x/feed"
        self.last_check = None

    async def check_for_updates(self):
        """Check ISO working group for updates."""

        feed = await self.fetch_rss_feed(self.subscription_endpoint)
        updates = []

        for entry in feed.entries:
            if entry.published > self.last_check:
                updates.append({
                    'title': entry.title,
                    'link': entry.link,
                    'published': entry.published,
                    'summary': entry.summary
                })

        self.last_check = datetime.now()
        return updates

    async def notify_team(self, updates):
        """Notify development team of standard updates."""
        if not updates:
            return

        message = "ISO/IEC 39075 Updates:\n\n"
        for update in updates:
            message += f"• {update['title']}\n"
            message += f"  {update['link']}\n\n"

        await send_slack_notification(channel="#standards", message=message)

# Scheduled task
async def monitor_iso_standards():
    tracker = ISOStandardsTracker()

    while True:
        updates = await tracker.check_for_updates()
        if updates:
            await tracker.notify_team(updates)

        await asyncio.sleep(86400)  # Daily check