fix: strip backticks from map literal keys in Cypher queries

Fixed an issue where backticks in map literal keys were being included
in the returned key names instead of being properly stripped. Applied
the fix consistently across all map-related parsing contexts.

Changes:
- Made CypherASTBuilder.stripBackticks() static and package-private
  to allow access from CypherExpressionBuilder
- Updated CypherExpressionBuilder.parseMapLiteralExpression() to strip
  backticks from map keys (RETURN clause map literals)
- Updated CypherExpressionBuilder.parseMapProperties() to strip
  backticks from map keys (pattern properties)
- Updated CypherASTBuilder.visitMap() to strip backticks from map keys
  (CREATE/MERGE clause map literals)
- Updated CypherExpressionBuilder.parseMapProjection() to strip
  backticks from both explicit keys and property names (map projections)
- Added comprehensive test cases in CypherMapBackticksTest to verify:
  - Single backticked key in RETURN (e.g., `@rid`)
  - Multiple backticked keys in RETURN
  - Escaped backticks within keys (e.g., `key``with``backticks`)
  - Backticked keys in CREATE clause
  - Backticked keys in map projections

Example queries that now work correctly:
- RETURN: collect({`@rid`: ID(c), text: c.text})
- CREATE: CREATE (n {`@special`: 'value'})
- Map projection: n{.name, `@id`: n.id}

Before: keys were returned as "`@rid`" (with backticks)
After: keys are returned as "@Rid" (without backticks)

https://claude.ai/code/session_01ATpxvdUh9HNtuBW7x9NmLT

Author: claude

engine/src/main/java/com/arcadedb/query/opencypher/parser/CypherASTBuilder.java

@@ -1074,7 +1074,7 @@ public Map<String, Object> visitMap(final Cypher25Parser.MapContext ctx) {
     final List<Cypher25Parser.ExpressionContext> values = ctx.expression();
 
     for (int i = 0; i < keys.size() && i < values.size(); i++) {
-      final String key = keys.get(i).getText();
+      final String key = stripBackticks(keys.get(i).getText());
       // Parse as Expression
       final Expression expr = expressionBuilder.parseExpression(values.get(i));
 
@@ -1138,7 +1138,7 @@ private List<String> extractLabels(final Cypher25Parser.LabelExpressionContext c
    * @param name the name potentially wrapped in backticks
    * @return the name without backticks
    */
-  private String stripBackticks(final String name) {
+  static String stripBackticks(final String name) {
     if (name == null || name.length() < 2) {
       return name;
     }

engine/src/main/java/com/arcadedb/query/opencypher/parser/CypherExpressionBuilder.java

@@ -1117,7 +1117,7 @@ MapExpression parseMapLiteralExpression(final Cypher25Parser.MapContext ctx) {
     final List<Cypher25Parser.ExpressionContext> values = ctx.expression();
 
     for (int i = 0; i < keys.size() && i < values.size(); i++) {
-      final String key = keys.get(i).getText();
+      final String key = CypherASTBuilder.stripBackticks(keys.get(i).getText());
       final Expression valueExpr = parseExpression(values.get(i));
       entries.put(key, valueExpr);
     }
@@ -1328,7 +1328,7 @@ private Map<String, Object> parseMapProperties(final Cypher25Parser.MapContext c
     final List<Cypher25Parser.ExpressionContext> values = ctx.expression();
 
     for (int i = 0; i < keys.size() && i < values.size(); i++) {
-      final String key = keys.get(i).getText();
+      final String key = CypherASTBuilder.stripBackticks(keys.get(i).getText());
       final Expression expr = parseExpression(values.get(i));
       if (expr instanceof LiteralExpression) {
         map.put(key, ((LiteralExpression) expr).getValue());
@@ -1356,12 +1356,12 @@ MapProjectionExpression parseMapProjection(final Cypher25Parser.MapProjectionCon
     for (final Cypher25Parser.MapProjectionElementContext elemCtx : ctx.mapProjectionElement()) {
       if (elemCtx.propertyKeyName() != null && elemCtx.expression() != null) {
         // key: expression
-        final String key = elemCtx.propertyKeyName().getText();
+        final String key = CypherASTBuilder.stripBackticks(elemCtx.propertyKeyName().getText());
         final Expression expr = parseExpression(elemCtx.expression());
         elements.add(new MapProjectionExpression.ProjectionElement(key, expr));
       } else if (elemCtx.property() != null) {
         // .propertyName
-        final String propName = elemCtx.property().propertyKeyName().getText();
+        final String propName = CypherASTBuilder.stripBackticks(elemCtx.property().propertyKeyName().getText());
         elements.add(new MapProjectionExpression.ProjectionElement(propName));
       } else if (elemCtx.variable() != null) {
         // variable (include another variable's value)

engine/src/test/java/com/arcadedb/query/opencypher/CypherMapBackticksTest.java

@@ -0,0 +1,183 @@
+/*
+ * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.query.opencypher;
+
+import com.arcadedb.database.Database;
+import com.arcadedb.database.DatabaseFactory;
+import com.arcadedb.query.sql.executor.Result;
+import com.arcadedb.query.sql.executor.ResultSet;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Test for map literals with backticked keys.
+ * Ensures that backticks are properly stripped from map keys in RETURN clauses.
+ */
+public class CypherMapBackticksTest {
+  private Database database;
+
+  @BeforeEach
+  void setUp() {
+    database = new DatabaseFactory("./target/databases/testcyphermapbackticks").create();
+    database.getSchema().createVertexType("DOCUMENT");
+    database.getSchema().createVertexType("CHUNK");
+    database.getSchema().createEdgeType("HAS_CHUNK");
+  }
+
+  @AfterEach
+  void tearDown() {
+    if (database != null) {
+      database.drop();
+      database = null;
+    }
+  }
+
+  @Test
+  void testMapLiteralWithBacktickedKeys() {
+    // Create test data
+    database.transaction(() -> {
+      database.command("opencypher",
+        "CREATE (d:DOCUMENT {name: 'Doc1'})-[:HAS_CHUNK]->(c:CHUNK {text: 'Content', llm_flag: true})");
+    });
+
+    // Query with map literal using backticked key (fixed direction to match CREATE)
+    final ResultSet result = database.query("opencypher",
+      "MATCH (d:DOCUMENT)-->(c:CHUNK) WHERE c.llm_flag = true " +
+      "RETURN collect({`@rid`: ID(c), text: c.text}) AS chunks");
+
+    assertThat(result.hasNext()).isTrue();
+    final Result row = result.next();
+    assertThat(row.hasProperty("chunks")).isTrue();
+
+    final List<Map<String, Object>> chunks = (List<Map<String, Object>>) row.getProperty("chunks");
+    assertThat(chunks).isNotEmpty();
+
+    final Map<String, Object> firstChunk = chunks.get(0);
+
+    // The key should be "@rid" without backticks
+    assertThat(firstChunk).containsKey("@rid");
+    assertThat(firstChunk).doesNotContainKey("`@rid`");
+    assertThat(firstChunk).containsKey("text");
+    assertThat(firstChunk.get("text")).isEqualTo("Content");
+  }
+
+  @Test
+  void testMapLiteralWithMultipleBacktickedKeys() {
+    // Create test data
+    database.transaction(() -> {
+      database.command("opencypher",
+        "CREATE (d:DOCUMENT {name: 'Doc1'})-[:HAS_CHUNK]->(c:CHUNK {text: 'Content'})");
+    });
+
+    // Query with multiple backticked keys (fixed direction to match CREATE)
+    final ResultSet result = database.query("opencypher",
+      "MATCH (d:DOCUMENT)-->(c:CHUNK) " +
+      "RETURN {`@rid`: ID(c), `@type`: 'chunk', normalKey: c.text} AS data");
+
+    assertThat(result.hasNext()).isTrue();
+    final Result row = result.next();
+    assertThat(row.hasProperty("data")).isTrue();
+
+    final Map<String, Object> data = (Map<String, Object>) row.getProperty("data");
+
+    // All keys should be without backticks
+    assertThat(data).containsKey("@rid");
+    assertThat(data).doesNotContainKey("`@rid`");
+    assertThat(data).containsKey("@type");
+    assertThat(data).doesNotContainKey("`@type`");
+    assertThat(data).containsKey("normalKey");
+    assertThat(data.get("@type")).isEqualTo("chunk");
+    assertThat(data.get("normalKey")).isEqualTo("Content");
+  }
+
+  @Test
+  void testMapLiteralWithEscapedBackticks() {
+    // Create test data
+    database.transaction(() -> {
+      database.command("opencypher",
+        "CREATE (n:DOCUMENT {name: 'Test'})");
+    });
+
+    // Query with escaped backticks (`` -> `) in key name
+    final ResultSet result = database.query("opencypher",
+      "MATCH (n:DOCUMENT) " +
+      "RETURN {`key``with``backticks`: n.name} AS data");
+
+    assertThat(result.hasNext()).isTrue();
+    final Result row = result.next();
+    assertThat(row.hasProperty("data")).isTrue();
+
+    final Map<String, Object> data = (Map<String, Object>) row.getProperty("data");
+
+    // The key should have single backticks (`` escaped to `)
+    assertThat(data).containsKey("key`with`backticks");
+    assertThat(data.get("key`with`backticks")).isEqualTo("Test");
+  }
+
+  @Test
+  void testCreateWithBacktickedMapKeys() {
+    // Test CREATE clause with backticked keys in map literal
+    database.transaction(() -> {
+      database.command("opencypher",
+        "CREATE (n:DOCUMENT {`@special`: 'value1', normalKey: 'value2'})");
+    });
+
+    // Verify the properties were stored with correct key names (without backticks)
+    final ResultSet result = database.query("opencypher",
+      "MATCH (n:DOCUMENT) RETURN n.`@special` AS special, n.normalKey AS normal");
+
+    assertThat(result.hasNext()).isTrue();
+    final Result row = result.next();
+    assertThat((Object) row.getProperty("special")).isEqualTo("value1");
+    assertThat((Object) row.getProperty("normal")).isEqualTo("value2");
+  }
+
+  @Test
+  void testMapProjectionWithBacktickedKeys() {
+    // Test map projection with backticked keys
+    database.transaction(() -> {
+      database.command("opencypher",
+        "CREATE (n:DOCUMENT {name: 'Doc1', id: 123})");
+    });
+
+    // Query with map projection using backticked key
+    final ResultSet result = database.query("opencypher",
+      "MATCH (n:DOCUMENT) " +
+      "RETURN n{.name, `@id`: n.id} AS data");
+
+    assertThat(result.hasNext()).isTrue();
+    final Result row = result.next();
+    assertThat(row.hasProperty("data")).isTrue();
+
+    final Map<String, Object> data = (Map<String, Object>) row.getProperty("data");
+
+    // The keys should be without backticks
+    assertThat(data).containsKey("name");
+    assertThat(data).containsKey("@id");
+    assertThat(data).doesNotContainKey("`@id`");
+    assertThat(data.get("name")).isEqualTo("Doc1");
+    assertThat(data.get("@id")).isEqualTo(123);
+  }
+}