ArcadeDB Manual

docker run --rm -p 2424:2424 -p 2480:2480 -p 5432:5432 \
    --name arcadedb arcadedata/arcadedb:26.3.1

<repositories>
  <repository>
    <id>github</id>
    <url>https://maven.pkg.github.com/ArcadeData/arcadedb</url>
    <snapshots>
      <enabled>true</enabled>
    </snapshots>
  </repository>
</repositories>

<dependency>
    <groupId>com.arcadedb</groupId>
    <artifactId>arcadedb-server</artifactId>
    <version>26.3.1-java17</version>
</dependency>

ContextConfiguration config = new ContextConfiguration();
ArcadeDBServer server = new ArcadeDBServer(config);
server.start();

config.setValue(GlobalConfiguration.HA_SERVER_LIST, "192.168.10.1,192.168.10.2,192.168.10.3");
config.setValue(GlobalConfiguration.HA_REPLICATION_INCOMING_HOST, "0.0.0.0");
config.setValue(GlobalConfiguration.HA_ENABLED, true);

Database database = server.getDatabase(<URL>);

Database database = server.getOrCreateDatabase(<URL>);

package com.yourpackage;

public class MyTest implements ServerPlugin {
  // ...

  @Override
  public void registerAPI(HttpServer httpServer, final PathHandler routes) {
    routes.addPrefixPath("/myapi",//
      Handlers.routing()//
        .get("/account/{id}", new RetieveeAccount(this))// YOU CAN ADD YOUR HANDLERS UNDER THE SAME PREFIX PATH
        .post("/test/{name}", new MyTestAPI(this))//
    );
  }
}

public class MyTestAPI extends DatabaseAbstractHandler {

  public MyTestAPI(final HttpServer httpServer) {
    super(httpServer);
  }

  @Override
  public void execute(final HttpServerExchange exchange, ServerSecurityUser user, final Database database) throws IOException {
    final Deque<String> namePar = exchange.getQueryParameters().get("name");
    if (namePar == null || namePar.isEmpty()) {
      exchange.setStatusCode(400);
      exchange.getResponseSender().send("{ \"error\" : \"name is null\"}");
      return;
    }

    final String name = namePar.getFirst();

    // DO SOMETHING MEANINGFUL HERE
    // ...

    exchange.setStatusCode(204);
    exchange.getResponseSender().send("");
  }
}

$ java ... -Darcadedb.server.plugins=MyPlugin:com.yourpackage.MyPlugin ...

configuration.setValue(GlobalConfiguration.NETWORK_USE_SSL, true);
configuration.setValue(GlobalConfiguration.NETWORK_SSL_KEYSTORE, "src/test/resources/master.jks");
configuration.setValue(GlobalConfiguration.NETWORK_SSL_KEYSTORE_PASSWORD, "keypassword");
configuration.setValue(GlobalConfiguration.NETWORK_SSL_TRUSTSTORE, "src/test/resources/master.jks");
configuration.setValue(GlobalConfiguration.NETWORK_SSL_TRUSTSTORE_PASSWORD, "storepassword");

GlobalConfiguration.SERVER_HTTPS_INCOMING_PORT

DatabaseFactory databaseFactory = new DatabaseFactory("/databases/mydb");
try( Database db = databaseFactory.create(); ){
  // YOUR CODE
}

DatabaseFactory databaseFactory = new DatabaseFactory("/databases/mydb");
try( Database db = databaseFactory.open(); ){
  // YOUR CODE
}

databaseFactory.open(PaginatedFile.MODE.READ_ONLY);

try( Database db = databaseFactory.open(); ){
  db.transaction( (tx) -> {
    // YOUR CODE HERE
  });
}

Database db = databaseFactory.open();
try {
  db.begin();

  // YOUR CHANGES HERE

  db.commit();

} catch (Exception e) {
  db.rollback();
} finally {
  db.close();
}

try( Database db = databaseFactory.open(); ){
  db.transaction( () -> {
    // CREATE THE CUSTOMER TYPE
    db.getSchema().createDocumentType("Customer");
  });
}

try( Database db = databaseFactory.open(); ){
  db.transaction( () -> {
    // CREATE A CUSTOMER INSTANCE
    MutableDocument customer = db.newDocument("Customer");
    customer.set("name", "Jay");
    customer.set("surname", "Miner");
    customer.save(); // THE DOCUMENT IS SAVED IN THE DATABASE ONLY WHEN `.save()` IS CALLED
  });
}

try( Database db = databaseFactory.open(); ){
  db.transaction( () -> {
    ResultSet result = db.query("SQL", "select from V where age > ? and city = ?", 18, "Melbourne");
    while (result.hasNext()) {
      Result record = result.next();
      System.out.println( "Found record, name = " + record.getProperty("name"));
    }
  });
}

try( Database db = databaseFactory.open(); ){
  db.transaction( () -> {
    Map<String,Object> parameters = new HashMap<>();
    parameters.put( "age", 18 );
    parameters.put( "city", "Melbourne" );

    ResultSet result = db.query("SQL", "select from V where age > :age and city = :city", parameters);
    while (result.hasNext()) {
      Result record = result.next();
      System.out.println( "Found record, name = " + record.getProperty("name"));
    }
  });
}

try( Database db = databaseFactory.open(); ){
  db.transaction( () -> {
    // CREATE THE ACCOUNT TYPE
    db.getSchema().createVertexType("User");
    db.getSchema().createEdgeType("IsFriendOf");
  });
}

try( Database db = databaseFactory.open(); ){
  db.transaction( () -> {
    MutableVertex albert = db.newVertex("User").set("name", "Albert").set("lastName", "Einstein").save();
    MutableVertex michelle = db.newVertex("User").set("name", "Michelle").set("lastName", "Besso").save();
    albert.newEdge("IsFriendOf", michelle, true, "since", 2010);
  });
}

pip install "psycopg[binary]>=3.1,<4"

import psycopg

conn = psycopg.connect(
    host='localhost',
    port=5432,
    dbname='mydb',
    user='root',
    password='arcadedb',
    autocommit=True,
)
print('Connected to ArcadeDB')

with conn.cursor() as cur:
    # Create vertex types
    cur.execute("CREATE VERTEX TYPE Person IF NOT EXISTS")
    cur.execute("CREATE VERTEX TYPE Movie IF NOT EXISTS")

    # Create edge type
    cur.execute("CREATE EDGE TYPE Acted IF NOT EXISTS")

    # Insert data
    cur.execute("CREATE VERTEX Person SET name = 'Alice', age = 30")
    cur.execute("CREATE VERTEX Person SET name = 'Bob', age = 25")
    cur.execute("CREATE VERTEX Movie SET title = 'The Matrix', year = 1999")
    cur.execute("""
        CREATE EDGE Acted FROM (SELECT FROM Person WHERE name = 'Alice')
                           TO (SELECT FROM Movie WHERE title = 'The Matrix')
                           SET role = 'Trinity'
    """)

with conn.cursor() as cur:
    cur.execute("""
        SELECT person.name, movie.title, acted.role
        FROM MATCH {type: Person, as: person}
             -Acted-> {type: Movie, as: movie}
    """)
    for row in cur.fetchall():
        print(f'{row[0]} acted in {row[1]} as {row[2]}')

with conn.cursor() as cur:
    cur.execute("{cypher} MATCH (p:Person)-[a:Acted]->(m:Movie) RETURN p.name, m.title, a.role")
    for row in cur.fetchall():
        print(f'{row[0]} acted in {row[1]} as {row[2]}')

with conn.cursor() as cur:
    # Create a type with a vector property
    cur.execute("CREATE VERTEX TYPE Product IF NOT EXISTS")
    cur.execute("CREATE PROPERTY Product.embedding IF NOT EXISTS LIST")
    cur.execute("CREATE INDEX ON Product (embedding) VECTOR (4, COSINE, LSM_VECTOR)")

    # Insert products with embeddings
    cur.execute("CREATE VERTEX Product SET name = 'Laptop', embedding = [0.9, 0.1, 0.8, 0.2]")
    cur.execute("CREATE VERTEX Product SET name = 'Tablet', embedding = [0.8, 0.2, 0.7, 0.3]")
    cur.execute("CREATE VERTEX Product SET name = 'Phone',  embedding = [0.7, 0.3, 0.6, 0.4]")
    cur.execute("CREATE VERTEX Product SET name = 'Book',   embedding = [0.1, 0.9, 0.2, 0.8]")

    # Find the 3 most similar products to a query vector
    cur.execute("""
        SELECT name, distance FROM (
            SELECT expand(vectorNeighbors('Product[embedding]', [0.85, 0.15, 0.75, 0.25], 3))
        )
    """)
    print('Similar products:')
    for row in cur.fetchall():
        print(f'  {row[0]}')

#!/usr/bin/env python3
"""ArcadeDB Python quickstart -- graph + vector search."""

import psycopg

def main():
    conn = psycopg.connect(
        host='localhost', port=5432, dbname='mydb',
        user='root', password='arcadedb', autocommit=True,
    )

    with conn.cursor() as cur:
        # Create schema
        cur.execute("CREATE VERTEX TYPE Person IF NOT EXISTS")
        cur.execute("CREATE VERTEX TYPE Movie IF NOT EXISTS")
        cur.execute("CREATE EDGE TYPE Acted IF NOT EXISTS")

        # Insert data
        cur.execute("CREATE VERTEX Person SET name = 'Alice', age = 30")
        cur.execute("CREATE VERTEX Movie SET title = 'The Matrix', year = 1999")
        cur.execute("""
            CREATE EDGE Acted FROM (SELECT FROM Person WHERE name = 'Alice')
                               TO (SELECT FROM Movie WHERE title = 'The Matrix')
                               SET role = 'Trinity'
        """)

        # Query with SQL MATCH
        cur.execute("""
            SELECT person.name, movie.title, acted.role
            FROM MATCH {type: Person, as: person}
                 -Acted-> {type: Movie, as: movie}
        """)
        for row in cur.fetchall():
            print(f'{row[0]} acted in {row[1]} as {row[2]}')

    conn.close()

if __name__ == '__main__':
    main()

npm install pg

const { Client } = require('pg');

const client = new Client({
  host: 'localhost',
  port: 5432,
  database: 'mydb',
  user: 'root',
  password: 'arcadedb',
});

await client.connect();
console.log('Connected to ArcadeDB');

// Create vertex types
await client.query('CREATE VERTEX TYPE Person IF NOT EXISTS');
await client.query('CREATE VERTEX TYPE Movie IF NOT EXISTS');

// Create edge type
await client.query('CREATE EDGE TYPE Acted IF NOT EXISTS');

// Insert data
await client.query("CREATE VERTEX Person SET name = 'Alice', age = 30");
await client.query("CREATE VERTEX Person SET name = 'Bob', age = 25");
await client.query("CREATE VERTEX Movie SET title = 'The Matrix', year = 1999");
await client.query(`
  CREATE EDGE Acted FROM (SELECT FROM Person WHERE name = 'Alice')
                     TO (SELECT FROM Movie WHERE title = 'The Matrix')
                     SET role = 'Trinity'
`);

const result = await client.query(`
  SELECT person.name, movie.title, acted.role
  FROM MATCH {type: Person, as: person}
       -Acted-> {type: Movie, as: movie}
`);

for (const row of result.rows) {
  console.log(`${row.name} acted in ${row.title} as ${row.role}`);
}

const result = await client.query(
  '{cypher} MATCH (p:Person)-[a:Acted]->(m:Movie) RETURN p.name, m.title, a.role'
);

for (const row of result.rows) {
  console.log(`${row['p.name']} acted in ${row['m.title']} as ${row['a.role']}`);
}

// Create a type with a vector property
await client.query('CREATE VERTEX TYPE Product IF NOT EXISTS');
await client.query('CREATE PROPERTY Product.embedding IF NOT EXISTS LIST');
await client.query('CREATE INDEX ON Product (embedding) VECTOR (4, COSINE, LSM_VECTOR)');

// Insert products with embeddings
await client.query("CREATE VERTEX Product SET name = 'Laptop', embedding = [0.9, 0.1, 0.8, 0.2]");
await client.query("CREATE VERTEX Product SET name = 'Tablet', embedding = [0.8, 0.2, 0.7, 0.3]");
await client.query("CREATE VERTEX Product SET name = 'Phone',  embedding = [0.7, 0.3, 0.6, 0.4]");
await client.query("CREATE VERTEX Product SET name = 'Book',   embedding = [0.1, 0.9, 0.2, 0.8]");

// Find the 3 most similar products to a query vector
const similar = await client.query(`
  SELECT name, distance FROM (
    SELECT expand(vectorNeighbors('Product[embedding]', [0.85, 0.15, 0.75, 0.25], 3))
  )
`);
console.log('Similar products:');
for (const row of similar.rows) {
  console.log(`  ${row.name}`);
}

#!/usr/bin/env node
/**
 * ArcadeDB JavaScript quickstart -- graph + vector search.
 */

const { Client } = require('pg');

async function main() {
  const client = new Client({
    host: 'localhost', port: 5432, database: 'mydb',
    user: 'root', password: 'arcadedb',
  });
  await client.connect();

  // Create schema
  await client.query('CREATE VERTEX TYPE Person IF NOT EXISTS');
  await client.query('CREATE VERTEX TYPE Movie IF NOT EXISTS');
  await client.query('CREATE EDGE TYPE Acted IF NOT EXISTS');

  // Insert data
  await client.query("CREATE VERTEX Person SET name = 'Alice', age = 30");
  await client.query("CREATE VERTEX Movie SET title = 'The Matrix', year = 1999");
  await client.query(`
    CREATE EDGE Acted FROM (SELECT FROM Person WHERE name = 'Alice')
                       TO (SELECT FROM Movie WHERE title = 'The Matrix')
                       SET role = 'Trinity'
  `);

  // Query with SQL MATCH
  const result = await client.query(`
    SELECT person.name, movie.title, acted.role
    FROM MATCH {type: Person, as: person}
         -Acted-> {type: Movie, as: movie}
  `);
  for (const row of result.rows) {
    console.log(`${row.name} acted in ${row.title} as ${row.role}`);
  }

  await client.end();
}

main().catch(console.error);

CREATE VERTEX TYPE Product
CREATE PROPERTY Product.name STRING
CREATE PROPERTY Product.category STRING
CREATE PROPERTY Product.embedding LIST OF FLOAT

CREATE INDEX ON Product (embedding) LSM_VECTOR METADATA {
  dimensions: 4,
  similarity: 'COSINE'
}

CREATE VERTEX Product SET name = 'Laptop',       category = 'Electronics', embedding = [0.9, 0.1, 0.8, 0.2]
CREATE VERTEX Product SET name = 'Tablet',        category = 'Electronics', embedding = [0.85, 0.15, 0.75, 0.25]
CREATE VERTEX Product SET name = 'Smartphone',    category = 'Electronics', embedding = [0.8, 0.2, 0.7, 0.3]
CREATE VERTEX Product SET name = 'Headphones',    category = 'Electronics', embedding = [0.6, 0.4, 0.5, 0.5]
CREATE VERTEX Product SET name = 'Novel',         category = 'Books',       embedding = [0.1, 0.9, 0.2, 0.8]
CREATE VERTEX Product SET name = 'Textbook',      category = 'Books',       embedding = [0.2, 0.8, 0.3, 0.7]
CREATE VERTEX Product SET name = 'Running Shoes', category = 'Sports',      embedding = [0.3, 0.5, 0.9, 0.1]
CREATE VERTEX Product SET name = 'Yoga Mat',      category = 'Sports',      embedding = [0.25, 0.55, 0.85, 0.15]

SELECT name, category, distance FROM (
  SELECT expand(vectorNeighbors('Product[embedding]', [0.88, 0.12, 0.78, 0.22], 3))
)

CREATE EDGE TYPE FREQUENTLY_BOUGHT_WITH
CREATE EDGE TYPE SIMILAR_TO

CREATE EDGE FREQUENTLY_BOUGHT_WITH
  FROM (SELECT FROM Product WHERE name = 'Laptop')
  TO (SELECT FROM Product WHERE name = 'Headphones')

CREATE EDGE SIMILAR_TO
  FROM (SELECT FROM Product WHERE name = 'Laptop')
  TO (SELECT FROM Product WHERE name = 'Tablet')

CREATE EDGE FREQUENTLY_BOUGHT_WITH
  FROM (SELECT FROM Product WHERE name = 'Novel')
  TO (SELECT FROM Product WHERE name = 'Textbook')

-- Step 1: Find top 3 by vector similarity
SELECT name, category, distance FROM (
  SELECT expand(vectorNeighbors('Product[embedding]', [0.88, 0.12, 0.78, 0.22], 3))
)

-- Step 2: Get products frequently bought with the top match
SELECT friend.name, friend.category
FROM MATCH {type: Product, as: product, where: (name = 'Laptop')}
     -FREQUENTLY_BOUGHT_WITH-> {type: Product, as: friend}

-- Euclidean distance (absolute distance in vector space)
CREATE PROPERTY Product.embedding_l2 LIST OF FLOAT
CREATE INDEX ON Product (embedding_l2) LSM_VECTOR METADATA {
  dimensions: 4,
  similarity: 'EUCLIDEAN'
}

-- Dot product (fastest for normalized vectors)
CREATE PROPERTY Product.embedding_dot LIST OF FLOAT
CREATE INDEX ON Product (embedding_dot) LSM_VECTOR METADATA {
  dimensions: 4,
  similarity: 'DOT_PRODUCT'
}

-- Higher efSearch for better recall (useful for critical queries)
SELECT name, category, distance FROM (
  SELECT expand(vectorNeighbors('Product[embedding]', [0.88, 0.12, 0.78, 0.22], 3, 200))
)

CREATE VERTEX TYPE LargeProduct
CREATE PROPERTY LargeProduct.embedding ARRAY_OF_FLOATS

CREATE INDEX ON LargeProduct (embedding) LSM_VECTOR METADATA {
  dimensions: 384,
  similarity: 'COSINE',
  quantization: 'INT8'
}

SELECT name, distance FROM (
  SELECT expand(vectorNeighbors('LargeProduct[embedding]', $queryVector, 10))
)

CREATE TIMESERIES TYPE SensorReading
  TIMESTAMP ts PRECISION MILLISECOND
  TAGS (sensor_id STRING, location STRING)
  FIELDS (
    temperature DOUBLE,
    humidity DOUBLE,
    pressure DOUBLE
  )
  SHARDS 4

curl -X POST "http://localhost:2480/api/v1/ts/mydb/write?precision=ms" \
  -u root:arcadedb \
  -H "Content-Type: text/plain" \
  --data-binary '
SensorReading,sensor_id=sensor-A,location=floor-1 temperature=22.5,humidity=65.0,pressure=1013.2 1708430400000
SensorReading,sensor_id=sensor-A,location=floor-1 temperature=22.7,humidity=64.5,pressure=1013.1 1708430460000
SensorReading,sensor_id=sensor-A,location=floor-1 temperature=23.1,humidity=63.0,pressure=1013.0 1708430520000
SensorReading,sensor_id=sensor-B,location=floor-2 temperature=19.8,humidity=70.0,pressure=1012.5 1708430400000
SensorReading,sensor_id=sensor-B,location=floor-2 temperature=19.5,humidity=71.0,pressure=1012.6 1708430460000
SensorReading,sensor_id=sensor-B,location=floor-2 temperature=19.2,humidity=72.0,pressure=1012.7 1708430520000
'

INSERT INTO SensorReading
  (ts, sensor_id, location, temperature, humidity, pressure)
  VALUES
    ('2026-02-20T10:10:00Z', 'sensor-A', 'floor-1', 23.5, 62.0, 1012.9),
    ('2026-02-20T10:10:00Z', 'sensor-B', 'floor-2', 19.0, 73.0, 1012.8)

SELECT ts, sensor_id, temperature, humidity
FROM SensorReading
WHERE ts BETWEEN '2026-02-20T10:00:00Z' AND '2026-02-20T11:00:00Z'
  AND sensor_id = 'sensor-A'
ORDER BY ts

SELECT ts.timeBucket('1h', ts) AS hour,
       sensor_id,
       avg(temperature) AS avg_temp,
       max(temperature) AS max_temp,
       min(temperature) AS min_temp,
       count(*) AS samples
FROM SensorReading
WHERE ts BETWEEN '2026-02-20' AND '2026-02-21'
GROUP BY hour, sensor_id
ORDER BY hour

-- Rate of change per minute
SELECT ts.timeBucket('5m', ts) AS window,
       sensor_id,
       ts.rate(temperature, ts) AS temp_change_per_sec
FROM SensorReading
GROUP BY window, sensor_id

-- 99th percentile temperature per hour
SELECT ts.timeBucket('1h', ts) AS hour,
       ts.percentile(temperature, 0.99) AS p99_temp
FROM SensorReading
GROUP BY hour

SELECT ts.timeBucket('1m', ts) AS minute,
       ts.interpolate(temperature, 'linear', ts) AS temp
FROM SensorReading
WHERE sensor_id = 'sensor-A'
  AND ts BETWEEN '2026-02-20T10:00:00Z' AND '2026-02-20T11:00:00Z'
GROUP BY minute

# Instant query
curl "http://localhost:2480/ts/mydb/prom/api/v1/query?query=avg(SensorReading{sensor_id='sensor-A'})" \
  -u root:arcadedb

# Range query with rate calculation
curl "http://localhost:2480/ts/mydb/prom/api/v1/query_range?\
query=rate(SensorReading{sensor_id='sensor-A'}[5m])&\
start=1708430400&end=1708434000&step=60" \
  -u root:arcadedb

RETURN promql('avg(SensorReading{sensor_id="sensor-A"})')

CREATE CONTINUOUS AGGREGATE hourly_temps AS
  SELECT ts.timeBucket('1h', ts) AS hour,
         sensor_id,
         avg(temperature) AS avg_temp,
         max(temperature) AS max_temp,
         count(*) AS cnt
  FROM SensorReading
  GROUP BY hour, sensor_id

SELECT * FROM hourly_temps ORDER BY hour DESC LIMIT 10

ALTER TIMESERIES TYPE SensorReading
  ADD DOWNSAMPLING POLICY
    AFTER 7 DAYS GRANULARITY 1 MINUTES
    AFTER 30 DAYS GRANULARITY 1 HOURS

MATCH (u:User)-[:PURCHASED]->(p:Product)<-[:PURCHASED]-(other:User)-[:PURCHASED]->(rec:Product)
WHERE u.name = 'Alice' AND NOT (u)-[:PURCHASED]->(rec)
RETURN rec.name, count(other) AS score ORDER BY score DESC

SELECT name, category, distance FROM (
  SELECT expand(vectorNeighbors('Product[embedding]', [0.9, 0.1, 0.8, 0.2], 5))
) ORDER BY distance

SELECT productId, SUM(purchaseCount) AS total
FROM ProductInteraction
WHERE timestamp > date('2024-01-14', 'yyyy-MM-dd')
GROUP BY productId ORDER BY total DESC

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/recommendation-engine
docker compose up -d
./setup.sh
./queries/queries.sh

MATCH (r:Researcher)-[:CO_AUTHORED]->(p:Paper)<-[:CO_AUTHORED]-(coauthor:Researcher)
WHERE r.name = 'Dr. Smith'
RETURN coauthor.name, collect(p.title) AS papers

SELECT title, year, distance FROM (
  SELECT expand(vectorNeighbors('Paper[embedding]', [0.8, 0.3, 0.7, 0.1], 5))
) ORDER BY distance

SELECT title, abstract FROM Paper
WHERE SEARCH_INDEX('Paper[abstract]', 'machine learning graph')

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/knowledge-graphs
docker compose up -d
./setup.sh
./queries/queries.sh

SELECT content, source, distance FROM (
  SELECT expand(vectorNeighbors('Chunk[embedding]', [0.9, 0.1, 0.8, 0.2], 5))
)

MATCH (c:Chunk)-[:MENTIONS]->(e:Entity)-[:RELATES_TO*1..2]-(related:Entity)<-[:MENTIONS]-(other:Chunk)
WHERE c.source = 'quantum_computing.txt'
RETURN related.name, other.content, other.source

SELECT content, source,
  (1.0 / (1.0 + distance)) * 0.7 + (entityCount / 5.0) * 0.3 AS compositeScore
FROM ChunkScores ORDER BY compositeScore DESC

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/graph-rag
docker compose up -d
./setup.sh
./queries/queries.sh

MATCH (a1:Account)-[:USES_DEVICE]->(d:Device)<-[:USES_DEVICE]-(a2:Account)
WHERE a1 <> a2
RETURN a1.name, a2.name, d.deviceId AS sharedDevice

SELECT a1.name, a2.name, a1.ssn
FROM Account a1, Account a2
WHERE a1.ssn = a2.ssn AND a1 != a2

SELECT name, vectorCosineSimilarity(behavior_embedding, [0.1, 0.9, 0.1, 0.8]) AS similarity
FROM Transaction
WHERE vectorCosineSimilarity(behavior_embedding, [0.1, 0.9, 0.1, 0.8]) < 0.7

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/fraud-detection
docker compose up -d
./setup.sh
./queries/queries.sh

SELECT sensor_id, ts.timeBucket(timestamp, 'PT1H') AS hour,
  AVG(temperature) AS avg_temp, MAX(temperature) AS max_temp
FROM SensorReading
GROUP BY sensor_id, hour ORDER BY hour

SELECT service_id, ts.rate(timestamp, request_count, 'PT5M') AS req_per_5min
FROM ServiceMetrics
WHERE service_id = 'api-gateway'

MATCH (s:Service {name: 'database'})<-[:DEPENDS_ON*1..3]-(dependent:Service)
RETURN dependent.name AS affected_service, length(path) AS hops

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/realtime-analytics
docker compose up -d
./setup.sh
./queries/queries.sh

SELECT postId, SUM(likes + shares * 2 + comments * 3) AS trendingScore
FROM EngagementMetric
WHERE timestamp > date('2024-01-15', 'yyyy-MM-dd')
GROUP BY postId ORDER BY trendingScore DESC

MATCH path = (origin:User)-[:CREATED]->(p:Post)<-[:SHARED]-(sharer:User)-[:FOLLOWS]->(reached:User)
WHERE origin.name = 'Alice'
RETURN origin.name, sharer.name, reached.name, p.title

MATCH (u:User)-[:MEMBER_OF]->(g1:Group), (u)-[:MEMBER_OF]->(g2:Group)
WHERE g1 <> g2
RETURN u.name, g1.name, g2.name

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/social-network-analytics
docker compose up -d
./setup.sh
./queries/queries.sh

MATCH path = (p:Product)-[:CONTAINS*1..3]->(c:Component)<-[:SUPPLIES]-(s:Supplier)
WHERE p.name = 'SmartWatch Pro'
RETURN s.name, c.name, length(path) AS tier

MATCH (s:Supplier {name: 'ChipCorp'})-[:SUPPLIES]->(c:Component)<-[:CONTAINS]-(p:Product)
OPTIONAL MATCH (alt:Supplier)-[:SUPPLIES]->(c)
WHERE alt <> s
RETURN p.name, c.name, collect(alt.name) AS alternatives

SELECT name, region, distance FROM (
  SELECT expand(vectorNeighbors('Supplier[capability_vec]', [0.9, 0.8, 0.7, 0.6], 5))
)

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/supply-chain
docker compose up -d
./setup.sh
./queries/queries.sh

SELECT identity.email, role.name AS role, permission.action, resource.name AS resource
FROM MATCH {type: Identity, as: identity, where: (email = '[email protected]')}
  -MEMBER_OF->  {type: Group, as: grp}
  -HAS_ROLE->   {type: Role, as: role}
  -GRANTS->     {type: Permission, as: permission}
  -APPLIES_TO-> {type: Resource, as: resource}

SELECT identity.email, role.name
FROM MATCH {type: Identity, as: identity}
  -MEMBER_OF-> {type: Group, as: grp, while: (true)}
  -HAS_ROLE->  {type: Role, as: role, where: (name LIKE '%admin%')}

SELECT email, distance FROM (
  SELECT expand(vectorNeighbors('Identity[access_pattern_vec]', [0.1,0.9,0.1,0.8,0.2,0.7,0.3,0.6], 3))
) WHERE distance > 0.5

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/iam
docker compose up -d
./setup.sh
./queries/queries.sh

SELECT c1.name, c2.name, session.id AS sharedSession
FROM MATCH {type: Customer, as: c1}
  -STARTED->      {type: Session, as: session}
  <-STARTED-      {type: Customer, as: c2}
WHERE c1 <> c2

SELECT customer.name,
  COUNT(CASE WHEN neighbor.status = 'churned' THEN 1 END) * 1.0 / COUNT(neighbor) AS churnRatio
FROM MATCH {type: Customer, as: customer}
  -BELONGS_TO-> {type: Household}
  <-BELONGS_TO- {type: Customer, as: neighbor}
GROUP BY customer.name ORDER BY churnRatio DESC

MATCH (c:Customer)-[:STARTED]->(s:Session)-[:TRIGGERED]->(e1:Event)-[:TRIGGERED]->(e2:Event)-[:TRIGGERED]->(e3:Event)
WHERE e1.type = 'ad_click' AND e3.type = 'purchase'
RETURN c.name, e1.type, e2.type, e3.type, s.channel

git clone https://github.com/ArcadeData/arcadedb-usecases.git
cd arcadedb-usecases/customer-360
docker compose up -d
./setup.sh
./queries/queries.sh