Alternatives to Druid logo

Alternatives to Druid

HBase, MongoDB, Cassandra, Prometheus, and Elasticsearch are the most popular alternatives and competitors to Druid.
284
599
+ 1
27

What is Druid and what are its top alternatives?

Druid is a distributed, column-oriented, real-time analytics data store that is commonly used to power exploratory dashboards in multi-tenant environments. Druid excels as a data warehousing solution for fast aggregate queries on petabyte sized data sets. Druid supports a variety of flexible filters, exact calculations, approximate algorithms, and other useful calculations.
Druid is a tool in the Big Data Tools category of a tech stack.
Druid is an open source tool with 10.9K GitHub stars and 3K GitHub forks. Here’s a link to Druid's open source repository on GitHub

Top Alternatives to Druid

  • HBase

    HBase

    Apache HBase is an open-source, distributed, versioned, column-oriented store modeled after Google' Bigtable: A Distributed Storage System for Structured Data by Chang et al. Just as Bigtable leverages the distributed data storage provided by the Google File System, HBase provides Bigtable-like capabilities on top of Apache Hadoop. ...

  • MongoDB

    MongoDB

    MongoDB stores data in JSON-like documents that can vary in structure, offering a dynamic, flexible schema. MongoDB was also designed for high availability and scalability, with built-in replication and auto-sharding. ...

  • Cassandra

    Cassandra

    Partitioning means that Cassandra can distribute your data across multiple machines in an application-transparent matter. Cassandra will automatically repartition as machines are added and removed from the cluster. Row store means that like relational databases, Cassandra organizes data by rows and columns. The Cassandra Query Language (CQL) is a close relative of SQL. ...

  • Prometheus

    Prometheus

    Prometheus is a systems and service monitoring system. It collects metrics from configured targets at given intervals, evaluates rule expressions, displays the results, and can trigger alerts if some condition is observed to be true. ...

  • Elasticsearch

    Elasticsearch

    Elasticsearch is a distributed, RESTful search and analytics engine capable of storing data and searching it in near real time. Elasticsearch, Kibana, Beats and Logstash are the Elastic Stack (sometimes called the ELK Stack). ...

  • Clickhouse

    Clickhouse

    It allows analysis of data that is updated in real time. It offers instant results in most cases: the data is processed faster than it takes to create a query. ...

  • Presto

    Presto

    Distributed SQL Query Engine for Big Data

  • Snowflake

    Snowflake

    Snowflake eliminates the administration and management demands of traditional data warehouses and big data platforms. Snowflake is a true data warehouse as a service running on Amazon Web Services (AWS)—no infrastructure to manage and no knobs to turn. ...

Druid alternatives & related posts

HBase logo

HBase

329
379
14
The Hadoop database, a distributed, scalable, big data store
329
379
+ 1
14
PROS OF HBASE
  • 8
    Performance
  • 5
    OLTP
  • 1
    Fast Point Queries
CONS OF HBASE
    Be the first to leave a con

    related HBase posts

    Hi, I'm building a machine learning pipelines to store image bytes and image vectors in the backend.

    So, when users query for the random access image data (key), we return the image bytes and perform machine learning model operations on it.

    I'm currently considering going with Amazon S3 (in the future, maybe add Redis caching layer) as the backend system to store the information (s3 buckets with sharded prefixes).

    As the latency of S3 is 100-200ms (get/put) and it has a high throughput of 3500 puts/sec and 5500 gets/sec for a given bucker/prefix. In the future I need to reduce the latency, I can add Redis cache.

    Also, s3 costs are way fewer than HBase (on Amazon EC2 instances with 3x replication factor)

    I have not personally used HBase before, so can someone help me if I'm making the right choice here? I'm not aware of Hbase latencies and I have learned that the MOB feature on Hbase has to be turned on if we have store image bytes on of the column families as the avg image bytes are 240Kb.

    See more
    MongoDB logo

    MongoDB

    56.7K
    46.4K
    4.1K
    The database for giant ideas
    56.7K
    46.4K
    + 1
    4.1K
    PROS OF MONGODB
    • 823
      Document-oriented storage
    • 589
      No sql
    • 545
      Ease of use
    • 463
      Fast
    • 405
      High performance
    • 253
      Free
    • 214
      Open source
    • 178
      Flexible
    • 140
      Replication & high availability
    • 108
      Easy to maintain
    • 40
      Querying
    • 36
      Easy scalability
    • 35
      Auto-sharding
    • 34
      High availability
    • 30
      Map/reduce
    • 26
      Document database
    • 24
      Easy setup
    • 24
      Full index support
    • 15
      Reliable
    • 14
      Fast in-place updates
    • 13
      Agile programming, flexible, fast
    • 11
      No database migrations
    • 7
      Enterprise
    • 7
      Easy integration with Node.Js
    • 5
      Enterprise Support
    • 4
      Great NoSQL DB
    • 3
      Aggregation Framework
    • 3
      Support for many languages through different drivers
    • 3
      Drivers support is good
    • 2
      Schemaless
    • 2
      Fast
    • 2
      Awesome
    • 2
      Managed service
    • 2
      Easy to Scale
    • 1
      Consistent
    CONS OF MONGODB
    • 5
      Very slowly for connected models that require joins
    • 3
      Not acid compliant
    • 1
      Proprietary query language

    related MongoDB posts

    Jeyabalaji Subramanian

    Recently we were looking at a few robust and cost-effective ways of replicating the data that resides in our production MongoDB to a PostgreSQL database for data warehousing and business intelligence.

    We set ourselves the following criteria for the optimal tool that would do this job: - The data replication must be near real-time, yet it should NOT impact the production database - The data replication must be horizontally scalable (based on the load), asynchronous & crash-resilient

    Based on the above criteria, we selected the following tools to perform the end to end data replication:

    We chose MongoDB Stitch for picking up the changes in the source database. It is the serverless platform from MongoDB. One of the services offered by MongoDB Stitch is Stitch Triggers. Using stitch triggers, you can execute a serverless function (in Node.js) in real time in response to changes in the database. When there are a lot of database changes, Stitch automatically "feeds forward" these changes through an asynchronous queue.

    We chose Amazon SQS as the pipe / message backbone for communicating the changes from MongoDB to our own replication service. Interestingly enough, MongoDB stitch offers integration with AWS services.

    In the Node.js function, we wrote minimal functionality to communicate the database changes (insert / update / delete / replace) to Amazon SQS.

    Next we wrote a minimal micro-service in Python to listen to the message events on SQS, pickup the data payload & mirror the DB changes on to the target Data warehouse. We implemented source data to target data translation by modelling target table structures through SQLAlchemy . We deployed this micro-service as AWS Lambda with Zappa. With Zappa, deploying your services as event-driven & horizontally scalable Lambda service is dumb-easy.

    In the end, we got to implement a highly scalable near realtime Change Data Replication service that "works" and deployed to production in a matter of few days!

    See more
    Robert Zuber

    We use MongoDB as our primary #datastore. Mongo's approach to replica sets enables some fantastic patterns for operations like maintenance, backups, and #ETL.

    As we pull #microservices from our #monolith, we are taking the opportunity to build them with their own datastores using PostgreSQL. We also use Redis to cache data we’d never store permanently, and to rate-limit our requests to partners’ APIs (like GitHub).

    When we’re dealing with large blobs of immutable data (logs, artifacts, and test results), we store them in Amazon S3. We handle any side-effects of S3’s eventual consistency model within our own code. This ensures that we deal with user requests correctly while writes are in process.

    See more
    Cassandra logo

    Cassandra

    3.1K
    3K
    463
    A partitioned row store. Rows are organized into tables with a required primary key.
    3.1K
    3K
    + 1
    463
    PROS OF CASSANDRA
    • 107
      Distributed
    • 90
      High performance
    • 77
      High availability
    • 71
      Easy scalability
    • 50
      Replication
    • 25
      Reliable
    • 24
      Multi datacenter deployments
    • 6
      Schema optional
    • 6
      OLTP
    • 5
      Open source
    • 2
      Workload separation (via MDC)
    CONS OF CASSANDRA
    • 2
      Reliability of replication
    • 1
      Updates

    related Cassandra posts

    Thierry Schellenbach
    Shared insights
    on
    Redis
    Cassandra
    RocksDB
    at

    1.0 of Stream leveraged Cassandra for storing the feed. Cassandra is a common choice for building feeds. Instagram, for instance started, out with Redis but eventually switched to Cassandra to handle their rapid usage growth. Cassandra can handle write heavy workloads very efficiently.

    Cassandra is a great tool that allows you to scale write capacity simply by adding more nodes, though it is also very complex. This complexity made it hard to diagnose performance fluctuations. Even though we had years of experience with running Cassandra, it still felt like a bit of a black box. When building Stream 2.0 we decided to go for a different approach and build Keevo. Keevo is our in-house key-value store built upon RocksDB, gRPC and Raft.

    RocksDB is a highly performant embeddable database library developed and maintained by Facebook’s data engineering team. RocksDB started as a fork of Google’s LevelDB that introduced several performance improvements for SSD. Nowadays RocksDB is a project on its own and is under active development. It is written in C++ and it’s fast. Have a look at how this benchmark handles 7 million QPS. In terms of technology it’s much more simple than Cassandra.

    This translates into reduced maintenance overhead, improved performance and, most importantly, more consistent performance. It’s interesting to note that LinkedIn also uses RocksDB for their feed.

    #InMemoryDatabases #DataStores #Databases

    See more
    Umair Iftikhar
    Technical Architect at Vappar · | 3 upvotes · 68.2K views

    Developing a solution that collects Telemetry Data from different devices, nearly 1000 devices minimum and maximum 12000. Each device is sending 2 packets in 1 second. This is time-series data, and this data definition and different reports are saved on PostgreSQL. Like Building information, maintenance records, etc. I want to know about the best solution. This data is required for Math and ML to run different algorithms. Also, data is raw without definitions and information stored in PostgreSQL. Initially, I went with TimescaleDB due to PostgreSQL support, but to increase in sites, I started facing many issues with timescale DB in terms of flexibility of storing data.

    My major requirement is also the replication of the database for reporting and different purposes. You may also suggest other options other than Druid and Cassandra. But an open source solution is appreciated.

    See more
    Prometheus logo

    Prometheus

    2.3K
    2.7K
    233
    An open-source service monitoring system and time series database, developed by SoundCloud
    2.3K
    2.7K
    + 1
    233
    PROS OF PROMETHEUS
    • 43
      Powerful easy to use monitoring
    • 39
      Flexible query language
    • 32
      Dimensional data model
    • 26
      Alerts
    • 22
      Active and responsive community
    • 21
      Extensive integrations
    • 19
      Easy to setup
    • 12
      Beautiful Model and Query language
    • 7
      Easy to extend
    • 6
      Nice
    • 3
      Written in Go
    • 2
      Good for experimentation
    • 1
      Easy for monitoring
    CONS OF PROMETHEUS
    • 11
      Just for metrics
    • 6
      Needs monitoring to access metrics endpoints
    • 5
      Bad UI
    • 3
      Not easy to configure and use
    • 2
      Requires multiple applications and tools
    • 2
      Written in Go
    • 2
      Supports only active agents
    • 1
      TLS is quite difficult to understand

    related Prometheus posts

    Conor Myhrvold
    Tech Brand Mgr, Office of CTO at Uber · | 14 upvotes · 2.8M views

    Why we spent several years building an open source, large-scale metrics alerting system, M3, built for Prometheus:

    By late 2014, all services, infrastructure, and servers at Uber emitted metrics to a Graphite stack that stored them using the Whisper file format in a sharded Carbon cluster. We used Grafana for dashboarding and Nagios for alerting, issuing Graphite threshold checks via source-controlled scripts. While this worked for a while, expanding the Carbon cluster required a manual resharding process and, due to lack of replication, any single node’s disk failure caused permanent loss of its associated metrics. In short, this solution was not able to meet our needs as the company continued to grow.

    To ensure the scalability of Uber’s metrics backend, we decided to build out a system that provided fault tolerant metrics ingestion, storage, and querying as a managed platform...

    https://eng.uber.com/m3/

    (GitHub : https://github.com/m3db/m3)

    See more

    We have Prometheus as a monitoring engine as a part of our stack which contains Kubernetes cluster, container images and other open source tools. Also, I am aware that Sysdig can be integrated with Prometheus but I really wanted to know whether Sysdig or sysdig+prometheus will make better monitoring solution.

    See more
    Elasticsearch logo

    Elasticsearch

    23.9K
    17.9K
    1.6K
    Open Source, Distributed, RESTful Search Engine
    23.9K
    17.9K
    + 1
    1.6K
    PROS OF ELASTICSEARCH
    • 321
      Powerful api
    • 311
      Great search engine
    • 231
      Open source
    • 213
      Restful
    • 200
      Near real-time search
    • 96
      Free
    • 83
      Search everything
    • 54
      Easy to get started
    • 45
      Analytics
    • 26
      Distributed
    • 6
      Fast search
    • 5
      More than a search engine
    • 3
      Great docs
    • 3
      Awesome, great tool
    • 3
      Easy to scale
    • 2
      Intuitive API
    • 2
      Great piece of software
    • 2
      Fast
    • 2
      Nosql DB
    • 2
      Easy setup
    • 2
      Highly Available
    • 2
      Document Store
    • 2
      Great customer support
    • 1
      Reliable
    • 1
      Not stable
    • 1
      Potato
    • 1
      Open
    • 1
      Github
    • 1
      Elaticsearch
    • 1
      Actively developing
    • 1
      Responsive maintainers on GitHub
    • 1
      Ecosystem
    • 1
      Scalability
    • 0
      Easy to get hot data
    • 0
      Community
    CONS OF ELASTICSEARCH
    • 6
      Diffecult to get started
    • 5
      Resource hungry
    • 4
      Expensive
    • 3
      Hard to keep stable at large scale

    related Elasticsearch posts

    Tim Abbott

    We've been using PostgreSQL since the very early days of Zulip, but we actually didn't use it from the beginning. Zulip started out as a MySQL project back in 2012, because we'd heard it was a good choice for a startup with a wide community. However, we found that even though we were using the Django ORM for most of our database access, we spent a lot of time fighting with MySQL. Issues ranged from bad collation defaults, to bad query plans which required a lot of manual query tweaks.

    We ended up getting so frustrated that we tried out PostgresQL, and the results were fantastic. We didn't have to do any real customization (just some tuning settings for how big a server we had), and all of our most important queries were faster out of the box. As a result, we were able to delete a bunch of custom queries escaping the ORM that we'd written to make the MySQL query planner happy (because postgres just did the right thing automatically).

    And then after that, we've just gotten a ton of value out of postgres. We use its excellent built-in full-text search, which has helped us avoid needing to bring in a tool like Elasticsearch, and we've really enjoyed features like its partial indexes, which saved us a lot of work adding unnecessary extra tables to get good performance for things like our "unread messages" and "starred messages" indexes.

    I can't recommend it highly enough.

    See more
    Tymoteusz Paul
    Devops guy at X20X Development LTD · | 21 upvotes · 4.3M views

    Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

    It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

    I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

    We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

    If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

    The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

    Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

    See more
    Clickhouse logo

    Clickhouse

    208
    263
    56
    A column-oriented database management system
    208
    263
    + 1
    56
    PROS OF CLICKHOUSE
    • 13
      Fast, very very fast
    • 10
      Good compression ratio
    • 5
      Horizontally scalable
    • 4
      Utilizes all CPU resources
    • 4
      Great CLI
    • 4
      RESTful
    • 3
      Has no transactions
    • 3
      Great number of SQL functions
    • 2
      Open-source
    • 2
      Buggy
    • 1
      In IDEA data import via HTTP interface not working
    • 1
      Server crashes its normal :(
    • 1
      Highly available
    • 1
      Flexible compression options
    • 1
      Flexible connection options
    • 1
      ODBC
    CONS OF CLICKHOUSE
    • 2
      Slow insert operations

    related Clickhouse posts

    Presto logo

    Presto

    300
    771
    57
    Distributed SQL Query Engine for Big Data
    300
    771
    + 1
    57
    PROS OF PRESTO
    • 15
      Works directly on files in s3 (no ETL)
    • 11
      Join multiple databases
    • 11
      Open-source
    • 8
      Scalable
    • 7
      Gets ready in minutes
    • 5
      MPP
    CONS OF PRESTO
      Be the first to leave a con

      related Presto posts

      Ashish Singh
      Tech Lead, Big Data Platform at Pinterest · | 35 upvotes · 753.4K views

      To provide employees with the critical need of interactive querying, we’ve worked with Presto, an open-source distributed SQL query engine, over the years. Operating Presto at Pinterest’s scale has involved resolving quite a few challenges like, supporting deeply nested and huge thrift schemas, slow/ bad worker detection and remediation, auto-scaling cluster, graceful cluster shutdown and impersonation support for ldap authenticator.

      Our infrastructure is built on top of Amazon EC2 and we leverage Amazon S3 for storing our data. This separates compute and storage layers, and allows multiple compute clusters to share the S3 data.

      We have hundreds of petabytes of data and tens of thousands of Apache Hive tables. Our Presto clusters are comprised of a fleet of 450 r4.8xl EC2 instances. Presto clusters together have over 100 TBs of memory and 14K vcpu cores. Within Pinterest, we have close to more than 1,000 monthly active users (out of total 1,600+ Pinterest employees) using Presto, who run about 400K queries on these clusters per month.

      Each query submitted to Presto cluster is logged to a Kafka topic via Singer. Singer is a logging agent built at Pinterest and we talked about it in a previous post. Each query is logged when it is submitted and when it finishes. When a Presto cluster crashes, we will have query submitted events without corresponding query finished events. These events enable us to capture the effect of cluster crashes over time.

      Each Presto cluster at Pinterest has workers on a mix of dedicated AWS EC2 instances and Kubernetes pods. Kubernetes platform provides us with the capability to add and remove workers from a Presto cluster very quickly. The best-case latency on bringing up a new worker on Kubernetes is less than a minute. However, when the Kubernetes cluster itself is out of resources and needs to scale up, it can take up to ten minutes. Some other advantages of deploying on Kubernetes platform is that our Presto deployment becomes agnostic of cloud vendor, instance types, OS, etc.

      #BigData #AWS #DataScience #DataEngineering

      See more
      Eric Colson
      Chief Algorithms Officer at Stitch Fix · | 21 upvotes · 1.9M views

      The algorithms and data infrastructure at Stitch Fix is housed in #AWS. Data acquisition is split between events flowing through Kafka, and periodic snapshots of PostgreSQL DBs. We store data in an Amazon S3 based data warehouse. Apache Spark on Yarn is our tool of choice for data movement and #ETL. Because our storage layer (s3) is decoupled from our processing layer, we are able to scale our compute environment very elastically. We have several semi-permanent, autoscaling Yarn clusters running to serve our data processing needs. While the bulk of our compute infrastructure is dedicated to algorithmic processing, we also implemented Presto for adhoc queries and dashboards.

      Beyond data movement and ETL, most #ML centric jobs (e.g. model training and execution) run in a similarly elastic environment as containers running Python and R code on Amazon EC2 Container Service clusters. The execution of batch jobs on top of ECS is managed by Flotilla, a service we built in house and open sourced (see https://github.com/stitchfix/flotilla-os).

      At Stitch Fix, algorithmic integrations are pervasive across the business. We have dozens of data products actively integrated systems. That requires serving layer that is robust, agile, flexible, and allows for self-service. Models produced on Flotilla are packaged for deployment in production using Khan, another framework we've developed internally. Khan provides our data scientists the ability to quickly productionize those models they've developed with open source frameworks in Python 3 (e.g. PyTorch, sklearn), by automatically packaging them as Docker containers and deploying to Amazon ECS. This provides our data scientist a one-click method of getting from their algorithms to production. We then integrate those deployments into a service mesh, which allows us to A/B test various implementations in our product.

      For more info:

      #DataScience #DataStack #Data

      See more
      Snowflake logo

      Snowflake

      544
      667
      6
      The data warehouse built for the cloud
      544
      667
      + 1
      6
      PROS OF SNOWFLAKE
      • 2
        Good Performance
      • 1
        Public and Private Data Sharing
      • 1
        Multicloud
      • 1
        Great Documentation
      • 1
        Serverless
      CONS OF SNOWFLAKE
        Be the first to leave a con

        related Snowflake posts

        Shared insights
        on
        Google BigQuery
        Snowflake

        I use Google BigQuery because it makes is super easy to query and store data for analytics workloads. If you're using GCP, you're likely using BigQuery. However, running data viz tools directly connected to BigQuery will run pretty slow. They recently announced BI Engine which will hopefully compete well against big players like Snowflake when it comes to concurrency.

        What's nice too is that it has SQL-based ML tools, and it has great GIS support!

        See more
        Shared insights
        on
        Snowflake
        Hadoop
        MarkLogic

        For a property and casualty insurance company, we currently use MarkLogic and Hadoop for our raw data lake. Trying to figure out how snowflake fits in the picture. Does anybody have some good suggestions/best practices for when to use and what data to store in Mark logic versus Snowflake versus a hadoop or all three of these platforms redundant with one another?

        See more