Big data continues to grow exponentially, and data management technologies are changing rapidly to meet the demands. Data storage options continually evolve with options for relational versus graph databases and hosted versus cloud, not to mention the many different data formats and query languages that come with these data stores.
Modern enterprises struggle to manage their data stores efficiently and cost-effectively, and in many cases must continue to maintain legacy systems that use older data storage technology. The problem is compounded by the need for businesses to understand and utilize the data contained in these various systems to their competitive advantage.
Uncovering the important data in these data silos requires purpose-built techniques and tools to consolidate and enable efficient and improved decision-making.
Tom Sawyer Software has spent more than three decades working with data and providing solutions that address the data silo issue.
Our mature data integration platform, Perspectives, includes data federation and data integration capabilities that combine data residing in different data sources and with different data structures to provide enterprises with real-time access to a unified view of the data.
And we don't stop there. Perspectives can reveal valuable insights through powerful visualizations and analysis.
Data federation allows for accessing and querying data from different sources as if they were stored in a single database, without physically moving or copying the data.
Data integration is the process of ingesting data from one or more external data sources into a single, unified in-memory graph model.
Having a consolidated view of data from different systems provides a single source of truth for accurate decision-making.
Using integrated data, you can apply specialized visualization and analysis techniques to expose interesting and previously unseen results.
Data consumers have a single source of truth to consult, enabling them to make mission critical decisions quickly and accurately.
Eliminating latency concerns and the need for data migration or synchronization, data can be accessed and queried in real-time to improve data agility and flexibility.
Reduce the dependency on IT teams for developing custom data integrations or moving data around.
No need to move or copy data to a central data lake or data warehouse, which can lead to consistency and accuracy issues.
The Perspectives platform is data agnostic. It includes a comprehensive set of data integrators that can populate a model from a data source. Some integrators are a bidirectional bridge between a data source and a model, and support writing model data back to the data source.
Whether you have a traditional relational database, a schema-less graph database or RESTful API, the data federation and integration process is easy with Perspectives.
The data integration process is easy for relational databases. Follow these three simple steps, then repeat as needed.
Use the provided integrators to connect to your data source.
Use automatic schema extraction to read the structure of your data and pull out the metadata information automatically. Use the schema editor to view and manually adjust the Perspectives schema to match your application needs.
Bind the data source and the schema. This process determines how many model elements of each model element type are created in the model, and determines the values of all attributes in the model.
Repeat the steps to connect to and federate data from as many data sources as you need.
For graph databases, Perspectives supports automatic binding by default. This means you can use a query to preview the database content and then visualize the data in a drawing view without manually creating a schema and defining data bindings.
The new dynamic data integration tool in Tom Sawyer Perspectives 10.0 allows you to integrate your data in about 20 seconds. From there you can springboard from a Cypher or Gremlin-compatible database to a fully customized, interactive visualization application in only 100 seconds more!
The Neptune Gremlin integrator populates a model from an Amazon Neptune database that supports a Property Graph model. The Neptune integrator, automatically creates a Tom Sawyer Perspectives schema where the data bindings work as follows:
Element bindings correspond to:
Attribute bindings correspond to a relative path starting from the location path for element bindings.
Watch these videos to learn how easy it is to connect to a data source and create visualizations with Perspectives, our graph platform.
Perspectives can write data (commit changes) back to a Neo4j, Amazon Neptune, Apache TinkerPop, JanusGraph, or OrientDB database, or an Excel, SQL, text, or XML data source.
You don't need to worry about the various nuances and integration problems of each platform. Perspectives automatically handles that for you.
During commit, Perspectives ensures data integrity.
Perspectives detects and resolves conflicts during update and commit operations. A conflict occurs when the same object with the same identifier has mismatched values in the data source and in the model.
With Perspectives, commit configuration is convenient and easy putting you in control of which changes to commit. By default, automatic bindings for Neo4j, Neptune Gremlin, Neptune openCypher, OrientDB, and TinkerPop integrators conveniently handle the commit operations to automatically save all changes. But you can choose to exclude any attributes from being committed. And the system supports regular expressions.
Learn more about the graph editing capabilities in Perspectives.
By writing changes directly to the original data source, you can provide real-time updates to the data without delays. This is particularly important in applications where up-to-date information is critical, such as financial systems, real-time monitoring, or collaborative editing tools.
Writing data back helps maintain data consistency. When you update the data source immediately after modifying it, you ensure that all users or components working with that data see the same changes. This prevents data discrepancies or conflicts.
Committing changes in the original data source can provide a complete historical record of all modifications made to the data. This audit trail can be invaluable for debugging, compliance, and accountability purposes.
In distributed systems, writing changes back to the original source can distribute the data updates across multiple nodes, improving the scalability and load balancing of your application.
If a commit process fails midway, you can use the recorded changes to recover and reapply updates, ensuring data integrity.
When multiple users or systems interact with the same data source, writing changes back simplifies collaboration. Everyone sees the same data state, reducing confusion and conflicts.
In cases where data retrieval is time-consuming (e.g., fetching data from external APIs or databases), persisting changes locally can reduce latency by avoiding repetitive data fetches.
If a change leads to unexpected results or errors, reverting to the previous data state is more straightforward when changes are already stored in the original source.
In scenarios with strict data governance or compliance requirements, writing changes back to the original data source ensures that data policies and access controls are consistently enforced.
Once your integrators are configured in Perspectives, the data is loaded into our in-memory native graph model which makes it effective and efficient to work with the data.
Perspectives makes it easy to design and configure an end-user web or desktop application that utilizes the graph model so your users can access the data in real-time. You configure easy-to-understand views of the data including graph drawings, tables, charts, timelines, maps and more. You can also incorporate powerful analytics into the resulting application so users gain even more insight into the data.
Watch this video to see how easy it is to configure a dashboard-style layout of views for your Perspectives application:
An example application created with Perspectives showing a dashboard layout with drawing, map, tree, and chart views.
Query graph databases without the need to know Gremlin or Cypher.
You may not know every query that users will want to perform, that's why we created the query builder, which allows non-technical users to interact with graph database data without the need to know Gremlin or Cypher.
Read our blog to learn more about query builder and Perspectives 11.0.0.
An example of load neighbors being used in Perspectives 12.0.0.
Load neighbors is an innovative tool that can greatly improve the data navigation and analysis experience for end users. With load neighbors, users can explore their data more effectively, saving them valuable time and allowing them to focus on their most important tasks. Load neighbors allows users to load data incrementally based on their use case. As a result, users can gain insights and make faster decisions, which is essential in today’s fast-paced business world.
Learn more about load neighbors and other features in Perspectives 12.0.0.