NoSQL databases provide flexible schemas, horizontal scalability, and eventual consistency. There are four main NoSQL data models: key-value, document, column family, and graph. Key-value databases store data as unstructured (key, value) pairs. Document databases store data as documents with a flexible schema. Column family databases organize data by columns within rows. Graph databases model data as nodes and relationships. Popular NoSQL databases include MongoDB, Cassandra, HBase, Redis, Neo4j, and Elasticsearch.
This document provides an overview of NoSQL databases, including what they are, common types, uses cases, and examples. It defines NoSQL as distributed, schema-less databases and discusses four main types: columnar, document, key-value, and graph databases. The document also examines specific NoSQL databases like HBase, MongoDB, Redis, and Neo4j, providing information on their architectures, features, and how they are used. General recommendations are made around reading documentation, design reviews, and isolating NoSQL clusters.
The NoSQL movement has introduced four new database architectural patterns that complement, but not replace, traditional relational and analytical databases. This presentation will introduce these four patterns and discuss their relative strengths and weaknesses for solving a variety of business problems. These problems include Big Data (scalability), search, high availability and agility. For each type of problem we look at how NoSQL databases take different approaches to solving these problems and how you can use this knowledge to find the right database architecture for your business challenges.
Couchbase is an open source NoSQL document database that provides a fully functional document store without a predefined schema. It uses buckets as containers for data storage and replication. Couchbase is considered a CP system that prioritizes consistency and partition tolerance within a cluster, but can provide AP capabilities across data centers using its Cross Datacentre Replication (XDCR) feature. Key aspects of Couchbase include buckets for logical data grouping, flexible document storage using JSON, and auto-sharding and replication of data for high availability.
The document discusses MongoDB and how it compares to relational database management systems (RDBMS). It provides examples of how data can be modeled and stored differently in MongoDB compared to SQL databases. Specifically, it discusses how MongoDB allows for flexible, dynamic schemas as each document can have a different structure. This enables complex data like product catalogs with varying attributes for different items to be stored easily in a single collection. The document also provides examples of common operations like insert, update and delete in MongoDB compared to SQL.
This document summarizes the limitations of Azure SQL Database. Key limitations include not being able to change collation settings of system objects, use Windows authentication, manage high availability features, or use various SQL Server tools and stored procedures. The document provides a detailed list of limitations across database and T-SQL functionality, database internals, and other areas in comparison to on-premises SQL Server. It advises checking official Microsoft documentation for the most up-to-date information.
In these slides we introduce Column-Oriented Stores. We deeply analyze Google BigTable. We discuss about features, data model, architecture, components and its implementation. In the second part we discuss all the major open source implementation for column-oriented databases.
Sql vs NO-SQL database differences explainedSatya Pal
This document compares SQL and NoSQL databases. It outlines key differences between the two types of databases such as their data structures (tables vs documents/key-value pairs), schemas (strict vs dynamic), scalability (vertical vs horizontal), and query languages (SQL vs unstructured). Examples of popular SQL databases discussed are MySQL, MS-SQL Server, and Oracle. Examples of NoSQL databases discussed are MongoDB, CouchDB, and Redis. The document provides an overview of each example database's features and benefits.
HBase is an open-source, distributed, column-oriented database that runs on top of Hadoop. It provides real-time read and write access to large amounts of data across clusters of commodity hardware. HBase scales to billions of rows and millions of columns and is used by companies like Twitter, Adobe, and Yahoo to store large datasets. It uses a master-slave architecture with a single HBaseMaster and multiple RegionServers and stores data in Hadoop's HDFS for high availability.
NuoDB is an elastic SQL database that uses an emergent architecture where everything is represented as autonomous atoms. Atoms can replicate themselves across nodes to provide scalability without compromising on ACID transactions or requiring additional administration. Unlike traditional SQL databases, NuoDB's distributed model allows it to scale elastically in the cloud while providing the full functionality of SQL and high availability even with node failures.
This document provides an introduction to relational databases, NoSQL databases, and data in general. It includes the following:
- An overview of relational databases and their ACID properties. Relational databases are best for structured, centralized data and scale vertically.
- A survey of several popular NoSQL databases like MongoDB, Cassandra, Redis, and HBase. NoSQL databases are best for unstructured, large quantities of data and scale horizontally.
- General advice that the data and query models, durability needs, scalability needs, and consistency requirements should determine the best database choice. Trying different options is recommended.
1. The document discusses various technologies for building big data architectures, including NoSQL databases, distributed file systems, and data partitioning techniques.
2. Key-value stores, document databases, and graph databases are introduced as alternatives to relational databases for large, unstructured data.
3. The document also covers approaches for scaling databases horizontally, such as sharding, replication, and partitioning data across multiple servers.
Apache Cassandra is a free and open source distributed database management system that is highly scalable and designed to manage large amounts of structured data. It provides high availability with no single point of failure. Cassandra uses a decentralized architecture and is optimized for scalability and availability without compromising performance. It distributes data across nodes and data centers and replicates data for fault tolerance.
This document provides an outline for a student talk on NoSQL databases. It introduces NoSQL databases and discusses their characteristics and uses. It then covers different types of NoSQL databases including key-value, column, document, and graph databases. Examples of specific NoSQL databases like MongoDB, Cassandra, HBase, Riak, and Neo4j are provided. The document also discusses concepts like CAP theorem, replication, sharding, and provides comparisons of different database types.
Oracle Week 2016 - Modern Data ArchitectureArthur Gimpel
This document discusses modern operational data architectures and the use of both relational and NoSQL databases. It provides an overview of relational databases and their ACID properties. While relational databases dominate the market, they have limitations around scalability, flexibility, and performance. NoSQL databases offer alternatives like horizontal scaling and flexible schemas. Key-value stores are best for caching, sessions, and serving data, while document stores are popular for hierarchical and search use cases. Graph databases excel at link analysis. The document advocates a polyglot persistence approach using multiple database types according to their strengths. It provides examples of search architectures using both database-centric and application-centric distribution approaches.
MySQL uses different storage engines to store, retrieve and index data. The major storage engines are MyISAM, InnoDB, MEMORY, and ARCHIVE. MyISAM uses table-level locking and supports full-text searching but not transactions. InnoDB supports transactions, row-level locking and foreign keys but with more overhead than MyISAM. MEMORY stores data in memory for very fast access but data is lost on server restart. ARCHIVE is for read-only tables to improve performance and reduce storage requirements.
This document provides an overview of Postgresql, including its history, capabilities, advantages over other databases, best practices, and references for further learning. Postgresql is an open source relational database management system that has been in development for over 30 years. It offers rich SQL support, high performance, ACID transactions, and extensive extensibility through features like JSON, XML, and programming languages.
This document provides an overview of NoSQL databases and summarizes key information about several NoSQL databases, including HBase, Redis, Cassandra, MongoDB, and Memcached. It discusses concepts like horizontal scalability, the CAP theorem, eventual consistency, and data models used by different NoSQL databases like key-value, document, columnar, and graph structures.
NoSQL databases provide an alternative to traditional relational databases that is well-suited for large datasets, high scalability needs, and flexible, changing schemas. NoSQL databases sacrifice strict consistency for greater scalability and availability. The document model is well-suited for semi-structured data and allows for embedding related data within documents. Key-value stores provide simple lookup of data by key but do not support complex queries. Graph databases effectively represent network-like connections between data elements.
NoSQL databases were developed to address the limitations of relational databases in handling massive, unstructured datasets. NoSQL databases sacrifice ACID properties like consistency in favor of scalability and availability. The CAP theorem states that only two of consistency, availability, and partition tolerance can be achieved at once. Common NoSQL database types include document stores, key-value stores, column-oriented stores, and graph databases. NoSQL is best suited for large datasets that don't require strict consistency or relational structures.
This document provides an overview of NoSQL databases. It discusses that NoSQL databases are non-relational and do not follow the RDBMS principles. It describes some of the main types of NoSQL databases including document stores, key-value stores, column-oriented stores, and graph databases. It also discusses how NoSQL databases are designed for massive scalability and do not guarantee ACID properties, instead following a BASE model ofBasically Available, Soft state, and Eventually Consistent.
The document provides an introduction to NoSQL databases, including key definitions and characteristics. It discusses that NoSQL databases are non-relational and do not follow RDBMS principles. It also summarizes different types of NoSQL databases like document stores, key-value stores, and column-oriented stores. Examples of popular databases for each type are also provided.
The No SQL Principles and Basic Application Of Casandra ModelRishikese MR
The slides discuss various matters of the No SQL and casandra Models, the slide gives a complete picture of the both topics and its relations. Also it discuss the merits and demerits of the topics and its features and examples are also described.
An overview of various database technologies and their underlying mechanisms over time.
Presentation delivered at Alliander internally to inspire the use of and forster the interest in new (NOSQL) technologies. 18 September 2012
Basic Introduction to Cassandra with Architecture and strategies.
with big data challenge. What is NoSQL Database.
The Big Data Challenge
The Cassandra Solution
The CAP Theorem
The Architecture of Cassandra
The Data Partition and Replication
This document provides an overview and introduction to NoSQL databases. It discusses key-value stores like Dynamo and BigTable, which are distributed, scalable databases that sacrifice complex queries for availability and performance. It also explains column-oriented databases like Cassandra that scale to massive workloads. The document compares the CAP theorem and consistency models of these databases and provides examples of their architectures, data models, and operations.
A Survey of Advanced Non-relational Database Systems: Approaches and Applicat...Qian Lin
This document summarizes a survey of advanced non-relational database systems, their approaches, applications, and comparison to relational database management systems (RDBMS). It outlines the problem of scaling to meet new web-scale demands, describes how non-relational databases provide a solution by sacrificing consistency for availability and partition tolerance. Examples of non-relational databases are provided, including their data models, APIs, optimizations, and benefits compared to RDBMS such as improved scalability and fault tolerance.
This document provides an overview of NoSQL databases, including:
- Key-value stores store data as maps or hashmaps and are efficient for data access but limited in query capabilities.
- Column-oriented stores group attributes into column families and store data efficiently but are operationally challenging.
- Document databases store loosely structured data like JSON and allow retrieving documents by keys or contents.
- Graph databases are suited for interaction networks and path finding but are less suited for tabular data.
“not only SQL.”
NoSQL databases are databases store data in a format other than relational tables.
NoSQL databases or non-relational databases don’t store relationship data well.
NoSQL databases were developed to address the need for databases that can handle big data and scale horizontally to support massive amounts of data and high user loads. NoSQL databases are non-relational and support high availability through horizontal scaling and replication across commodity servers to allow for continuous availability. Popular types of NoSQL databases include key-value stores, document stores, column-oriented databases, and graph databases, each suited for different use cases depending on an application's data model and query requirements.
SQL, NoSQL, Distributed SQL: Choose your DataStore carefullyMd Kamaruzzaman
In modern Software Development and Software Architecture, selecting the right DataStore is one of the most challenging and important task. In this presentation, I have summarized the major DataStores and the decision criteria to select the right DataStore according to the use case.
The document discusses different NoSQL data models including key-value, document, column family, and graph models. It provides examples of popular NoSQL databases that implement each model such as Redis, MongoDB, Cassandra, and Neo4j. The document argues that these NoSQL databases address limitations of relational databases in supporting modern web applications with requirements for scalability, flexibility, and high performance.
The document provides an overview of column databases. It begins with a quick recap of different database types and then defines and discusses column databases and column-oriented databases. It explains that column databases store data by column rather than by row, allowing for faster access to specific columns of data. Examples of column databases discussed include Cassandra, HBase, and Vertica. The document then focuses on Cassandra, describing its data model using concepts like keyspaces and column families. It also explains Cassandra's database engine architecture featuring memtables, SSTables, and compaction. The document concludes by mentioning some large companies that use Cassandra in production systems.
The document summarizes a meetup about NoSQL databases hosted by AWS in Sydney in 2012. It includes an agenda with presentations on Introduction to NoSQL and using EMR and DynamoDB. NoSQL is introduced as a class of databases that don't use SQL as the primary query language and are focused on scalability, availability and handling large volumes of data in real-time. Common NoSQL databases mentioned include DynamoDB, BigTable and document databases.
This document provides an overview and summary of key concepts related to advanced databases. It discusses relational databases including MySQL, SQL, transactions, and ODBC. It also covers database topics like triggers, indexes, and NoSQL databases. Alternative database systems like graph databases, triplestores, and linked data are introduced. Web services, XML, and data journalism are also briefly summarized. The document provides definitions and examples of these technical database terms and concepts.
How to Make a Field Storable in Odoo 17 - Odoo SlidesCeline George
Let’s discuss about how to make a field in Odoo model as a storable. For that, a module for College management has been created in which there is a model to store the the Student details.
Life of Ah Gong and Ah Kim ~ A Story with Life Lessons (Hokkien, English & Ch...OH TEIK BIN
A PowerPoint Presentation of a fictitious story that imparts Life Lessons on loving-kindness, virtue, compassion and wisdom.
The texts are in Romanized Hokkien, English and Chinese.
For the Video Presentation with audio narration in Hokkien, please check out the Link:
https://vimeo.com/manage/videos/987932748
Email Marketing in Odoo 17 - Odoo 17 SlidesCeline George
Email marketing is used to send advertisements or commercial messages to specific groups of people by using email. Email Marketing also helps to track the campaign’s overall effectiveness. This slide will show the features of odoo 17 email marketing.
Dr. Nasir Mustafa CERTIFICATE OF APPRECIATION "NEUROANATOMY"Dr. Nasir Mustafa
CERTIFICATE OF APPRECIATION
"NEUROANATOMY"
DURING THE JOINT ONLINE LECTURE SERIES HELD BY
KUTAISI UNIVERSITY (GEORGIA) AND ISTANBUL GELISIM UNIVERSITY (TURKEY)
FROM JUNE 10TH TO JUNE 14TH, 2024
How to Configure Field Cleaning Rules in Odoo 17Celine George
In this slide let’s discuss how to configure field cleaning rules in odoo 17. Field Cleaning is used to format the data that we use inside Odoo. Odoo 17's Data Cleaning module offers Field Cleaning Rules to improve data consistency and quality within specific fields of our Odoo records. By using the field cleaning, we can correct the typos, correct the spaces between them and also formats can be corrected.
Dear Sakthi Thiru Dr. G. B. Senthil Kumar,
It is with great honor and respect that we extend this formal invitation to you. As a distinguished leader whose presence commands admiration and reverence, we cordially invite you to join us in celebrating the 25th anniversary of our graduation from Adhiparasakthi Engineering College on 27th July, 2024. we would be honored to have you by our side as we reflect on the achievements and memories of the past 25 years.
Plato and Aristotle's Views on Poetry by V.Jesinthal Maryjessintv
PPT on Plato and Aristotle's Views on Poetry prepared by Mrs.V.Jesinthal Mary, Dept of English and Foreign Languages(EFL),SRMIST Science and Humanities ,Ramapuram,Chennai-600089
2. What is NOSQL ?
• NOSQL is not a standard.
• NOSQL does not mean "No SQL", rather “Not Only SQL”
• But is also not a RDBMS replacement.
• CAP [Consistency Availability Partition Tolerance] Theorem
• BASE [ Basic Availability, Soft--‐state, Eventual Consistency] v/s ACID
3. Characteristics of a NoSQL Database
• Flexible schema / schema less
• Non relational
• Often Distributed (Partitioned)
• Often Replicated
• Horizontally Scalable
• Eventually consistent
• Cheaper compared to Big names RDBMS systems
• Simple API as compared to SQL (but not standard across products or even
versions).
4. NoSQL pros/cons
Advantages
– Massive scalability
– High availability
– Lower cost (than competitive solutions at that scale)
– (usually) predictable elasticity
– Schema flexibility, sparse & semi-structured data
5. Disadvantages
– Limited query capabilities (so far)
– Eventual consistency is not intuitive to program for
• Makes client applications more complicated
– No standardizatrion
• Portability might be an issue
– Insufficient access control
6. Different types of NoSQL Databases
• NoSQL databases are classified in four major data models:
1. Key-value
2. Document
3. Column family
4. Graph
7. 1. Key-value data model
• The main idea is the use of a hash table
• Access data (values) by strings called keys
• Data has no required format – data may have any format
• Data model: (key, value) pairs
• Basic Operations:
Insert(key , value),
Fetch(key),Update(key),
Delete(key)
8. Contd..
• key/value store
• can be in memory only, or backed by disk persistence.
• supports versioning
• e.g. Voldemort (LinkedIn), Amazon SimpleDB, Memcache,
BerkeleyDB, Oracle NoSQL
9. 1.1 Voldemort
• Distributed key-value store
– Based on Dynamo
• Originally developed by LinkedIn, now open source
• Features
– Simple data model (no joins or complex queries, no RI, …)
– P2P
– Scale-out / elastic
• Consistent hashing of keyspace
• Fixed partitions (no splits, but owner may change when re-balancing)
– Eventual consistency / High Availability
– Replication
– Failure handling
10. 2. Riak
• Like Voldemort , Riak was based on Dynamo database
• Offers key/value interface
• Designed to run on large distributed clusters
• Uses consistent hashing to avoid the need for the kind of centralized
index server
• Querying is handled using MapReduce functions written in JavaScript
• It’s a open source for enterprise customers
11. 2. Document-based datamodel
• Similar to Key-Value model, except value is a document.
• Usually JSON like interchange model.
• Query Model: JavaScript-like or custom.
• Aggregations: Map/Reduce
• Indexes are done via B-Trees.
• unlike simple key-value stores, both keys and values are fully
searchable in document databases.
• e.g. Couchbase, MongoDB, RavenDB, ArangoDB, MarkLogic,
OrientDB, RavenDB, Redis, RethinkDB
12. 2.1 CouchDB
• Schema-free, document oriented database
– Documents stored in JSON format (XML in old versions)
– B-tree storage engine
– MVCC model, no locking
– no joins, no PK/FK (UUIDs are auto assigned)
– Implemented in Erlang
• 1st version in C++, 2nd in Erlang and 500 times more scalable (source: “Erlang
Programming” by Cesarini & Thompson)
– Replication (incremental)
• Documents
– UUID, version
– Old versions retained
13. 2.2 MongoDB
• Another popular Document Database
• Data is stored on Disks but cached in memory for speed
• Supports Replication and Partitioning (Sharding)
• Very popular in Web Applications
• Data is stored internally as BSON and exchanged with
applications as JSON.
• Very easy to setup and get started.
• Not open--‐source but free to use (even commercially) and
support license option.
15. 2.3 Redis
• Often referred to as a Data Structure Server
• Supports storing strings, hashes, lists, sets , sorted sets bitmaps and
hyperloglogs.
• Data is kept in Memory
• Extremely popular for short lived data (Session, cache)
• Can be used as a Push/Pull Message Queue
16. 3. Column family data model
• The column is lowest/smallest
instance of data.
• It is a tuple that contains a
name, a value and a timestamp
• Multiple columns (values) per key.
• e.g. Cassandra, Hbase,
Amazon Redshift, HP Vertica,
Teradata, BigTable, Hypertable
17. 3.1 Cassandra
• Data is stored column wise as opposed to row--‐wise
• Supports partitioning (sharding) and replication even across data
centers.
• Can be used to store > Petabytes of data.
• Supports SQL like CQL interface.
• Open--‐source but commercially supported by DataStax.
18. 3.1 Cassandra – data model, partitioning
• Data model
– Same as BigTable
– Super Columns (nested Columns) and Super Column Families
– column order in a CF can be specified (name, time)
• Dynamic partitioning
– Consistent hashing
– Ring of nodes
– Nodes can be “moved” on the ring for load balancing
19. 3.2 BigTable
• Sparse, distributed, persistent multidimensional sorted map
• (row, column, timestamp) dimensions, value is string
• Key features
– Hybrid row/column store
– Single master (stand-by replica)
– Versioning
– Compression
20. BigTable - architecture
• Master server
– Assign tablets to Tablet Servers
– Balance TS load
– Garbage collection
– Schema management
– Client data does not move through the MS (directly through TS)
– Tablet location not handled by MS
• Tablet server (many)
– thousands of tablets per TS
– Manages Read / Write / Split of its tablets
21. 3.3 HBase
• Developed by Powerset, now Apache
• Based on BigTable
– HDFS (GFS), ZooKeeper (Chubby)
– Master Node (Master Server), Region Servers (Tablet Servers)
– HStore (tablet), memcache (memtable), MapFile (SSTable)
• Features
– Data is stored sorted (no real indexes)
– Automatic partitioning
– Automatic re-balancing / re-partitioning
– Fault tolerance (HDFS, 3 replicas)
23. 3.4 Hypertable
• It’s a open source clone of BigTable
• Written in C++
• Has increased performance
24. 4. Graph data model
• Based on Graph Theory.
• Scale vertically, no clustering.
• You can use graph algorithms easily
• Transactions
• ACID
• For modeling the structure of Data
• Uses Property Graph Data Model (Nodes, Relationships,
properties)
• e.g. Neo4j, InfiniteGraph, OrientDB, Titan GraphDB
25. Other Types / Special Purpose
• Search DBs Solr, Elasticsearch
• Object Databases
• XML Databases