Questions d'entretien JavaScript essentielles que vous devez connaître

Introduction

Le Cypher Query Language (CQL) est un outil puissant conçu pour interroger des bases de données graphiques. Contrairement aux bases de données relationnelles traditionnelles, les bases de données graphiques excellent dans la gestion de données fortement connectées avec des relations non définies. CQL fournit une syntaxe à la fois intuitive et puissante, facilitant la création, la lecture, la mise à jour et la suppression de données stockées dans des bases de données graphiques. Dans ce guide complet, nous explorerons les fonctionnalités, les contraintes, les terminologies et les commandes de CQL, ainsi que des exemples pratiques pour vous aider à exploiter tout son potentiel.

Table des matières

Fonctionnalités du langage de requête Cypher (CQL)

Convient aux données fortement connectées

L'une des caractéristiques les plus remarquables de CQL est son adéquation aux données fortement connectées. Contrairement aux bases de données relationnelles, où les relations sont souvent complexes et lourdes à gérer, les bases de données graphiques prospèrent grâce aux connexions. CQL permet une interrogation intuitive et efficace de ces relations, ce qui en fait un choix idéal pour les réseaux sociaux, les moteurs de recommandation, etc.

Plusieurs étiquettes pour les nœuds

En CQL, un nœud peut être associé à plusieurs étiquettes. Cette flexibilité permet une meilleure organisation et catégorisation des données. Par exemple, un nœud représentant une personne peut avoir des étiquettes telles que Personne, Employé et Client, chacune représentant différents aspects de l'identité de l'individu.

Contraintes du CQL

Limites de la fragmentation

Bien que CQL soit puissant, il présente certaines contraintes. La fragmentation n'est possible que pour certains domaines. Cela signifie que, dans certains cas, il faudra parcourir les données dans leur intégralité pour obtenir une réponse définitive.

Traversée graphique complète pour des réponses définitives

Pour certaines requêtes, en particulier celles impliquant des relations complexes, il peut être nécessaire de parcourir l'intégralité du graphique pour garantir que les données renvoyées sont exactes et complètes. Cela peut nécessiter beaucoup de ressources et de temps, en fonction de la taille et de la complexité du graphique.

Terminologies en CQL

Nœud

Un nœud représente une entité dans le graphique. Les nœuds peuvent avoir des propriétés qui stockent des informations sur l'entité, telles que le nom, l'âge ou tout autre attribut pertinent.

Étiquette

Les étiquettes permettent le regroupement de nœuds. Ils remplacent la notion de tables en SQL. Par exemple, un nœud avec une étiquette Personne regroupe tous les nœuds qui représentent des personnes.

Relation

Une relation est un lien matérialisé entre deux nœuds. Cela remplace la notion de relations dans SQL, permettant des connexions directes entre entités.

Attributs

Les attributs sont des propriétés qu'un nœud ou une relation peut avoir. Par exemple, un nœud Personne peut avoir des attributs tels que le nom et l'âge, tandis qu'une relation LIKES peut avoir des attributs tels que depuis.

Commandes de base en CQL

CRÉER

La commande CREATE est utilisée pour créer des nœuds et des relations. Ceci est fondamental pour construire la structure du graphe.

CORRESPONDRE

La commande MATCH est utilisée pour rechercher des modèles dans le graphique. C'est la pierre angulaire des requêtes en CQL, vous permettant de récupérer des nœuds et des relations en fonction de critères spécifiés.

Création de nœuds

Création de nœuds de base

Créer des nœuds en CQL est simple. Utilisez la commande CREATE suivie des détails du nœud.

CREATE (:Person {name:\"John\", age:30})
CREATE (:Food {name:\"Pizza\"})

Création de nœuds avec des propriétés

Les nœuds peuvent être créés avec des propriétés, qui sont des paires clé-valeur qui stockent des informations sur le nœud.

CREATE (:Person {name:\"Jane\", age:25, occupation:\"Engineer\"})
CREATE (:Food {name:\"Burger\", calories:500})

Recherche de nœuds

Recherche de nœud de base

La commande MATCH permet de rechercher des nœuds dans le graphique.

MATCH (p:Person) RETURN p

Recherche avancée avec la clause WHERE

Pour des recherches plus spécifiques, utilisez la clause WHERE pour filtrer les nœuds en fonction de leurs propriétés.

MATCH (p:Person)
WHERE p.age > 20
RETURN p.name, p.age

Créer des relations

Créer des relations lors de la création de nœuds

Vous pouvez créer des relations entre les nœuds au fur et à mesure que vous les créez.

CREATE (p:Person {name:\"John\", age:30})-[:LIKES]->(f:Food {name:\"Pizza\"})

Création de relations entre les nœuds existants

Des relations peuvent également être créées entre des nœuds existants à l'aide de la commande MATCH.

MATCH (p:Person {name:\"John\"})
MATCH (f:Food {name:\"Pizza\"})
CREATE (p)-[r:LIKES]->(f)
RETURN r

Modification des nœuds et des relations

Ajout d'attributs

Des attributs peuvent être ajoutés aux nœuds existants à l'aide de la commande SET.

MATCH (p:Person {name:\"John\"})
SET p.occupation = \"Developer\"
RETURN p

Suppression d'attributs

Pour supprimer un attribut, définissez sa valeur sur NULL.

MATCH (p:Person {name:\"John\"})
SET p.age = NULL
RETURN p

Modifying Attributes

Attributes can be modified by setting them to new values.

MATCH (p:Person {name:\"John\"})
SET p.age = 35
RETURN p

Using Aggregate Functions in CQL

COUNT

The COUNT function returns the number of nodes or relationships.

MATCH (n) RETURN count(n)

AVG

The AVG function calculates the average value of a numeric property.

MATCH (n) RETURN avg(n.age)

SUM

The SUM function calculates the total sum of a numeric property.

MATCH (n) RETURN sum(n.age)

Advanced Queries in CQL

Number of Relations by Type

To get the count of each type of relationship in the graph, use the type function.

MATCH ()-[r]->() RETURN type(r), count(*)

Collecting Values into Lists

The COLLECT function creates a list of all values for a given property.

MATCH (p:Product)-[:BELONGS_TO]->(o:Order)
RETURN id(o) as orderId, collect(p)

Database Maintenance in CQL

Deleting Nodes and Relationships

To delete all nodes and relationships, use the DELETE command.

MATCH (a)-[r]->(b) DELETE a, r, b

Visualizing Database Schema

Visualize the database schema to understand the structure of your graph.

CALL db.schema.visualization YIELD nodes, relationships

Practical Tricks and Tips

Finding Specific Nodes

Here are three ways to find a node representing a person named Lana Wachowski.

// Solution 1
MATCH (p:Person {name: \"Lana Wachowski\"})
RETURN p

// Solution 2
MATCH (p:Person)
WHERE p.name = \"Lana Wachowski\"
RETURN p

// Solution 3
MATCH (p:Person)
WHERE p.name =~ \".*Lana Wachowski.*\"
RETURN p

Complex Query Examples

Display the name and role of people born after 1960 who acted in movies released in the 1980s.

MATCH (p:Person)-[a:ACTED_IN]->(m:Movie)
WHERE p.born > 1960 AND m.released >= 1980 AND m.released < 1990
RETURN p.name, a.roles

Add the label Actor to people who have acted in at least one movie.

MATCH (p:Person)-[:ACTED_IN]->(:Movie)
WHERE NOT (p:Actor)
SET p:Actor

Application Examples

Real-World Use Cases

Consider a database for an online store where you need to manage products, clients, orders, and shipping addresses. Here's how you might model this in CQL.

Example Queries

Let's create some example nodes and relationships for an online store scenario:

CREATE (p1:Product {id: 1, name: \"Laptop\", price: 1000})
CREATE (p2:Product {id: 2, name: \"Phone\", price: 500})
CREATE (c:Client {id: 1, name: \"John Doe\"})
CREATE (o:Order {id: 1, date: \"2023-06-01\"})
CREATE (adr:Address {id: 1, street: \"123 Main St\", city: \"Anytown\", country: \"USA\"})

Now, let's create the relationships between these nodes:

CREATE (p1)-[:BELONGS_TO]->(o)
CREATE (p2)-[:BELONGS_TO]->(o)
CREATE (c)-[:MADE]->(o)
CREATE (o)-[:SHIPPED_TO]->(adr)

Querying Products Ordered in Each Order

To find out the products ordered in each order, including their quantity and unit price, use the following query:

MATCH (p:Product)-[:BELONGS_TO]->(o:Order)
RETURN id(o) as orderId, collect(p)

Querying Clients and Shipping Addresses

To determine which client made each order and where each order was shipped, use this query:

MATCH (c:Client)-[:MADE]->(o:Order)-[:SHIPPED_TO]->(adr:Address)
RETURN c.name as client, id(o) as orderId, adr.street, adr.city, adr.country

FAQ

What is Cypher Query Language (CQL)?

Cypher Query Language (CQL) is a powerful query language designed specifically for querying and updating graph databases. It allows you to interact with data in a way that emphasizes the relationships between data points.

How does CQL differ from SQL?

While SQL is designed for querying relational databases, CQL is designed for graph databases. This means that CQL excels at handling complex, highly connected data, whereas SQL is better suited for tabular data structures.

Can I use CQL with any database?

CQL is primarily used with Neo4j, a popular graph database management system. However, other graph databases may have their own query languages with similar capabilities.

What are the benefits of using CQL?

CQL allows for intuitive querying of graph databases, making it easier to manage and analyze data with complex relationships. It supports a rich set of commands for creating, updating, and deleting nodes and relationships, as well as powerful query capabilities.

Is CQL difficult to learn?

CQL is designed to be user-friendly and intuitive. If you are familiar with SQL, you will find many similarities in CQL. The main difference lies in how data relationships are handled.

How can I optimize my CQL queries?

Optimizing CQL queries involves understanding your graph's structure and using efficient query patterns. Indexing frequently searched properties and avoiding unnecessary full graph traversals can significantly improve performance.

Conclusion

Cypher Query Language (CQL) is a robust tool for managing graph databases, offering powerful capabilities for querying and updating complex, highly connected data. By mastering CQL, you can leverage the full potential of graph databases, making it easier to handle intricate data relationships and perform sophisticated analyses.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!