Here's a list of the most common FlexVertex concepts and terms. If you find an error, or there's something you'd like us to add, please contact us at support [at] flexvertex.com
This is a class that cannot be instantiated directly. It serves as a blueprint for other classes. You define abstract classes to establish properties that can be shared by multiple derived classes.
Authentication is carried out by validating a username and password combination. The scope of an account is within a given schema.
Transactions help safeguard your valuable information. FlexVertex offers comprehensive ACID-compliant transaction support, consisting of:
Atomicity. Every data interaction is handled as a single "unit” and will either succeed or fail completely
Consistency. Thwarting invalid behaviors helps protect your data’s integrity
Isolation. Multiple transactions can take place at one time without negatively impacting each other
Durability. As soon as your data has been committed, it’s protected - even if there’s a power outage or other unexpected event
FlexVertex supplies numerous techniques to interact with its stored information. These include native APIs constructed on the fastest underlying communication protocol, an easily understood REST API, and widely popular query languages and tools such as SQL and JDBC. Our APIs provide a single, consistent method to work with your data, regardless of your storage model or which edition you've deployed. All FlexVertex APIs work seamlessly with our revolutionary Voyager navigation language.
These are files that typically contain Voyager code or images to be displayed in Cartographer. However, FlexVertex assets may be any other type of electronic file. Assets are treated as objects and benefit from replication, transactions, and all other FlexVertex data protection features.
This capability determines whether a given user has the permission to connect to a FlexVertex instance. Note that administrators define the authenticated domain, nexus, and schema when creating a user account.
This capability identifies whether a given user has the permission to view, create, update, or delete an object.
The lowest level class for a given object. Derived classes can inherit properties and behaviors from one or more base classes.
This strategy requires more memory due to its nature of exploring all neighboring nodes at each depth level before moving on to the next level. This characteristic makes BFS considered optimal for finding the shortest path in a graph, as it systematically explores closer nodes first, ensuring the shortest path is identified when the target is near the starting point. Although BFS is generally slower than depth-first search (DFS), it excels in specific applications such as finding the Minimum Spanning Tree of a graph, enabling web crawler functionalities, and facilitating binary tree serialization/deserialization. Its systematic approach also makes BFS more amenable to parallelization, allowing for more efficient processing when the computational resources allow for concurrent exploration of the graph's breadth.
Enter SQL queries and run Voyager scripts to locate information. Carry out free-form FlexVertex Data Multiverse exploration, in both tabular and graphic formats. See Periscope for a command-line interface.
This is the primary FlexVertex graphical management tool. Major capabilites include:
Dashboard. Provides a high level view of your FlexVertex environment
Cartographer. Enables interactive querying and exploration of your FlexVertex Data Multiverse
Schema. Graphical utilities to configure your FlexVertex information hierarchy
Voyager. Tools for uploading Voyager scripts
Security. Define authentication and authorization for your FlexVertex Data Multiverse
Tools. Utilities to help administer your FlexVertex environment
Metrics. Detailed statistics about how your FlexVertex Data Multiverse is operating
Log. View and search contents of user and system log activities
A blueprint for creating objects. FlexVertex lets you define standalone classes or use object-oriented principles to create multi-level class hierarchies.
This is a connection that's established by assigning a class to it. All FlexVertex class-based connections derive from the FlexConnection base class. You're able to use full object orientation capabilities for these types of connections, in contrast with name-based connections which don't offer this functionality.
A collection of related classes, beginning with one or more base classes and incorporating one or more derived classes.
These are designed to provide the fastest possible access to your data. They're associated with a given class' property. They're automatically updated when a property value is changed. These indexes also support composite property values.
These applications run on the user's device - such as a computer or smartphone - and interact with a FlexVertex database hosted on a server. They send requests to and receive responses from FlexVertex over a network (in contrast with server-side execution), enabling data queries, updates, and management from the client side.
This enables relating information within the FlexVertex Data Multiverse. A connection can be created using directionality (i.e., from one object to another object or to an object from another object. Connections may be either class-based or name-based.
A user-defined subset of the information in your FlexVertex Data Multiverse. This subset can range from a single, standalone object up to trillions of connected objects.
These are rules applied to properties within a class to limit the type of data that can be stored in those properties. These constraints are essential for maintaining data integrity and accuracy within the class. They include:
Unique constraints. Confirm that all values stored in a property are distinct
Not null constraints. Prevent any instance of a property from being empty
Check constraints. Enforce user-defined rules, such as a value range for a property
Regardless of the constraints you employ, they help ensure the reliability and validity of the data encapsulated within your classes, thus maintaining the consistency and logic of your overall data model.
Container technologies - such as Docker - have revolutionized the job of packaging and deploying complex software solutions. FlexVertex takes advantage of Docker containers to offer unmatched performance, scalability, and security, all while providing substantial economic benefits over traditional approaches. Containers make it easier to install FlexVertex, whether on-premises, in the cloud, or in a hybrid configuration. Monitoring and administration – including data backup and restoration – are also easier and more streamlined. For larger environments, containerization design also makes it possible to take advantage of Kubernetes for management.
In contrast with the specialized, single data model style offered by most other information storage technologies, FlexVertex delivers multiple native data models including document, graph, key-value, and time series - all in a single, integrated, and affordable solution.
It’s essential to understand you may choose to establish a connection between any FlexVertex object and any other FlexVertex object, regardless of the underlying data model you’ve defined. This makes it possible to ask unlimited numbers of open-ended questions of your data, either programmatically or interactively.
A flexible, scalable, and consistent way of organizing and relating information, able to support applications ranging from single-user applications on small devices all the way to enormous systems running on thousands of distributed servers.
This strategy is characterized by its lower memory requirements, stemming from its approach of exploring as far along a branch as possible before backtracking. This method can potentially get trapped in infinite loops; however, FlexVertex includes checks to prevent such issues or to detect cycles within the graph. DFS is generally faster than breadth-first search (BFS) and is preferred when the target is anticipated to be farther from the starting point. It is particularly suited for applications such as navigating decision trees, solving puzzles or mazes where only one solution is needed, and finding strongly connected components within a graph. The ability of DFS to delve deep into a graph makes it advantageous when the depth where the solution resides is known or when exploring large, sparse graphs where the breadth-wise exploration of BFS would be less efficient.
A class definition that inherits details and behaviors from one or more parent base classes, possibly including abstract classes. Additional classes may be created from a derived class.
The ending point(s) of a journey - also known as the origin to explore the connection among one or more objects.
FlexVertex employs containers to offer unmatched performance, scalability, and security, all while providing substantial economic benefits over traditional approaches. Containers make it easier to install FlexVertex, whether on-premises, in the cloud, or in a hybrid configuration. Docker is the preferred FlexVertex container implementation.
A common way of representing and storing information, routinely encoded using JavaScript Object Notation (JSON). The FlexVertex Data Multiverse has built-in support for documents and extends their capabilities to easily associate them with other objects which optionally may be defined using other data models.
This represents a top-level entity such as an organization or customer. It’s an integral component in the FlexDirectory concept, which is akin to the Lightweight Directory Access Protocol (LDAP). Domains contain nexuses and can support thousands of them. Deleting an existing Domain removes all nexuses and schema below it.
In the context of a graph database, an edge represents a relationship or connection between two vertices (nodes). Each edge can have properties, which are key-value pairs that describe the attributes of the relationship. Edges are directional, indicating the flow of the relationship from one vertex to another. In FlexVertex, edges are represented as objects called connections. This structure allows for efficient querying and traversal of relationships, making it easy to analyze and understand complex interconnections within the data, such as in social networks or recommendation systems.
FlexVertex offers highly tailored editions to meet every computing need. Code is compatible across all editions, which include:
These are designed to take advantage of direct invocations of FlexVertex server-side API calls. Embedded solutions typically desire the shortest latency between application and database, and have the fastest performance requirements
As part of its native object orientation capabilites, FlexVertex supports nesting properties and entire objects within other objects. Developers are free to create, search, update, and delete these properties via SQL and FlexVertex APIs.
Users and administrators are free to customize their FlexVertex environment as they see fit. Examples include adjustable security, indexes, and polymorphism.
This is the base class from which assets derive.
This is the foundational class that serves as the base for all connections. It provides a flexible and adaptable framework for connection objects. FlexConnection is named and implemented using a class-based approach, allowing developers to easily extend and customize its functionality as required. With the support of properties and polymorphism, FlexConnection offers a powerful and versatile solution for managing different types of connections in a robust and scalable manner. If you don't want to specify a connection class, you may elect to use a named connection instead.
This internal FlexVertex class represents the result set from a journey.
This internal FlexVertex class is made up of the steps necessary to retrieve a journey. It contains details about the connection and target.
All data in FlexVertex is stored in objects. This is the base class from which many other key classes derive. These include FlexConnection
The internal FlexVertex class to support journeys. A FlexSegment consists of a source, a connection, and a target.
A style of storing and relating data that is much more compatible with how real-world objects are associated. Employing graph capabilities make it possible to ask powerful, open-ended questions of your information. By treating all data as connected objects, FlexVertex enables graph capabilities throughout the entire FlexVertex Data Multiverse.
This is a mechanism where a new class, known as a subclass, derives or 'inherits' the properties of an existing class, referred to as the superclass or base class. This establishes a hierarchical relationship between classes, promoting code organization and reusability. It allows for the creation of more specific classes from a general class without modifying the original class, facilitating easier maintenance and extension of code.
The steps necessary to find the connections between two or more objects. Journeys consist of one or more segments which are in turn comprised of a source, a connection, and a target.
A unique identifier across the entire FlexVertex Data Multiverse, including all domains. These make it possible to establish a connection between any two objects.
Standard object keys follow this structure:
| Contents |
|---|
| DomainID |
| NexusID |
| SchemaID |
| ClassID |
| UUID |
Connection object keys contain additional information:
| Contents |
|---|
| DomainID |
| NexusID |
| SchemaID |
| ClassID |
| Connection type |
| Source object key |
| Name key |
| Target class id |
| UUID |
This data model can best be visualized as a hash table consisting of an arbitrary number of key and value pairs. The specific structure of these keys and associated values are totally up to the data. Like all other data models, key-value information can be linked to other objects in the FlexVertex Data Multiverse.
Since every application has its own data requirements, FlexVertex lets architects and developers select the optimal information representation to best satisfy their unique needs. Examples include graph, document, time-series, and key-value. However, since all data is ultimately stored as objects, anything within a FlexVertex Data Multiverse can be associated with anything else.
This style of connecting objects simply requires providing a name when establishing the connection. In contrast with class-based connections, it does not offer polymorphism or inheritance.
These artifacts reside beneath a domain and are primarily used to identify sub-domain organizations (i.e., for regions, there could be "North America", "South America", "Europe", "Asia", "Africa", etc.). Nexuses are meant to contain schemas and can support thousands of them.
These are the primary data entities within the FlexVertex Data Multiverse. They’re always associated with a class. Each object's key is a unique identifier across the entire Multiverse, including all domains. Objects are comprised of named property values, and each property can be associated (by name) with a property definition in the object's class. An object may also have named properties that are not associated with its class, known as schema-less.
Features such as class inheritance and polymorphism let you design base classes and then extend them as necessary - including deriving sub-classes with multiple parents. You can then query and otherwise interact with data at the class level without needing to alter your information in any way. This removes the object/database impedance mismatch, and greatly simplifies the job of creating high quality software.
The starting point(s) of a journey - also known as the source to explore the connection among one or more objects.
Command-line interface tool for interacting with FlexVertex. Primarily meant for SQL queries. See Cartographer for more fully featured graphical capabilities, including running Voyager scripts.
These server-side applications are extensions to the core FlexVertex product capabilities, and are typically provided by value-added software vendors.
This enables different data classes to implement a common interface or extend a common base class. This allows instances of these data classes to be treated as objects of the base class or interface type. For example, if you have a base data class Vehicle and derived classes like Car and Bike, instances of Car and Bike can be treated as Vehicle objects.
Software developers are free to choose from several powerful but distinct storage options for their FlexVertex Data Multiverse. These include selections for in-memory processing, single node embedded solutions, and massively scalable multiple server applications.
Individual data elements, either stand-alone schema-less or defined within a class. Each property has a unique name per class and an associated type, such as String, Float, Integer, List, and so on. Properties may be marked as being required and may also have default values assigned. It’s also possible to configure enforced value checking for properties. Examples include minimum/maximum values on an Integer, or enumerated values for a String.
Properties may also be assigned to connections.
FlexVertex automatically and securely synchronizes information across multiple servers. This helps improve performance while safeguarding data. It’s available in all editions from Bronze onward.
Similar in concept to artifacts from relational databases, these contain classes, indexes, Sequences, objects, connections, and accounts.
All FlexVertex objects derive from a base class. These class definitions generally contain properties. However, you may also elect to assign values to undeclared properties on an object-by-object basis. This tactic is known as 'schema-less'.
One or more sequences in a journey to determine the connections among objects. Segments are made up of a source, connection, and a target.
These are applications that execute on the same computers that host FlexVertex database servers. They're designed to perform specific tasks or operations, utilizing the database directly for data storage, retrieval, and manipulation. In contrast with client side software, these applications benefit from reduced network latency and improved performance, as they access the database locally without the need for data to travel over a network.
The initial object(s) when launching a journey to explore object-to-object connections.
Rather than just being a bolt-on afterthought, SQL is integral to everything in FlexVertex. For example, it seamlessly works with our groundbreaking Voyager multiverse navigation language. However, even though we offer a powerful SQL option, you’re always free to use our APIs instead, or in combination with it.
FlexVertex SQL provides full create, read, update, and delete capabilities on both standard and embedded objects, all supervised by our fine-grained authorization system. You can choose from our rich function library to streamline interactions with your data, as well as manage result sets. Named parameters, Boolean conditions, list filtering, and arrays are just a few examples of the productivity tools that you can take advantage of when writing your SQL.
FlexVertex was engineered from the ground up to securely store massive quantities of structured, unstructured, and semi-structured data, all safeguarded with full ACID-compliant transaction capabilities, domain and database authentication, object authorization, and LDAP compatibility. Architects and developers are free to specify the optimal storage strategy to meet their needs, including in-memory, embedded, and distributed. Customers seeking to attain enterprise-grade stability and performance can opt for our robust, distributed architecture capable of supporting nearly limitless concurrent instances.
See derived class.
One or more objects that are the results destination of a journey.
This data model store pairs of timestamps and values created at that specific point in time. These can support a diverse range of applications, and routinely grow to contain very large data amounts. For example, financial data, such as open, low, high, and close for a stock symbol over a given period is perfect for a time series database. Industrial applications could include continual details about a manufacturing robot’s status throughout the day. Smart cities initiatives often use time series data for things like results from traffic sensors. And these are just a few examples of the nearly limitless potential of these systems.
This is a sequence of operations performed as a single logical unit of work. Transactions ensure that these operations either complete in their entirety or have no effect at all. This capability is crucial for maintaining the consistency and integrity of your data. During a transaction, any changes made are not visible to other transactions until the transaction is successfully completed, safeguarding against concurrent access issues. Transactions are used to group multiple steps into one operation, ensuring that your database remains in a consistent state even in cases of system failures or interruptions.
In the context of a graph database, a vertex, also known as a node, represents an entity or object within the database. Each vertex can store properties, which are key-value pairs that describe the attributes of the entity. Vertices are connected by edges, which represent the relationships between entities. This structure allows for efficient querying and traversal of complex data relationships. Graph databases excel at handling interconnected data, making them ideal for applications such as social networks, recommendation systems, and knowledge graphs, where understanding and analyzing the relationships between entities is crucial. Vertices form the foundation of the graph data model. In FlexVertex, vertices are represented by objects. Edges, which are used to associate vertices with each other, are represented by objects as well, in this case known as connections.
Voyager pairs its own language constructs with familiar SQL to revolutionize the previously complex and cumbersome task of traversing a graph to uncover important relationships. It's designed to be accessible for as many people as possible. That meant using a hybrid declarative imperative approach to exploring the multiverse's massively interconnected objects. This offers developers clarity versus the often-cryptic brevity that existing languages use. Voyager lets you compile and store your scripts, which means you can use them over and over - just like a stored procedure, and with the added benefit of full ACID transaction capabilities. To make things even simpler for developers, Voyager is tightly integrated with SQL and all FlexVertex APIs.