Bigtable is a distributed storage system designed to scale to petabytes of data across thousands of servers. It provides a flexible data model with dynamic control over data layout and format, allowing clients to store and query structured and unstructured data. Data is indexed and queried using row keys and column qualifiers, and versions are indexed by timestamp. The system achieves high performance and scalability through its use of distributed storage on Google infrastructure and a tablet-based data partitioning scheme.
Bigtable is a distributed storage system designed by Google to manage large amounts of structured data across thousands of commodity servers. It provides a simple data model and API that allows clients to easily manage petabytes of data. Bigtable scales to large data volumes and workloads by automatically partitioning data into tablets that can be distributed across servers and dynamically rebalanced as needed.
This document provides an overview of Bigtable, Google's distributed storage system. Bigtable is designed to manage large amounts of structured data across thousands of machines. It provides a simple data model with dynamic control over data layout and high scalability. Bigtable stores data as a sparse, multi-dimensional sorted map and uses row keys, column families and timestamps to index data. It was developed to meet the varied demands of Google's applications for data size, latency and flexibility in data management across a distributed environment.
Bigtable is a distributed storage system designed to handle large amounts of structured data across thousands of commodity servers. It provides a simple "big table" abstraction with rows and columns that can be improved by adding additional columns and timestamps. Underneath, it uses Google's distributed file system GFS for storage and relies on the tablet server architecture and SSTable format to achieve high performance for millions of reads/writes per second and dynamic scaling.
BigTable is a distributed storage system designed by Google to manage large amounts of structured data across thousands of machines. It is a sparse, multidimensional sorted map that scales to petabytes of data. BigTable uses other Google technologies like Google File System for storage, and MapReduce for distributed computations. Data is stored across tablets that are dynamically partitioned and distributed among tablet servers for high performance and availability.
Bigtable is a distributed storage system for managing large structured datasets. It uses a sparse distributed multidimensional sorted map as its data model. Bigtable has been widely adopted by Google for applications requiring scalability, high performance, and high availability, serving over 60 Google products. It utilizes various technologies like the Google File System for storage and Chubby for coordination.
BigTable is a distributed storage system developed by Google for managing structured data at a massive scale. It uses a sparse, distributed, and persistent multidimensional sorted map to store data across thousands of commodity servers. BigTable's data model organizes information into rows, column families, columns, and versions, providing flexibility and high performance for applications like web indexing and analytics.
Google BigTable is a highly scalable database system that is not relational. It distributes data across servers for load balancing. Rows are stored in lexicographic order and partitioned into tablets distributed across servers. Queries retrieve results from minimal tablets. The system is easy to use, with a simple data model and queries that can be performed with Query or GQLQuery classes.
Bigtable: A Distributed Storage System for Structured Dataelliando dias
This document summarizes a research paper on Bigtable, a distributed storage system from Google. Bigtable stores data in sparse, distributed, and persistent multidimensional sorted maps, indexed by row key, column key, and timestamp. It is designed to be scalable, fault-tolerant and handle massive amounts of data across thousands of commodity servers. Bigtable breaks data into tablets that are assigned to tablet servers, and uses mechanisms like compaction and caching to improve performance and manage storage. The system has proven capable of high throughput at Google, handling petabytes of data.
Bigtable is a distributed storage system designed by Google to manage large amounts of structured data across thousands of commodity servers. It provides a simple data model and API that allows clients to easily manage petabytes of data. Bigtable scales to large data volumes and workloads by automatically partitioning data into tablets that can be distributed across servers and dynamically rebalanced as needed.
This document provides an overview of Bigtable, Google's distributed storage system. Bigtable is designed to manage large amounts of structured data across thousands of machines. It provides a simple data model with dynamic control over data layout and high scalability. Bigtable stores data as a sparse, multi-dimensional sorted map and uses row keys, column families and timestamps to index data. It was developed to meet the varied demands of Google's applications for data size, latency and flexibility in data management across a distributed environment.
Bigtable is a distributed storage system designed to handle large amounts of structured data across thousands of commodity servers. It provides a simple "big table" abstraction with rows and columns that can be improved by adding additional columns and timestamps. Underneath, it uses Google's distributed file system GFS for storage and relies on the tablet server architecture and SSTable format to achieve high performance for millions of reads/writes per second and dynamic scaling.
BigTable is a distributed storage system designed by Google to manage large amounts of structured data across thousands of machines. It is a sparse, multidimensional sorted map that scales to petabytes of data. BigTable uses other Google technologies like Google File System for storage, and MapReduce for distributed computations. Data is stored across tablets that are dynamically partitioned and distributed among tablet servers for high performance and availability.
Bigtable is a distributed storage system for managing large structured datasets. It uses a sparse distributed multidimensional sorted map as its data model. Bigtable has been widely adopted by Google for applications requiring scalability, high performance, and high availability, serving over 60 Google products. It utilizes various technologies like the Google File System for storage and Chubby for coordination.
BigTable is a distributed storage system developed by Google for managing structured data at a massive scale. It uses a sparse, distributed, and persistent multidimensional sorted map to store data across thousands of commodity servers. BigTable's data model organizes information into rows, column families, columns, and versions, providing flexibility and high performance for applications like web indexing and analytics.
Google BigTable is a highly scalable database system that is not relational. It distributes data across servers for load balancing. Rows are stored in lexicographic order and partitioned into tablets distributed across servers. Queries retrieve results from minimal tablets. The system is easy to use, with a simple data model and queries that can be performed with Query or GQLQuery classes.
Bigtable: A Distributed Storage System for Structured Dataelliando dias
This document summarizes a research paper on Bigtable, a distributed storage system from Google. Bigtable stores data in sparse, distributed, and persistent multidimensional sorted maps, indexed by row key, column key, and timestamp. It is designed to be scalable, fault-tolerant and handle massive amounts of data across thousands of commodity servers. Bigtable breaks data into tablets that are assigned to tablet servers, and uses mechanisms like compaction and caching to improve performance and manage storage. The system has proven capable of high throughput at Google, handling petabytes of data.
Google developed Bigtable to address the challenges of Google's massive scale of data storage and analysis needs. Bigtable is a distributed storage system that provides a flexible data model and can scale to petabytes of data across thousands of commodity servers. It uses a column-oriented data structure that allows for efficient storage of sparse datasets and flexible querying. Bigtable also provides features like replication, load balancing, and data compression to ensure high performance, fault tolerance, and manageability as data volumes continue growing rapidly over time.
This document provides an overview of Google BigTable, including its motivation, key components, data model, and implementation. BigTable is a distributed storage system designed to scale to massive amounts of data across thousands of servers. It uses several Google technologies like Google File System for storage, Chubby for locking, and MapReduce for distributed processing. The document describes BigTable's data model of rows, columns, and timestamps, as well as its APIs, building blocks, load balancing structure, and compaction process.
Bigtable is a distributed storage system for structured data designed to be scalable, high performance, and highly available. It uses a sparse, multidimensional sorted map to store data across many servers. Bigtable allows for asynchronous updates to different pieces of data at very high read and write rates and efficient scans across large datasets. It has been applied to applications like analytics, Earth imagery, and personalized search at Google.
In recent years, we have seen an overwhelming number of TV commercials that promise that the Cloud can help with many problems, including some family issues. What stands behind the terms “Cloud” and “Cloud Computing,” and what we can actually expect from this phenomenon? A group of students of the Computer Systems Technology department and Dr. T. Malyuta, whom has been working with the Cloud technologies since its early days, will provide an overview of the business and technological aspects of the Cloud.
This document summarizes the evolution of Hive, a data warehouse infrastructure built on top of Hadoop. It discusses Hive's origins at Facebook to manage large, unstructured data. Key points include Hive now functioning as a parallel SQL database using Hadoop for storage and execution. The document outlines new features in versions 0.6 and 0.7 like views, dynamic partitioning, and pluggable indexing. It also discusses Hive's roadmap for testing, performance improvements, and new capabilities.
This document describes Hive, an open-source data warehousing solution built on top of Hadoop. Hive supports queries expressed in a SQL-like declarative language called HiveQL, which are compiled into map-reduce jobs executed on Hadoop. Hive organizes data into tables partitioned across directories and files in HDFS. It includes a system catalog called Hive Metastore for storing schemas and statistics to optimize queries.
This document describes Cassandra, a highly scalable, eventually consistent, distributed, structured key-value store. Cassandra uses a dynamic column family data model and provides tunable consistency. It scales horizontally by adding more servers, handles failures automatically through replication, and has flexible schemas and high availability.
This document provides an overview of several Google technologies that help enable its fast and reliable services, including Google File System (GFS), Chubby lock service, MapReduce, and BigTable. BigTable is described as Google's proprietary, non-relational database that uses compression and a distributed, tablet-based architecture to provide high performance at scale across commodity hardware. It stores data as multidimensional sparse maps divided into tablets that are distributed, replicated, and load balanced for availability and scalability.
The document summarizes Google's Bigtable storage system, which provides a structured storage layer for large distributed data sets. Bigtable stores data as a sparse, distributed, multidimensional sorted map. It is built using the Google File System for storage, Chubby for locking, and provides a simple "get/put/delete" interface for accessing rows and columns. Bigtable tables are sharded into tablets, distributed across servers, and data is stored in immutable Sorted String Tables (SSTables).
As part of NoSQL series, I presented Google Bigtable paper. In presentation I tried to give some plain introduction to Hadoop, MapReduce, HBase
www.scalability.rs
This document provides an overview of Google Bigtable, a distributed storage system for structured data. It discusses Bigtable's design including its use of column families, row keys, and versioning. It also describes Bigtable's basic implementation including its use of the Google File System (GFS) and how data is divided into tablets and distributed across tablet servers. The document then discusses related systems like HBase and how it compares to Bigtable. It provides examples of Bigtable's performance and real-world usage at Google. Finally, it poses some thoughts for discussion and provides useful references for further information.
This document summarizes Google's Bigtable storage system. Bigtable stores data as a sparse, distributed, persistent multidimensional sorted map. It is built using the Google File System for storage, Chubby for locking, and a tablet structure with tablets split across multiple servers. Bigtable provides a simple data model and interfaces for clients to perform read and write operations on large datasets.
This document describes Bigtable, Google's distributed storage system for managing structured data at large scale. Bigtable stores data in sparse, distributed, sorted maps indexed by row key, column key, and timestamp. It is scalable, self-managing, and used by over 60 Google products and services. Bigtable provides high availability and performance through its use of distributed systems techniques like replication, load balancing, and data locality.
The document describes BigTable, a distributed storage system developed at Google to handle large amounts of structured data. BigTable stores data in sparse, distributed, multidimensional sorted maps, with rows organized by lexicographical ordering of row keys. It provides a flexible data model with columns grouped into column families and versions of each cell value stored by timestamp. BigTable is scalable, fault-tolerant and self-managing, using a master server to manage tablet servers that store and serve ranges of table data.
This document provides an overview of key-value stores Bigtable and Dynamo. It discusses their data models, APIs, consistency models, replication strategies, and architectures. Bigtable uses a column-oriented data model and provides strong consistency, while Dynamo sacrifices consistency for availability and flexibility through configurable consistency parameters. Both systems were designed for web-scale applications but take different approaches to meet different priorities like writes for Bigtable and availability for Dynamo.
This document discusses working with files and directories in PHP. It covers understanding file types and permissions, reading and writing files and directories, uploading and downloading files. Specific functions covered include opendir(), readdir(), closedir(), scandir(), mkdir(), filesize(), filetype(), is_dir(), and move_uploaded_file(). The document provides examples of using these functions to list directories, get file information, create directories, and store uploaded files.
Entrepreneurship Education Through Student-Run EventsMark Tayar
A brief summary of a presentation delivered at the Stanford Roundtable on Entrepreneurship Education, Asia, 2008. The presentation looks at the success of student-run entrepreneurship education through student socities such as SIFE, FEWS and ASES.
Turning Point Behavioral Health Care Center held an evening appreciation event on June 9, 2009 at the DoubleTree Hotel and Conference Center in Skokie, Illinois to recognize and thank their staff and supporters. The event was held to express gratitude for the contributions of those who support Turning Point Behavioral Health Care Center's mission.
Mark Tayar searches for talented games and film students for the Academy of Interactive Entertainment (AIE). AIE teaches game development, animation, and visual effects across campuses near games and film companies. It brings together programmers and artists to work on student projects, preparing them for careers in the industry. Several AIE graduates are now living their childhood dreams of working in games and films, as recommended by employers and government reviews of AIE's respected, industry-relevant courses.
This document provides tips for a case study assignment for an international business course, including suggesting to tell an interesting story, evaluate and analyze the case study by describing facts and discussing multiple perspectives, and outlining a future strategy for the organization with clear pathways and a recommendation for a preferred option. The case study should cover the brief history and recent developments of the organization's international business, discuss 3 issues in their internationalization process, and follow general guidelines of 4,000 words and 30 references.
Google developed Bigtable to address the challenges of Google's massive scale of data storage and analysis needs. Bigtable is a distributed storage system that provides a flexible data model and can scale to petabytes of data across thousands of commodity servers. It uses a column-oriented data structure that allows for efficient storage of sparse datasets and flexible querying. Bigtable also provides features like replication, load balancing, and data compression to ensure high performance, fault tolerance, and manageability as data volumes continue growing rapidly over time.
This document provides an overview of Google BigTable, including its motivation, key components, data model, and implementation. BigTable is a distributed storage system designed to scale to massive amounts of data across thousands of servers. It uses several Google technologies like Google File System for storage, Chubby for locking, and MapReduce for distributed processing. The document describes BigTable's data model of rows, columns, and timestamps, as well as its APIs, building blocks, load balancing structure, and compaction process.
Bigtable is a distributed storage system for structured data designed to be scalable, high performance, and highly available. It uses a sparse, multidimensional sorted map to store data across many servers. Bigtable allows for asynchronous updates to different pieces of data at very high read and write rates and efficient scans across large datasets. It has been applied to applications like analytics, Earth imagery, and personalized search at Google.
In recent years, we have seen an overwhelming number of TV commercials that promise that the Cloud can help with many problems, including some family issues. What stands behind the terms “Cloud” and “Cloud Computing,” and what we can actually expect from this phenomenon? A group of students of the Computer Systems Technology department and Dr. T. Malyuta, whom has been working with the Cloud technologies since its early days, will provide an overview of the business and technological aspects of the Cloud.
This document summarizes the evolution of Hive, a data warehouse infrastructure built on top of Hadoop. It discusses Hive's origins at Facebook to manage large, unstructured data. Key points include Hive now functioning as a parallel SQL database using Hadoop for storage and execution. The document outlines new features in versions 0.6 and 0.7 like views, dynamic partitioning, and pluggable indexing. It also discusses Hive's roadmap for testing, performance improvements, and new capabilities.
This document describes Hive, an open-source data warehousing solution built on top of Hadoop. Hive supports queries expressed in a SQL-like declarative language called HiveQL, which are compiled into map-reduce jobs executed on Hadoop. Hive organizes data into tables partitioned across directories and files in HDFS. It includes a system catalog called Hive Metastore for storing schemas and statistics to optimize queries.
This document describes Cassandra, a highly scalable, eventually consistent, distributed, structured key-value store. Cassandra uses a dynamic column family data model and provides tunable consistency. It scales horizontally by adding more servers, handles failures automatically through replication, and has flexible schemas and high availability.
This document provides an overview of several Google technologies that help enable its fast and reliable services, including Google File System (GFS), Chubby lock service, MapReduce, and BigTable. BigTable is described as Google's proprietary, non-relational database that uses compression and a distributed, tablet-based architecture to provide high performance at scale across commodity hardware. It stores data as multidimensional sparse maps divided into tablets that are distributed, replicated, and load balanced for availability and scalability.
The document summarizes Google's Bigtable storage system, which provides a structured storage layer for large distributed data sets. Bigtable stores data as a sparse, distributed, multidimensional sorted map. It is built using the Google File System for storage, Chubby for locking, and provides a simple "get/put/delete" interface for accessing rows and columns. Bigtable tables are sharded into tablets, distributed across servers, and data is stored in immutable Sorted String Tables (SSTables).
As part of NoSQL series, I presented Google Bigtable paper. In presentation I tried to give some plain introduction to Hadoop, MapReduce, HBase
www.scalability.rs
This document provides an overview of Google Bigtable, a distributed storage system for structured data. It discusses Bigtable's design including its use of column families, row keys, and versioning. It also describes Bigtable's basic implementation including its use of the Google File System (GFS) and how data is divided into tablets and distributed across tablet servers. The document then discusses related systems like HBase and how it compares to Bigtable. It provides examples of Bigtable's performance and real-world usage at Google. Finally, it poses some thoughts for discussion and provides useful references for further information.
This document summarizes Google's Bigtable storage system. Bigtable stores data as a sparse, distributed, persistent multidimensional sorted map. It is built using the Google File System for storage, Chubby for locking, and a tablet structure with tablets split across multiple servers. Bigtable provides a simple data model and interfaces for clients to perform read and write operations on large datasets.
This document describes Bigtable, Google's distributed storage system for managing structured data at large scale. Bigtable stores data in sparse, distributed, sorted maps indexed by row key, column key, and timestamp. It is scalable, self-managing, and used by over 60 Google products and services. Bigtable provides high availability and performance through its use of distributed systems techniques like replication, load balancing, and data locality.
The document describes BigTable, a distributed storage system developed at Google to handle large amounts of structured data. BigTable stores data in sparse, distributed, multidimensional sorted maps, with rows organized by lexicographical ordering of row keys. It provides a flexible data model with columns grouped into column families and versions of each cell value stored by timestamp. BigTable is scalable, fault-tolerant and self-managing, using a master server to manage tablet servers that store and serve ranges of table data.
This document provides an overview of key-value stores Bigtable and Dynamo. It discusses their data models, APIs, consistency models, replication strategies, and architectures. Bigtable uses a column-oriented data model and provides strong consistency, while Dynamo sacrifices consistency for availability and flexibility through configurable consistency parameters. Both systems were designed for web-scale applications but take different approaches to meet different priorities like writes for Bigtable and availability for Dynamo.
This document discusses working with files and directories in PHP. It covers understanding file types and permissions, reading and writing files and directories, uploading and downloading files. Specific functions covered include opendir(), readdir(), closedir(), scandir(), mkdir(), filesize(), filetype(), is_dir(), and move_uploaded_file(). The document provides examples of using these functions to list directories, get file information, create directories, and store uploaded files.
Entrepreneurship Education Through Student-Run EventsMark Tayar
A brief summary of a presentation delivered at the Stanford Roundtable on Entrepreneurship Education, Asia, 2008. The presentation looks at the success of student-run entrepreneurship education through student socities such as SIFE, FEWS and ASES.
Turning Point Behavioral Health Care Center held an evening appreciation event on June 9, 2009 at the DoubleTree Hotel and Conference Center in Skokie, Illinois to recognize and thank their staff and supporters. The event was held to express gratitude for the contributions of those who support Turning Point Behavioral Health Care Center's mission.
Mark Tayar searches for talented games and film students for the Academy of Interactive Entertainment (AIE). AIE teaches game development, animation, and visual effects across campuses near games and film companies. It brings together programmers and artists to work on student projects, preparing them for careers in the industry. Several AIE graduates are now living their childhood dreams of working in games and films, as recommended by employers and government reviews of AIE's respected, industry-relevant courses.
This document provides tips for a case study assignment for an international business course, including suggesting to tell an interesting story, evaluate and analyze the case study by describing facts and discussing multiple perspectives, and outlining a future strategy for the organization with clear pathways and a recommendation for a preferred option. The case study should cover the brief history and recent developments of the organization's international business, discuss 3 issues in their internationalization process, and follow general guidelines of 4,000 words and 30 references.
This document provides guidance for a StratSim report that is due on October 18th, 2010. It outlines the structure and content that should be included in the report, such as an overview of the starting business position and initial strategy, the performance objectives and actual performance, key strategic moves that led to success or demise, how the company is positioned for the future, and important lessons learned from the simulation experience. Examples are provided for each section. Other optional report styles mentioned are a post mortem, shareholders report, succession plans, or personal reflections. The document concludes by noting there will be no more presentations next week, but an assignment debrief, internal branding exercise, and quiz to assess knowledge for the final exam revision.
The document discusses social psychological predictors of terrorism and potential interventions. It identifies factors like marginalization, lack of social bonds, and charismatic leaders that can propel extremism. It advocates for community programs in schools and neighborhoods to promote inclusion, provide purposeful activities for youth, and undermine terrorist recruitment networks through policing and communication efforts. The implications are that mitigating root causes through social interventions may be more effective than military operations at reducing terrorism in the long run.
The document provides information and tips for an upcoming exam on international business topics. It includes:
1. A list of 12 exam topics that may be covered on the exam.
2. Tips for studying such as having a basic understanding of all chapters, relating answers to international business, highlighting keywords, and making an exam plan.
3. Suggestions for making responses engaging like using case studies, models, or quotes and having an interesting conclusion with a central theme.
4. Examples of potential exam questions are provided from previous exams.
The document concludes by providing time for students to ask questions about the exam or receive feedback on their group reports.
This document provides information about keeping kosher and using Dacor appliances on the Sabbath and Jewish holidays in a kosher manner. It defines what kosher means according to Jewish law, explaining the separation of meat and dairy and categories of kosher food. It also lists the 39 prohibited categories of work on the Sabbath and considerations for using gas cooktops, electric ovens, ranges, and warming ovens in a way that is compliant with kosher rules.
This document describes Bigtable, a distributed storage system designed by Google to manage large amounts of structured data across thousands of servers. Bigtable provides a simple data model with dynamic control over data layout and format. It scales to petabytes of data and is used by many Google products and projects. The document discusses Bigtable's data model, client API, implementation details including its use of other Google infrastructure like GFS and Chubby, and performance measurements.
Bigtable is a distributed storage system designed by Google to scale to petabytes of data across thousands of servers. It provides a simple data model with dynamic control over data layout and format. Data is indexed by row and column keys and stored as key-value pairs associated with timestamps. Bigtable is used by over 60 Google products and projects and scales from handling throughput-oriented batch jobs to latency-sensitive real-time serving of data.
Bigtable is Google's cloud-based data storage service that provides scalable, high-performance storage for large analytical and operational workloads. It uses a distributed, parallel architecture to store data across thousands of commodity servers and provides low-latency access. Many Google services such as Gmail, YouTube, Google Maps, and Google Analytics use Bigtable to store and access massive amounts of data.
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.
MySQL 8 Tips and Tricks from Symfony USA 2018, San FranciscoDave Stokes
This document discusses several new features in MySQL 8 including:
1. A new transactional data dictionary that stores metadata instead of files for improved simplicity and crash safety.
2. The addition of histograms to help the query optimizer understand data distributions without indexes for better query planning.
3. Resource groups that allow assigning threads to groups with specific CPU and memory limits to control resource usage.
4. Enhancements to JSON support like in-place updates and new functions for improved flexibility with semi-structured data.
Optimization on Key-value Stores in Cloud EnvironmentFei Dong
This document discusses optimizing key-value stores like HBase in cloud environments. It introduces HBase, a distributed, column-oriented database built on HDFS that provides scalable storage and retrieval of large datasets. The document compares rule-based and cost-based optimization strategies, and explores using rule-based optimization to analyze HBase's performance when deployed on Amazon EC2 instances. It describes developing an HBase profiler to measure the costs of using HBase for storage.
SURVEY ON IMPLEMANTATION OF COLUMN ORIENTED NOSQL DATA STORES ( BIGTABLE & CA...IJCERT JOURNAL
NOSQL is a database provides a mechanism for storage and retrieval of data that is modeled for huge amount of data which is used in big data and Cloud Computing . NOSQL systems are also called "Not only SQL" to emphasize that they may support SQL-like query languages. A basic classification of NOSQL is based on data model; they are like column, Document, Key-Value etc. The objective of this paper is to study and compare the implantation of various column oriented data stores like Bigtable, Cassandra.
This document discusses how to implement operations like selection, joining, grouping, and sorting in Cassandra without SQL. It explains that Cassandra uses a nested data model to efficiently store and retrieve related data. Operations like selection can be performed by creating additional column families that index data by fields like birthdate and allow fast retrieval of records by those fields. Joining can be implemented by nesting related entity data within the same column family. Grouping and sorting are also achieved through additional indexing column families. While this requires duplicating data for different queries, it takes advantage of Cassandra's strengths in scalable updates.
This document provides an overview of a syllabus for a course on NoSQL databases. It discusses the evolution and fundamentals of NoSQL, various data distribution models, and explores different NoSQL data models like key-value, document, and graph databases. It also covers topics like MapReduce, CAP theorem, and different types of NoSQL databases compared to relational databases.
Jovian DATA: A multidimensional database for the cloudBharat Rane
The document describes the architecture of JovianDATA, a massively parallel, shared-nothing implementation of a multidimensional database on cloud computing environments. It highlights three innovations: 1) dynamic partition management that optimally redistributes data when nodes are added or removed, 2) automatic replication of partitions degrading query performance to improve parallelism, and 3) using high numbers of nodes temporarily to materialize expensive portions of data cubes with intermittent scalability. The system represents and queries multidimensional data using tuples, transforms MDX queries to tuples, and retrieves data by sending tuple queries to storage.
This document discusses NoSQL databases and compares them to relational databases. It begins by explaining that NoSQL databases were developed to address scalability issues in relational databases. The document then categorizes NoSQL databases into four main types: key-value stores, column-oriented databases, document stores, and graph databases. For each type, popular examples are provided (e.g. DynamoDB, Cassandra, MongoDB) along with descriptions and use cases. The advantages of NoSQL databases over relational databases are also briefly touched on.
ArangoDB is a multi-model open source database that can be used as a document store, graph database, and key-value store using a single query language. It offers features like transactions, replication, sharding, and extensibility through JavaScript to provide a flexible database for various data models and use cases. The document presents ArangoDB as a database that can replace multiple specialized databases by providing multiple data models in a single system.
Big Data is used to store huge volume of both structured and unstructured data which is so large and is
hard to process using current / traditional database tools and software technologies. The goal of Big Data
Storage Management is to ensure a high level of data quality and availability for business intellect and big
data analytics applications. Graph database which is not most popular NoSQL database compare to
relational database yet but it is a most powerful NoSQL database which can handle large volume of data in
very efficient way. It is very difficult to manage large volume of data using traditional technology. Data
retrieval time may be more as per database size gets increase. As solution of that NoSQL databases are
available. This paper describe what is big data storage management, dimensions of big data, types of data,
what is structured and unstructured data, what is NoSQL database, types of NoSQL database, basic
structure of graph database, advantages, disadvantages and application area and comparison of various
graph database.
Big Data is used to store huge volume of both structured and unstructured data which is so large and is
hard to process using current / traditional database tools and software technologies. The goal of Big Data
Storage Management is to ensure a high level of data quality and availability for business intellect and big
data analytics applications. Graph database which is not most popular NoSQL database compare to
relational database yet but it is a most powerful NoSQL database which can handle large volume of data in
very efficient way. It is very difficult to manage large volume of data using traditional technology. Data
retrieval time may be more as per database size gets increase. As solution of that NoSQL databases are
available. This paper describe what is big data storage management, dimensions of big data, types of data,
what is structured and unstructured data, what is NoSQL database, types of NoSQL database, basic
structure of graph database, advantages, disadvantages and application area and comparison of various
graph database.
A Study on Graph Storage Database of NOSQLIJSCAI Journal
Big Data is used to store huge volume of both structured and unstructured data which is so large and is
hard to process using current / traditional database tools and software technologies. The goal of Big Data
Storage Management is to ensure a high level of data quality and availability for business intellect and big
data analytics applications. Graph database which is not most popular NoSQL database compare to
relational database yet but it is a most powerful NoSQL database which can handle large volume of data in
very efficient way. It is very difficult to manage large volume of data using traditional technology. Data
retrieval time may be more as per database size gets increase. As solution of that NoSQL databases are
available. This paper describe what is big data storage management, dimensions of big data, types of data,
what is structured and unstructured data, what is NoSQL database, types of NoSQL database, basic
structure of graph database, advantages, disadvantages and application area and comparison of various
graph database.
A Study on Graph Storage Database of NOSQLIJSCAI Journal
This document summarizes a research paper on graph storage databases in NoSQL. It discusses big data and the need for alternative databases to handle large, diverse datasets. It defines the key aspects of big data including volume, velocity, variety and complexity. It also describes different types of NoSQL databases, focusing on the basic structure of graph databases. Graph databases use nodes and relationships to model connected data. The document compares several graph database systems and discusses advantages like performance and flexibility as well as disadvantages like complexity. It outlines several applications of graph databases in areas like social networks and logistics.
HYBRID DATABASE SYSTEM FOR BIG DATA STORAGE AND MANAGEMENTIJCSEA Journal
Relational database systems have been the standard storage system over the last forty years. Recently,
advancements in technologies have led to an exponential increase in data volume, velocity and variety
beyond what relational databases can handle. Developers are turning to NoSQL which is a non- relational
database for data storage and management. Some core features of database system such as ACID have
been compromised in NOSQL databases. This work proposed a hybrid database system for the storage and
management of extremely voluminous data of diverse components known as big data, such that the two
models are integrated in one system to eliminate the limitations of the individual systems. The system is
implemented in MongoDB which is a NoSQL database and SQL. The results obtained, revealed that having
these two databases in one system can enhance storage and management of big data bridging the gap
between relational and NoSQL storage approach.
HYBRID DATABASE SYSTEM FOR BIG DATA STORAGE AND MANAGEMENTIJCSEA Journal
This document proposes a hybrid database system that integrates a NoSQL database (MongoDB) and a relational database (MySQL) to address the limitations of each individual system for big data storage and management. It discusses the properties of big data, reviews the approaches of relational and NoSQL databases, highlights their strengths and weaknesses, and then describes the proposed hybrid system that categorizes data as structured or unstructured and stores it in the appropriate database to leverage the benefits of both models. The system is designed to enhance big data storage and management by bridging the gaps between relational and NoSQL approaches.
PHP Detroit -- MySQL 8 A New Beginning (updated presentation)Dave Stokes
MySQL has many new features including a true data dictionary, better JSON support, histograms, roles, true descending indexes, 3d GIS, invisible indexes, and the default character set is UTF8MB4
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
AI in the Workplace Reskilling, Upskilling, and Future Work.pptxSunil Jagani
Discover how AI is transforming the workplace and learn strategies for reskilling and upskilling employees to stay ahead. This comprehensive guide covers the impact of AI on jobs, essential skills for the future, and successful case studies from industry leaders. Embrace AI-driven changes, foster continuous learning, and build a future-ready workforce.
Read More - https://bit.ly/3VKly70
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
Must Know Postgres Extension for DBA and Developer during MigrationMydbops
Mydbops Opensource Database Meetup 16
Topic: Must-Know PostgreSQL Extensions for Developers and DBAs During Migration
Speaker: Deepak Mahto, Founder of DataCloudGaze Consulting
Date & Time: 8th June | 10 AM - 1 PM IST
Venue: Bangalore International Centre, Bangalore
Abstract: Discover how PostgreSQL extensions can be your secret weapon! This talk explores how key extensions enhance database capabilities and streamline the migration process for users moving from other relational databases like Oracle.
Key Takeaways:
* Learn about crucial extensions like oracle_fdw, pgtt, and pg_audit that ease migration complexities.
* Gain valuable strategies for implementing these extensions in PostgreSQL to achieve license freedom.
* Discover how these key extensions can empower both developers and DBAs during the migration process.
* Don't miss this chance to gain practical knowledge from an industry expert and stay updated on the latest open-source database trends.
Mydbops Managed Services specializes in taking the pain out of database management while optimizing performance. Since 2015, we have been providing top-notch support and assistance for the top three open-source databases: MySQL, MongoDB, and PostgreSQL.
Our team offers a wide range of services, including assistance, support, consulting, 24/7 operations, and expertise in all relevant technologies. We help organizations improve their database's performance, scalability, efficiency, and availability.
Contact us: info@mydbops.com
Visit: https://www.mydbops.com/
Follow us on LinkedIn: https://in.linkedin.com/company/mydbops
For more details and updates, please follow up the below links.
Meetup Page : https://www.meetup.com/mydbops-databa...
Twitter: https://twitter.com/mydbopsofficial
Blogs: https://www.mydbops.com/blog/
Facebook(Meta): https://www.facebook.com/mydbops/
AppSec PNW: Android and iOS Application Security with MobSFAjin Abraham
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
"Scaling RAG Applications to serve millions of users", Kevin GoedeckeFwdays
How we managed to grow and scale a RAG application from zero to thousands of users in 7 months. Lessons from technical challenges around managing high load for LLMs, RAGs and Vector databases.
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
Session 1 - Intro to Robotic Process Automation.pdfUiPathCommunity
👉 Check out our full 'Africa Series - Automation Student Developers (EN)' page to register for the full program:
https://bit.ly/Automation_Student_Kickstart
In this session, we shall introduce you to the world of automation, the UiPath Platform, and guide you on how to install and setup UiPath Studio on your Windows PC.
📕 Detailed agenda:
What is RPA? Benefits of RPA?
RPA Applications
The UiPath End-to-End Automation Platform
UiPath Studio CE Installation and Setup
💻 Extra training through UiPath Academy:
Introduction to Automation
UiPath Business Automation Platform
Explore automation development with UiPath Studio
👉 Register here for our upcoming Session 2 on June 20: Introduction to UiPath Studio Fundamentals: https://community.uipath.com/events/details/uipath-lagos-presents-session-2-introduction-to-uipath-studio-fundamentals/
"Choosing proper type of scaling", Olena SyrotaFwdays
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
inQuba Webinar Mastering Customer Journey Management with Dr Graham HillLizaNolte
HERE IS YOUR WEBINAR CONTENT! 'Mastering Customer Journey Management with Dr. Graham Hill'. We hope you find the webinar recording both insightful and enjoyable.
In this webinar, we explored essential aspects of Customer Journey Management and personalization. Here’s a summary of the key insights and topics discussed:
Key Takeaways:
Understanding the Customer Journey: Dr. Hill emphasized the importance of mapping and understanding the complete customer journey to identify touchpoints and opportunities for improvement.
Personalization Strategies: We discussed how to leverage data and insights to create personalized experiences that resonate with customers.
Technology Integration: Insights were shared on how inQuba’s advanced technology can streamline customer interactions and drive operational efficiency.
Discover the Unseen: Tailored Recommendation of Unwatched ContentScyllaDB
The session shares how JioCinema approaches ""watch discounting."" This capability ensures that if a user watched a certain amount of a show/movie, the platform no longer recommends that particular content to the user. Flawless operation of this feature promotes the discover of new content, improving the overall user experience.
JioCinema is an Indian over-the-top media streaming service owned by Viacom18.
From Natural Language to Structured Solr Queries using LLMsSease
This talk draws on experimentation to enable AI applications with Solr. One important use case is to use AI for better accessibility and discoverability of the data: while User eXperience techniques, lexical search improvements, and data harmonization can take organizations to a good level of accessibility, a structural (or “cognitive” gap) remains between the data user needs and the data producer constraints.
That is where AI – and most importantly, Natural Language Processing and Large Language Model techniques – could make a difference. This natural language, conversational engine could facilitate access and usage of the data leveraging the semantics of any data source.
The objective of the presentation is to propose a technical approach and a way forward to achieve this goal.
The key concept is to enable users to express their search queries in natural language, which the LLM then enriches, interprets, and translates into structured queries based on the Solr index’s metadata.
This approach leverages the LLM’s ability to understand the nuances of natural language and the structure of documents within Apache Solr.
The LLM acts as an intermediary agent, offering a transparent experience to users automatically and potentially uncovering relevant documents that conventional search methods might overlook. The presentation will include the results of this experimental work, lessons learned, best practices, and the scope of future work that should improve the approach and make it production-ready.
The Department of Veteran Affairs (VA) invited Taylor Paschal, Knowledge & Information Management Consultant at Enterprise Knowledge, to speak at a Knowledge Management Lunch and Learn hosted on June 12, 2024. All Office of Administration staff were invited to attend and received professional development credit for participating in the voluntary event.
The objectives of the Lunch and Learn presentation were to:
- Review what KM ‘is’ and ‘isn’t’
- Understand the value of KM and the benefits of engaging
- Define and reflect on your “what’s in it for me?”
- Share actionable ways you can participate in Knowledge - - Capture & Transfer
Demystifying Knowledge Management through Storytelling
Bigtable osdi06
1. Bigtable: A Distributed Storage System for Structured Data
Fay Chang, Jeffrey Dean, Sanjay Ghemawat, Wilson C. Hsieh, Deborah A. Wallach
Mike Burrows, Tushar Chandra, Andrew Fikes, Robert E. Gruber
{fay,jeff,sanjay,wilsonh,kerr,m3b,tushar,fikes,gruber}@google.com
Google, Inc.
Abstract achieved scalability and high performance, but Bigtable
Bigtable is a distributed storage system for managing provides a different interface than such systems. Bigtable
structured data that is designed to scale to a very large does not support a full relational data model; instead, it
size: petabytes of data across thousands of commodity provides clients with a simple data model that supports
servers. Many projects at Google store data in Bigtable, dynamic control over data layout and format, and al-
including web indexing, Google Earth, and Google Fi- lows clients to reason about the locality properties of the
nance. These applications place very different demands data represented in the underlying storage. Data is in-
on Bigtable, both in terms of data size (from URLs to dexed using row and column names that can be arbitrary
web pages to satellite imagery) and latency requirements strings. Bigtable also treats data as uninterpreted strings,
(from backend bulk processing to real-time data serving). although clients often serialize various forms of struc-
Despite these varied demands, Bigtable has successfully tured and semi-structured data into these strings. Clients
provided a flexible, high-performance solution for all of can control the locality of their data through careful
these Google products. In this paper we describe the sim- choices in their schemas. Finally, Bigtable schema pa-
ple data model provided by Bigtable, which gives clients rameters let clients dynamically control whether to serve
dynamic control over data layout and format, and we de- data out of memory or from disk.
scribe the design and implementation of Bigtable. Section 2 describes the data model in more detail, and
Section 3 provides an overview of the client API. Sec-
tion 4 briefly describes the underlying Google infrastruc-
1 Introduction ture on which Bigtable depends. Section 5 describes the
fundamentals of the Bigtable implementation, and Sec-
Over the last two and a half years we have designed,
tion 6 describes some of the refinements that we made
implemented, and deployed a distributed storage system
to improve Bigtable’s performance. Section 7 provides
for managing structured data at Google called Bigtable.
measurements of Bigtable’s performance. We describe
Bigtable is designed to reliably scale to petabytes of
several examples of how Bigtable is used at Google
data and thousands of machines. Bigtable has achieved
in Section 8, and discuss some lessons we learned in
several goals: wide applicability, scalability, high per-
designing and supporting Bigtable in Section 9. Fi-
formance, and high availability. Bigtable is used by
nally, Section 10 describes related work, and Section 11
more than sixty Google products and projects, includ-
presents our conclusions.
ing Google Analytics, Google Finance, Orkut, Person-
alized Search, Writely, and Google Earth. These prod-
ucts use Bigtable for a variety of demanding workloads,
which range from throughput-oriented batch-processing 2 Data Model
jobs to latency-sensitive serving of data to end users.
The Bigtable clusters used by these products span a wide A Bigtable is a sparse, distributed, persistent multi-
range of configurations, from a handful to thousands of dimensional sorted map. The map is indexed by a row
servers, and store up to several hundred terabytes of data. key, column key, and a timestamp; each value in the map
In many ways, Bigtable resembles a database: it shares is an uninterpreted array of bytes.
many implementation strategies with databases. Paral-
lel databases [14] and main-memory databases [13] have (row:string, column:string, time:int64) → string
To appear in OSDI 2006 1
2. "contents:" "anchor:cnnsi.com" "anchor:my.look.ca"
"<html>..." t3
"com.cnn.www" "<html>..." t5 "CNN" t9 "CNN.com" t8
"<html>..." t6
Figure 1: A slice of an example table that stores Web pages. The row name is a reversed URL. The contents column family con-
tains the page contents, and the anchor column family contains the text of any anchors that reference the page. CNN’s home page
is referenced by both the Sports Illustrated and the MY-look home pages, so the row contains columns named anchor:cnnsi.com
and anchor:my.look.ca. Each anchor cell has one version; the contents column has three versions, at timestamps t3 , t5 , and t6 .
We settled on this data model after examining a variety Column Families
of potential uses of a Bigtable-like system. As one con-
crete example that drove some of our design decisions, Column keys are grouped into sets called column fami-
suppose we want to keep a copy of a large collection of lies, which form the basic unit of access control. All data
web pages and related information that could be used by stored in a column family is usually of the same type (we
many different projects; let us call this particular table compress data in the same column family together). A
the Webtable. In Webtable, we would use URLs as row column family must be created before data can be stored
keys, various aspects of web pages as column names, and under any column key in that family; after a family has
store the contents of the web pages in the contents: col- been created, any column key within the family can be
umn under the timestamps when they were fetched, as used. It is our intent that the number of distinct column
illustrated in Figure 1. families in a table be small (in the hundreds at most), and
that families rarely change during operation. In contrast,
a table may have an unbounded number of columns.
A column key is named using the following syntax:
family:qualifier. Column family names must be print-
Rows
able, but qualifiers may be arbitrary strings. An exam-
ple column family for the Webtable is language, which
The row keys in a table are arbitrary strings (currently up stores the language in which a web page was written. We
to 64KB in size, although 10-100 bytes is a typical size use only one column key in the language family, and it
for most of our users). Every read or write of data under stores each web page’s language ID. Another useful col-
a single row key is atomic (regardless of the number of umn family for this table is anchor; each column key in
different columns being read or written in the row), a this family represents a single anchor, as shown in Fig-
design decision that makes it easier for clients to reason ure 1. The qualifier is the name of the referring site; the
about the system’s behavior in the presence of concurrent cell contents is the link text.
updates to the same row. Access control and both disk and memory account-
Bigtable maintains data in lexicographic order by row ing are performed at the column-family level. In our
key. The row range for a table is dynamically partitioned. Webtable example, these controls allow us to manage
Each row range is called a tablet, which is the unit of dis- several different types of applications: some that add new
tribution and load balancing. As a result, reads of short base data, some that read the base data and create derived
row ranges are efficient and typically require communi- column families, and some that are only allowed to view
cation with only a small number of machines. Clients existing data (and possibly not even to view all of the
can exploit this property by selecting their row keys so existing families for privacy reasons).
that they get good locality for their data accesses. For
example, in Webtable, pages in the same domain are Timestamps
grouped together into contiguous rows by reversing the
hostname components of the URLs. For example, we Each cell in a Bigtable can contain multiple versions of
store data for maps.google.com/index.html under the the same data; these versions are indexed by timestamp.
key com.google.maps/index.html. Storing pages from Bigtable timestamps are 64-bit integers. They can be as-
the same domain near each other makes some host and signed by Bigtable, in which case they represent “real
domain analyses more efficient. time” in microseconds, or be explicitly assigned by client
To appear in OSDI 2006 2
3. // Open the table Scanner scanner(T);
Table *T = OpenOrDie("/bigtable/web/webtable"); ScanStream *stream;
stream = scanner.FetchColumnFamily("anchor");
// Write a new anchor and delete an old anchor stream->SetReturnAllVersions();
RowMutation r1(T, "com.cnn.www"); scanner.Lookup("com.cnn.www");
r1.Set("anchor:www.c-span.org", "CNN"); for (; !stream->Done(); stream->Next()) {
r1.Delete("anchor:www.abc.com"); printf("%s %s %lld %sn",
Operation op; scanner.RowName(),
Apply(&op, &r1); stream->ColumnName(),
stream->MicroTimestamp(),
stream->Value());
Figure 2: Writing to Bigtable. }
Figure 3: Reading from Bigtable.
applications. Applications that need to avoid collisions
must generate unique timestamps themselves. Different
versions of a cell are stored in decreasing timestamp or- Bigtable supports several other features that allow the
der, so that the most recent versions can be read first. user to manipulate data in more complex ways. First,
To make the management of versioned data less oner- Bigtable supports single-row transactions, which can be
ous, we support two per-column-family settings that tell used to perform atomic read-modify-write sequences on
Bigtable to garbage-collect cell versions automatically. data stored under a single row key. Bigtable does not cur-
The client can specify either that only the last n versions rently support general transactions across row keys, al-
of a cell be kept, or that only new-enough versions be though it provides an interface for batching writes across
kept (e.g., only keep values that were written in the last row keys at the clients. Second, Bigtable allows cells
seven days). to be used as integer counters. Finally, Bigtable sup-
In our Webtable example, we set the timestamps of ports the execution of client-supplied scripts in the ad-
the crawled pages stored in the contents: column to dress spaces of the servers. The scripts are written in a
the times at which these page versions were actually language developed at Google for processing data called
crawled. The garbage-collection mechanism described Sawzall [28]. At the moment, our Sawzall-based API
above lets us keep only the most recent three versions of does not allow client scripts to write back into Bigtable,
every page. but it does allow various forms of data transformation,
filtering based on arbitrary expressions, and summariza-
tion via a variety of operators.
3 API Bigtable can be used with MapReduce [12], a frame-
work for running large-scale parallel computations de-
The Bigtable API provides functions for creating and veloped at Google. We have written a set of wrappers
deleting tables and column families. It also provides that allow a Bigtable to be used both as an input source
functions for changing cluster, table, and column family and as an output target for MapReduce jobs.
metadata, such as access control rights.
Client applications can write or delete values in 4 Building Blocks
Bigtable, look up values from individual rows, or iter-
ate over a subset of the data in a table. Figure 2 shows Bigtable is built on several other pieces of Google in-
C++ code that uses a RowMutation abstraction to per- frastructure. Bigtable uses the distributed Google File
form a series of updates. (Irrelevant details were elided System (GFS) [17] to store log and data files. A Bigtable
to keep the example short.) The call to Apply performs cluster typically operates in a shared pool of machines
an atomic mutation to the Webtable: it adds one anchor that run a wide variety of other distributed applications,
to www.cnn.com and deletes a different anchor. and Bigtable processes often share the same machines
Figure 3 shows C++ code that uses a Scanner ab- with processes from other applications. Bigtable de-
straction to iterate over all anchors in a particular row. pends on a cluster management system for scheduling
Clients can iterate over multiple column families, and jobs, managing resources on shared machines, dealing
there are several mechanisms for limiting the rows, with machine failures, and monitoring machine status.
columns, and timestamps produced by a scan. For ex- The Google SSTable file format is used internally to
ample, we could restrict the scan above to only produce store Bigtable data. An SSTable provides a persistent,
anchors whose columns match the regular expression ordered immutable map from keys to values, where both
anchor:*.cnn.com, or to only produce anchors whose keys and values are arbitrary byte strings. Operations are
timestamps fall within ten days of the current time. provided to look up the value associated with a specified
To appear in OSDI 2006 3
4. key, and to iterate over all key/value pairs in a specified dynamically added (or removed) from a cluster to acco-
key range. Internally, each SSTable contains a sequence modate changes in workloads.
of blocks (typically each block is 64KB in size, but this The master is responsible for assigning tablets to tablet
is configurable). A block index (stored at the end of the servers, detecting the addition and expiration of tablet
SSTable) is used to locate blocks; the index is loaded servers, balancing tablet-server load, and garbage col-
into memory when the SSTable is opened. A lookup lection of files in GFS. In addition, it handles schema
can be performed with a single disk seek: we first find changes such as table and column family creations.
the appropriate block by performing a binary search in Each tablet server manages a set of tablets (typically
the in-memory index, and then reading the appropriate we have somewhere between ten to a thousand tablets per
block from disk. Optionally, an SSTable can be com- tablet server). The tablet server handles read and write
pletely mapped into memory, which allows us to perform requests to the tablets that it has loaded, and also splits
lookups and scans without touching disk. tablets that have grown too large.
Bigtable relies on a highly-available and persistent As with many single-master distributed storage sys-
distributed lock service called Chubby [8]. A Chubby tems [17, 21], client data does not move through the mas-
service consists of five active replicas, one of which is ter: clients communicate directly with tablet servers for
elected to be the master and actively serve requests. The reads and writes. Because Bigtable clients do not rely on
service is live when a majority of the replicas are running the master for tablet location information, most clients
and can communicate with each other. Chubby uses the never communicate with the master. As a result, the mas-
Paxos algorithm [9, 23] to keep its replicas consistent in ter is lightly loaded in practice.
the face of failure. Chubby provides a namespace that A Bigtable cluster stores a number of tables. Each ta-
consists of directories and small files. Each directory or ble consists of a set of tablets, and each tablet contains
file can be used as a lock, and reads and writes to a file all data associated with a row range. Initially, each table
are atomic. The Chubby client library provides consis- consists of just one tablet. As a table grows, it is auto-
tent caching of Chubby files. Each Chubby client main- matically split into multiple tablets, each approximately
tains a session with a Chubby service. A client’s session 100-200 MB in size by default.
expires if it is unable to renew its session lease within the
lease expiration time. When a client’s session expires, it 5.1 Tablet Location
loses any locks and open handles. Chubby clients can
also register callbacks on Chubby files and directories We use a three-level hierarchy analogous to that of a B+ -
for notification of changes or session expiration. tree [10] to store tablet location information (Figure 4).
Bigtable uses Chubby for a variety of tasks: to ensure
UserTable1
that there is at most one active master at any time; to Other ...
store the bootstrap location of Bigtable data (see Sec- METADATA
tablets ...
tion 5.1); to discover tablet servers and finalize tablet
... .
server deaths (see Section 5.2); to store Bigtable schema Root tablet
.
.
...
information (the column family information for each ta- Chubby file (1st METADATA tablet)
...
UserTableN
ble); and to store access control lists. If Chubby becomes ... .
.
. ...
unavailable for an extended period of time, Bigtable be-
.
.
comes unavailable. We recently measured this effect ... .
in 14 Bigtable clusters spanning 11 Chubby instances. ...
The average percentage of Bigtable server hours during
which some data stored in Bigtable was not available due Figure 4: Tablet location hierarchy.
to Chubby unavailability (caused by either Chubby out-
ages or network issues) was 0.0047%. The percentage The first level is a file stored in Chubby that contains
for the single cluster that was most affected by Chubby the location of the root tablet. The root tablet contains
unavailability was 0.0326%. the location of all tablets in a special METADATA table.
Each METADATA tablet contains the location of a set of
user tablets. The root tablet is just the first tablet in the
5 Implementation METADATA table, but is treated specially—it is never
split—to ensure that the tablet location hierarchy has no
The Bigtable implementation has three major compo- more than three levels.
nents: a library that is linked into every client, one mas- The METADATA table stores the location of a tablet
ter server, and many tablet servers. Tablet servers can be under a row key that is an encoding of the tablet’s table
To appear in OSDI 2006 4
5. identifier and its end row. Each METADATA row stores The master is responsible for detecting when a tablet
approximately 1KB of data in memory. With a modest server is no longer serving its tablets, and for reassign-
limit of 128 MB METADATA tablets, our three-level lo- ing those tablets as soon as possible. To detect when a
cation scheme is sufficient to address 234 tablets (or 261 tablet server is no longer serving its tablets, the master
bytes in 128 MB tablets). periodically asks each tablet server for the status of its
The client library caches tablet locations. If the client lock. If a tablet server reports that it has lost its lock,
does not know the location of a tablet, or if it discov- or if the master was unable to reach a server during its
ers that cached location information is incorrect, then last several attempts, the master attempts to acquire an
it recursively moves up the tablet location hierarchy. exclusive lock on the server’s file. If the master is able to
If the client’s cache is empty, the location algorithm acquire the lock, then Chubby is live and the tablet server
requires three network round-trips, including one read is either dead or having trouble reaching Chubby, so the
from Chubby. If the client’s cache is stale, the location master ensures that the tablet server can never serve again
algorithm could take up to six round-trips, because stale by deleting its server file. Once a server’s file has been
cache entries are only discovered upon misses (assuming deleted, the master can move all the tablets that were pre-
that METADATA tablets do not move very frequently). viously assigned to that server into the set of unassigned
Although tablet locations are stored in memory, so no tablets. To ensure that a Bigtable cluster is not vulnera-
GFS accesses are required, we further reduce this cost ble to networking issues between the master and Chubby,
in the common case by having the client library prefetch the master kills itself if its Chubby session expires. How-
tablet locations: it reads the metadata for more than one ever, as described above, master failures do not change
tablet whenever it reads the METADATA table. the assignment of tablets to tablet servers.
We also store secondary information in the When a master is started by the cluster management
METADATA table, including a log of all events per- system, it needs to discover the current tablet assign-
taining to each tablet (such as when a server begins ments before it can change them. The master executes
serving it). This information is helpful for debugging the following steps at startup. (1) The master grabs
and performance analysis. a unique master lock in Chubby, which prevents con-
current master instantiations. (2) The master scans the
servers directory in Chubby to find the live servers.
5.2 Tablet Assignment (3) The master communicates with every live tablet
server to discover what tablets are already assigned to
Each tablet is assigned to one tablet server at a time. The
each server. (4) The master scans the METADATA table
master keeps track of the set of live tablet servers, and
to learn the set of tablets. Whenever this scan encounters
the current assignment of tablets to tablet servers, in-
a tablet that is not already assigned, the master adds the
cluding which tablets are unassigned. When a tablet is
tablet to the set of unassigned tablets, which makes the
unassigned, and a tablet server with sufficient room for
tablet eligible for tablet assignment.
the tablet is available, the master assigns the tablet by
sending a tablet load request to the tablet server. One complication is that the scan of the METADATA
Bigtable uses Chubby to keep track of tablet servers. table cannot happen until the METADATA tablets have
When a tablet server starts, it creates, and acquires an been assigned. Therefore, before starting this scan (step
exclusive lock on, a uniquely-named file in a specific 4), the master adds the root tablet to the set of unassigned
Chubby directory. The master monitors this directory tablets if an assignment for the root tablet was not dis-
(the servers directory) to discover tablet servers. A tablet covered during step 3. This addition ensures that the root
server stops serving its tablets if it loses its exclusive tablet will be assigned. Because the root tablet contains
lock: e.g., due to a network partition that caused the the names of all METADATA tablets, the master knows
server to lose its Chubby session. (Chubby provides an about all of them after it has scanned the root tablet.
efficient mechanism that allows a tablet server to check The set of existing tablets only changes when a ta-
whether it still holds its lock without incurring network ble is created or deleted, two existing tablets are merged
traffic.) A tablet server will attempt to reacquire an ex- to form one larger tablet, or an existing tablet is split
clusive lock on its file as long as the file still exists. If the into two smaller tablets. The master is able to keep
file no longer exists, then the tablet server will never be track of these changes because it initiates all but the last.
able to serve again, so it kills itself. Whenever a tablet Tablet splits are treated specially since they are initi-
server terminates (e.g., because the cluster management ated by a tablet server. The tablet server commits the
system is removing the tablet server’s machine from the split by recording information for the new tablet in the
cluster), it attempts to release its lock so that the master METADATA table. When the split has committed, it noti-
will reassign its tablets more quickly. fies the master. In case the split notification is lost (either
To appear in OSDI 2006 5
6. because the tablet server or the master died), the master 5.4 Compactions
detects the new tablet when it asks a tablet server to load
the tablet that has now split. The tablet server will notify As write operations execute, the size of the memtable in-
the master of the split, because the tablet entry it finds in creases. When the memtable size reaches a threshold, the
the METADATA table will specify only a portion of the memtable is frozen, a new memtable is created, and the
tablet that the master asked it to load. frozen memtable is converted to an SSTable and written
to GFS. This minor compaction process has two goals:
it shrinks the memory usage of the tablet server, and it
5.3 Tablet Serving reduces the amount of data that has to be read from the
The persistent state of a tablet is stored in GFS, as illus- commit log during recovery if this server dies. Incom-
trated in Figure 5. Updates are committed to a commit ing read and write operations can continue while com-
log that stores redo records. Of these updates, the re- pactions occur.
cently committed ones are stored in memory in a sorted Every minor compaction creates a new SSTable. If this
buffer called a memtable; the older updates are stored in a behavior continued unchecked, read operations might
sequence of SSTables. To recover a tablet, a tablet server need to merge updates from an arbitrary number of
SSTables. Instead, we bound the number of such files
by periodically executing a merging compaction in the
memtable Read Op
background. A merging compaction reads the contents
of a few SSTables and the memtable, and writes out a
new SSTable. The input SSTables and memtable can be
Memory
discarded as soon as the compaction has finished.
GFS A merging compaction that rewrites all SSTables
tablet log into exactly one SSTable is called a major compaction.
SSTables produced by non-major compactions can con-
Write Op
tain special deletion entries that suppress deleted data in
SSTable Files older SSTables that are still live. A major compaction,
on the other hand, produces an SSTable that contains
Figure 5: Tablet Representation no deletion information or deleted data. Bigtable cy-
cles through all of its tablets and regularly applies major
reads its metadata from the METADATA table. This meta- compactions to them. These major compactions allow
data contains the list of SSTables that comprise a tablet Bigtable to reclaim resources used by deleted data, and
and a set of a redo points, which are pointers into any also allow it to ensure that deleted data disappears from
commit logs that may contain data for the tablet. The the system in a timely fashion, which is important for
server reads the indices of the SSTables into memory and services that store sensitive data.
reconstructs the memtable by applying all of the updates
that have committed since the redo points.
When a write operation arrives at a tablet server, the 6 Refinements
server checks that it is well-formed, and that the sender
is authorized to perform the mutation. Authorization is The implementation described in the previous section
performed by reading the list of permitted writers from a required a number of refinements to achieve the high
Chubby file (which is almost always a hit in the Chubby performance, availability, and reliability required by our
client cache). A valid mutation is written to the commit users. This section describes portions of the implementa-
log. Group commit is used to improve the throughput of tion in more detail in order to highlight these refinements.
lots of small mutations [13, 16]. After the write has been
committed, its contents are inserted into the memtable. Locality groups
When a read operation arrives at a tablet server, it is
similarly checked for well-formedness and proper autho- Clients can group multiple column families together into
rization. A valid read operation is executed on a merged a locality group. A separate SSTable is generated for
view of the sequence of SSTables and the memtable. each locality group in each tablet. Segregating column
Since the SSTables and the memtable are lexicograph- families that are not typically accessed together into sep-
ically sorted data structures, the merged view can be arate locality groups enables more efficient reads. For
formed efficiently. example, page metadata in Webtable (such as language
Incoming read and write operations can continue and checksums) can be in one locality group, and the
while tablets are split and merged. contents of the page can be in a different group: an ap-
To appear in OSDI 2006 6
7. plication that wants to read the metadata does not need Caching for read performance
to read through all of the page contents.
To improve read performance, tablet servers use two lev-
In addition, some useful tuning parameters can be els of caching. The Scan Cache is a higher-level cache
specified on a per-locality group basis. For example, a lo- that caches the key-value pairs returned by the SSTable
cality group can be declared to be in-memory. SSTables interface to the tablet server code. The Block Cache is a
for in-memory locality groups are loaded lazily into the lower-level cache that caches SSTables blocks that were
memory of the tablet server. Once loaded, column fam- read from GFS. The Scan Cache is most useful for appli-
ilies that belong to such locality groups can be read cations that tend to read the same data repeatedly. The
without accessing the disk. This feature is useful for Block Cache is useful for applications that tend to read
small pieces of data that are accessed frequently: we data that is close to the data they recently read (e.g., se-
use it internally for the location column family in the quential reads, or random reads of different columns in
METADATA table. the same locality group within a hot row).
Bloom filters
Compression As described in Section 5.3, a read operation has to read
from all SSTables that make up the state of a tablet.
Clients can control whether or not the SSTables for a If these SSTables are not in memory, we may end up
locality group are compressed, and if so, which com- doing many disk accesses. We reduce the number of
pression format is used. The user-specified compres- accesses by allowing clients to specify that Bloom fil-
sion format is applied to each SSTable block (whose size ters [7] should be created for SSTables in a particu-
is controllable via a locality group specific tuning pa- lar locality group. A Bloom filter allows us to ask
rameter). Although we lose some space by compress- whether an SSTable might contain any data for a spec-
ing each block separately, we benefit in that small por- ified row/column pair. For certain applications, a small
tions of an SSTable can be read without decompress- amount of tablet server memory used for storing Bloom
ing the entire file. Many clients use a two-pass custom filters drastically reduces the number of disk seeks re-
compression scheme. The first pass uses Bentley and quired for read operations. Our use of Bloom filters
McIlroy’s scheme [6], which compresses long common also implies that most lookups for non-existent rows or
strings across a large window. The second pass uses a columns do not need to touch disk.
fast compression algorithm that looks for repetitions in
a small 16 KB window of the data. Both compression
passes are very fast—they encode at 100–200 MB/s, and Commit-log implementation
decode at 400–1000 MB/s on modern machines. If we kept the commit log for each tablet in a separate
Even though we emphasized speed instead of space re- log file, a very large number of files would be written
duction when choosing our compression algorithms, this concurrently in GFS. Depending on the underlying file
two-pass compression scheme does surprisingly well. system implementation on each GFS server, these writes
For example, in Webtable, we use this compression could cause a large number of disk seeks to write to the
scheme to store Web page contents. In one experiment, different physical log files. In addition, having separate
we stored a large number of documents in a compressed log files per tablet also reduces the effectiveness of the
locality group. For the purposes of the experiment, we group commit optimization, since groups would tend to
limited ourselves to one version of each document in- be smaller. To fix these issues, we append mutations
stead of storing all versions available to us. The scheme to a single commit log per tablet server, co-mingling
achieved a 10-to-1 reduction in space. This is much mutations for different tablets in the same physical log
better than typical Gzip reductions of 3-to-1 or 4-to-1 file [18, 20].
on HTML pages because of the way Webtable rows are Using one log provides significant performance ben-
laid out: all pages from a single host are stored close efits during normal operation, but it complicates recov-
to each other. This allows the Bentley-McIlroy algo- ery. When a tablet server dies, the tablets that it served
rithm to identify large amounts of shared boilerplate in will be moved to a large number of other tablet servers:
pages from the same host. Many applications, not just each server typically loads a small number of the orig-
Webtable, choose their row names so that similar data inal server’s tablets. To recover the state for a tablet,
ends up clustered, and therefore achieve very good com- the new tablet server needs to reapply the mutations for
pression ratios. Compression ratios get even better when that tablet from the commit log written by the original
we store multiple versions of the same value in Bigtable. tablet server. However, the mutations for these tablets
To appear in OSDI 2006 7
8. were co-mingled in the same physical log file. One ap- of the SSTables that we generate are immutable. For ex-
proach would be for each new tablet server to read this ample, we do not need any synchronization of accesses
full commit log file and apply just the entries needed for to the file system when reading from SSTables. As a re-
the tablets it needs to recover. However, under such a sult, concurrency control over rows can be implemented
scheme, if 100 machines were each assigned a single very efficiently. The only mutable data structure that is
tablet from a failed tablet server, then the log file would accessed by both reads and writes is the memtable. To re-
be read 100 times (once by each server). duce contention during reads of the memtable, we make
We avoid duplicating log reads by first sort- each memtable row copy-on-write and allow reads and
ing the commit log entries in order of the keys writes to proceed in parallel.
table, row name, log sequence number . In the Since SSTables are immutable, the problem of perma-
sorted output, all mutations for a particular tablet are nently removing deleted data is transformed to garbage
contiguous and can therefore be read efficiently with one collecting obsolete SSTables. Each tablet’s SSTables are
disk seek followed by a sequential read. To parallelize registered in the METADATA table. The master removes
the sorting, we partition the log file into 64 MB seg- obsolete SSTables as a mark-and-sweep garbage collec-
ments, and sort each segment in parallel on different tion [25] over the set of SSTables, where the METADATA
tablet servers. This sorting process is coordinated by the table contains the set of roots.
master and is initiated when a tablet server indicates that Finally, the immutability of SSTables enables us to
it needs to recover mutations from some commit log file. split tablets quickly. Instead of generating a new set of
Writing commit logs to GFS sometimes causes perfor- SSTables for each child tablet, we let the child tablets
mance hiccups for a variety of reasons (e.g., a GFS server share the SSTables of the parent tablet.
machine involved in the write crashes, or the network
paths traversed to reach the particular set of three GFS
servers is suffering network congestion, or is heavily 7 Performance Evaluation
loaded). To protect mutations from GFS latency spikes,
each tablet server actually has two log writing threads, We set up a Bigtable cluster with N tablet servers to
each writing to its own log file; only one of these two measure the performance and scalability of Bigtable as
threads is actively in use at a time. If writes to the ac- N is varied. The tablet servers were configured to use 1
tive log file are performing poorly, the log file writing is GB of memory and to write to a GFS cell consisting of
switched to the other thread, and mutations that are in 1786 machines with two 400 GB IDE hard drives each.
the commit log queue are written by the newly active log N client machines generated the Bigtable load used for
writing thread. Log entries contain sequence numbers these tests. (We used the same number of clients as tablet
to allow the recovery process to elide duplicated entries servers to ensure that clients were never a bottleneck.)
resulting from this log switching process. Each machine had two dual-core Opteron 2 GHz chips,
enough physical memory to hold the working set of all
running processes, and a single gigabit Ethernet link.
Speeding up tablet recovery The machines were arranged in a two-level tree-shaped
If the master moves a tablet from one tablet server to switched network with approximately 100-200 Gbps of
another, the source tablet server first does a minor com- aggregate bandwidth available at the root. All of the ma-
paction on that tablet. This compaction reduces recov- chines were in the same hosting facility and therefore the
ery time by reducing the amount of uncompacted state in round-trip time between any pair of machines was less
the tablet server’s commit log. After finishing this com- than a millisecond.
paction, the tablet server stops serving the tablet. Before The tablet servers and master, test clients, and GFS
it actually unloads the tablet, the tablet server does an- servers all ran on the same set of machines. Every ma-
other (usually very fast) minor compaction to eliminate chine ran a GFS server. Some of the machines also ran
any remaining uncompacted state in the tablet server’s either a tablet server, or a client process, or processes
log that arrived while the first minor compaction was from other jobs that were using the pool at the same time
being performed. After this second minor compaction as these experiments.
is complete, the tablet can be loaded on another tablet R is the distinct number of Bigtable row keys involved
server without requiring any recovery of log entries. in the test. R was chosen so that each benchmark read or
wrote approximately 1 GB of data per tablet server.
Exploiting immutability The sequential write benchmark used row keys with
names 0 to R − 1. This space of row keys was parti-
Besides the SSTable caches, various other parts of the tioned into 10N equal-sized ranges. These ranges were
Bigtable system have been simplified by the fact that all assigned to the N clients by a central scheduler that as-
To appear in OSDI 2006 8
9. Values read/written per second
4M
scans
# of Tablet Servers random reads (mem)
3M random writes
Experiment 1 50 250 500 sequential reads
random reads 1212 593 479 241 sequential writes
2M random reads
random reads (mem) 10811 8511 8000 6250
random writes 8850 3745 3425 2000
1M
sequential reads 4425 2463 2625 2469
sequential writes 8547 3623 2451 1905
scans 15385 10526 9524 7843 100 200 300 400 500
Number of tablet servers
Figure 6: Number of 1000-byte values read/written per second. The table shows the rate per tablet server; the graph shows the
aggregate rate.
signed the next available range to a client as soon as the Single tablet-server performance
client finished processing the previous range assigned to
it. This dynamic assignment helped mitigate the effects Let us first consider performance with just one tablet
of performance variations caused by other processes run- server. Random reads are slower than all other operations
ning on the client machines. We wrote a single string un- by an order of magnitude or more. Each random read in-
der each row key. Each string was generated randomly volves the transfer of a 64 KB SSTable block over the
and was therefore uncompressible. In addition, strings network from GFS to a tablet server, out of which only a
under different row key were distinct, so no cross-row single 1000-byte value is used. The tablet server executes
compression was possible. The random write benchmark approximately 1200 reads per second, which translates
was similar except that the row key was hashed modulo into approximately 75 MB/s of data read from GFS. This
R immediately before writing so that the write load was bandwidth is enough to saturate the tablet server CPUs
spread roughly uniformly across the entire row space for because of overheads in our networking stack, SSTable
the entire duration of the benchmark. parsing, and Bigtable code, and is also almost enough
to saturate the network links used in our system. Most
The sequential read benchmark generated row keys in Bigtable applications with this type of an access pattern
exactly the same way as the sequential write benchmark, reduce the block size to a smaller value, typically 8KB.
but instead of writing under the row key, it read the string Random reads from memory are much faster since
stored under the row key (which was written by an earlier each 1000-byte read is satisfied from the tablet server’s
invocation of the sequential write benchmark). Similarly, local memory without fetching a large 64 KB block from
the random read benchmark shadowed the operation of GFS.
the random write benchmark. Random and sequential writes perform better than ran-
The scan benchmark is similar to the sequential read dom reads since each tablet server appends all incoming
benchmark, but uses support provided by the Bigtable writes to a single commit log and uses group commit to
API for scanning over all values in a row range. Us- stream these writes efficiently to GFS. There is no sig-
ing a scan reduces the number of RPCs executed by the nificant difference between the performance of random
benchmark since a single RPC fetches a large sequence writes and sequential writes; in both cases, all writes to
of values from a tablet server. the tablet server are recorded in the same commit log.
Sequential reads perform better than random reads
The random reads (mem) benchmark is similar to the since every 64 KB SSTable block that is fetched from
random read benchmark, but the locality group that con- GFS is stored into our block cache, where it is used to
tains the benchmark data is marked as in-memory, and serve the next 64 read requests.
therefore the reads are satisfied from the tablet server’s Scans are even faster since the tablet server can return
memory instead of requiring a GFS read. For just this a large number of values in response to a single client
benchmark, we reduced the amount of data per tablet RPC, and therefore RPC overhead is amortized over a
server from 1 GB to 100 MB so that it would fit com- large number of values.
fortably in the memory available to the tablet server.
Figure 6 shows two views on the performance of our Scaling
benchmarks when reading and writing 1000-byte values
to Bigtable. The table shows the number of operations Aggregate throughput increases dramatically, by over a
per second per tablet server; the graph shows the aggre- factor of a hundred, as we increase the number of tablet
gate number of operations per second. servers in the system from 1 to 500. For example, the
To appear in OSDI 2006 9
10. # of tablet servers # of clusters percentage of data served from memory, and complexity
0 .. 19 259 of the table schema. In the rest of this section, we briefly
20 .. 49 47 describe how three product teams use Bigtable.
50 .. 99 20
100 .. 499 50
> 500 12 8.1 Google Analytics
Google Analytics (analytics.google.com) is a service
Table 1: Distribution of number of tablet servers in Bigtable that helps webmasters analyze traffic patterns at their
clusters. web sites. It provides aggregate statistics, such as the
number of unique visitors per day and the page views
per URL per day, as well as site-tracking reports, such as
performance of random reads from memory increases by the percentage of users that made a purchase, given that
almost a factor of 300 as the number of tablet server in- they earlier viewed a specific page.
creases by a factor of 500. This behavior occurs because To enable the service, webmasters embed a small
the bottleneck on performance for this benchmark is the JavaScript program in their web pages. This program
individual tablet server CPU. is invoked whenever a page is visited. It records various
However, performance does not increase linearly. For information about the request in Google Analytics, such
most benchmarks, there is a significant drop in per-server as a user identifier and information about the page be-
throughput when going from 1 to 50 tablet servers. This ing fetched. Google Analytics summarizes this data and
drop is caused by imbalance in load in multiple server makes it available to webmasters.
configurations, often due to other processes contending We briefly describe two of the tables used by Google
for CPU and network. Our load balancing algorithm at- Analytics. The raw click table (˜200 TB) maintains a
tempts to deal with this imbalance, but cannot do a per- row for each end-user session. The row name is a tuple
fect job for two main reasons: rebalancing is throttled to containing the website’s name and the time at which the
reduce the number of tablet movements (a tablet is un- session was created. This schema ensures that sessions
available for a short time, typically less than one second, that visit the same web site are contiguous, and that they
when it is moved), and the load generated by our bench- are sorted chronologically. This table compresses to 14%
marks shifts around as the benchmark progresses. of its original size.
The random read benchmark shows the worst scaling The summary table (˜20 TB) contains various prede-
(an increase in aggregate throughput by only a factor of fined summaries for each website. This table is gener-
100 for a 500-fold increase in number of servers). This ated from the raw click table by periodically scheduled
behavior occurs because (as explained above) we transfer MapReduce jobs. Each MapReduce job extracts recent
one large 64KB block over the network for every 1000- session data from the raw click table. The overall sys-
byte read. This transfer saturates various shared 1 Gi- tem’s throughput is limited by the throughput of GFS.
gabit links in our network and as a result, the per-server This table compresses to 29% of its original size.
throughput drops significantly as we increase the number
of machines.
8.2 Google Earth
8 Real Applications Google operates a collection of services that provide
users with access to high-resolution satellite imagery of
As of August 2006, there are 388 non-test Bigtable clus- the world’s surface, both through the web-based Google
ters running in various Google machine clusters, with a Maps interface (maps.google.com) and through the
combined total of about 24,500 tablet servers. Table 1 Google Earth (earth.google.com) custom client soft-
shows a rough distribution of tablet servers per cluster. ware. These products allow users to navigate across the
Many of these clusters are used for development pur- world’s surface: they can pan, view, and annotate satel-
poses and therefore are idle for significant periods. One lite imagery at many different levels of resolution. This
group of 14 busy clusters with 8069 total tablet servers system uses one table to preprocess data, and a different
saw an aggregate volume of more than 1.2 million re- set of tables for serving client data.
quests per second, with incoming RPC traffic of about The preprocessing pipeline uses one table to store raw
741 MB/s and outgoing RPC traffic of about 16 GB/s. imagery. During preprocessing, the imagery is cleaned
Table 2 provides some data about a few of the tables and consolidated into final serving data. This table con-
currently in use. Some tables store data that is served tains approximately 70 terabytes of data and therefore is
to users, whereas others store data for batch processing; served from disk. The images are efficiently compressed
the tables range widely in total size, average cell size, already, so Bigtable compression is disabled.
To appear in OSDI 2006 10
11. Project Table size Compression # Cells # Column # Locality % in Latency-
name (TB) ratio (billions) Families Groups memory sensitive?
Crawl 800 11% 1000 16 8 0% No
Crawl 50 33% 200 2 2 0% No
Google Analytics 20 29% 10 1 1 0% Yes
Google Analytics 200 14% 80 1 1 0% Yes
Google Base 2 31% 10 29 3 15% Yes
Google Earth 0.5 64% 8 7 2 33% Yes
Google Earth 70 – 9 8 3 0% No
Orkut 9 – 0.9 8 5 1% Yes
Personalized Search 4 47% 6 93 11 5% Yes
Table 2: Characteristics of a few tables in production use. Table size (measured before compression) and # Cells indicate approxi-
mate sizes. Compression ratio is not given for tables that have compression disabled.
Each row in the imagery table corresponds to a sin- The Personalized Search data is replicated across sev-
gle geographic segment. Rows are named to ensure that eral Bigtable clusters to increase availability and to re-
adjacent geographic segments are stored near each other. duce latency due to distance from clients. The Personal-
The table contains a column family to keep track of the ized Search team originally built a client-side replication
sources of data for each segment. This column family mechanism on top of Bigtable that ensured eventual con-
has a large number of columns: essentially one for each sistency of all replicas. The current system now uses a
raw data image. Since each segment is only built from a replication subsystem that is built into the servers.
few images, this column family is very sparse. The design of the Personalized Search storage system
The preprocessing pipeline relies heavily on MapRe- allows other groups to add new per-user information in
duce over Bigtable to transform data. The overall system their own columns, and the system is now used by many
processes over 1 MB/sec of data per tablet server during other Google properties that need to store per-user con-
some of these MapReduce jobs. figuration options and settings. Sharing a table amongst
The serving system uses one table to index data stored many groups resulted in an unusually large number of
in GFS. This table is relatively small (˜500 GB), but it column families. To help support sharing, we added a
must serve tens of thousands of queries per second per simple quota mechanism to Bigtable to limit the stor-
datacenter with low latency. As a result, this table is age consumption by any particular client in shared ta-
hosted across hundreds of tablet servers and contains in- bles; this mechanism provides some isolation between
memory column families. the various product groups using this system for per-user
information storage.
8.3 Personalized Search
9 Lessons
Personalized Search (www.google.com/psearch) is an
opt-in service that records user queries and clicks across In the process of designing, implementing, maintaining,
a variety of Google properties such as web search, im- and supporting Bigtable, we gained useful experience
ages, and news. Users can browse their search histories and learned several interesting lessons.
to revisit their old queries and clicks, and they can ask One lesson we learned is that large distributed sys-
for personalized search results based on their historical tems are vulnerable to many types of failures, not just
Google usage patterns. the standard network partitions and fail-stop failures as-
Personalized Search stores each user’s data in sumed in many distributed protocols. For example, we
Bigtable. Each user has a unique userid and is assigned have seen problems due to all of the following causes:
a row named by that userid. All user actions are stored memory and network corruption, large clock skew, hung
in a table. A separate column family is reserved for each machines, extended and asymmetric network partitions,
type of action (for example, there is a column family that bugs in other systems that we are using (Chubby for ex-
stores all web queries). Each data element uses as its ample), overflow of GFS quotas, and planned and un-
Bigtable timestamp the time at which the corresponding planned hardware maintenance. As we have gained more
user action occurred. Personalized Search generates user experience with these problems, we have addressed them
profiles using a MapReduce over Bigtable. These user by changing various protocols. For example, we added
profiles are used to personalize live search results. checksumming to our RPC mechanism. We also handled
To appear in OSDI 2006 11
12. some problems by removing assumptions made by one the behavior of Chubby features that were seldom exer-
part of the system about another part. For example, we cised by other applications. We discovered that we were
stopped assuming a given Chubby operation could return spending an inordinate amount of time debugging ob-
only one of a fixed set of errors. scure corner cases, not only in Bigtable code, but also in
Another lesson we learned is that it is important to Chubby code. Eventually, we scrapped this protocol and
delay adding new features until it is clear how the new moved to a newer simpler protocol that depends solely
features will be used. For example, we initially planned on widely-used Chubby features.
to support general-purpose transactions in our API. Be-
cause we did not have an immediate use for them, how- 10 Related Work
ever, we did not implement them. Now that we have
many real applications running on Bigtable, we have The Boxwood project [24] has components that overlap
been able to examine their actual needs, and have discov- in some ways with Chubby, GFS, and Bigtable, since it
ered that most applications require only single-row trans- provides for distributed agreement, locking, distributed
actions. Where people have requested distributed trans- chunk storage, and distributed B-tree storage. In each
actions, the most important use is for maintaining sec- case where there is overlap, it appears that the Box-
ondary indices, and we plan to add a specialized mech- wood’s component is targeted at a somewhat lower level
anism to satisfy this need. The new mechanism will than the corresponding Google service. The Boxwood
be less general than distributed transactions, but will be project’s goal is to provide infrastructure for building
more efficient (especially for updates that span hundreds higher-level services such as file systems or databases,
of rows or more) and will also interact better with our while the goal of Bigtable is to directly support client
scheme for optimistic cross-data-center replication. applications that wish to store data.
A practical lesson that we learned from supporting Many recent projects have tackled the problem of pro-
Bigtable is the importance of proper system-level mon- viding distributed storage or higher-level services over
itoring (i.e., monitoring both Bigtable itself, as well as wide area networks, often at “Internet scale.” This in-
the client processes using Bigtable). For example, we ex- cludes work on distributed hash tables that began with
tended our RPC system so that for a sample of the RPCs, projects such as CAN [29], Chord [32], Tapestry [37],
it keeps a detailed trace of the important actions done on and Pastry [30]. These systems address concerns that do
behalf of that RPC. This feature has allowed us to de- not arise for Bigtable, such as highly variable bandwidth,
tect and fix many problems such as lock contention on untrusted participants, or frequent reconfiguration; de-
tablet data structures, slow writes to GFS while com- centralized control and Byzantine fault tolerance are not
mitting Bigtable mutations, and stuck accesses to the Bigtable goals.
METADATA table when METADATA tablets are unavail- In terms of the distributed data storage model that one
able. Another example of useful monitoring is that ev- might provide to application developers, we believe the
ery Bigtable cluster is registered in Chubby. This allows key-value pair model provided by distributed B-trees or
us to track down all clusters, discover how big they are, distributed hash tables is too limiting. Key-value pairs
see which versions of our software they are running, how are a useful building block, but they should not be the
much traffic they are receiving, and whether or not there only building block one provides to developers. The
are any problems such as unexpectedly large latencies. model we chose is richer than simple key-value pairs,
The most important lesson we learned is the value and supports sparse semi-structured data. Nonetheless,
of simple designs. Given both the size of our system it is still simple enough that it lends itself to a very effi-
(about 100,000 lines of non-test code), as well as the cient flat-file representation, and it is transparent enough
fact that code evolves over time in unexpected ways, we (via locality groups) to allow our users to tune important
have found that code and design clarity are of immense behaviors of the system.
help in code maintenance and debugging. One exam- Several database vendors have developed parallel
ple of this is our tablet-server membership protocol. Our databases that can store large volumes of data. Oracle’s
first protocol was simple: the master periodically issued Real Application Cluster database [27] uses shared disks
leases to tablet servers, and tablet servers killed them- to store data (Bigtable uses GFS) and a distributed lock
selves if their lease expired. Unfortunately, this proto- manager (Bigtable uses Chubby). IBM’s DB2 Parallel
col reduced availability significantly in the presence of Edition [4] is based on a shared-nothing [33] architecture
network problems, and was also sensitive to master re- similar to Bigtable. Each DB2 server is responsible for
covery time. We redesigned the protocol several times a subset of the rows in a table which it stores in a local
until we had a protocol that performed well. However, relational database. Both products provide a complete
the resulting protocol was too complex and depended on relational model with transactions.
To appear in OSDI 2006 12
13. Bigtable locality groups realize similar compression Given the unusual interface to Bigtable, an interest-
and disk read performance benefits observed for other ing question is how difficult it has been for our users to
systems that organize data on disk using column-based adapt to using it. New users are sometimes uncertain of
rather than row-based storage, including C-Store [1, 34] how to best use the Bigtable interface, particularly if they
and commercial products such as Sybase IQ [15, 36], are accustomed to using relational databases that support
SenSage [31], KDB+ [22], and the ColumnBM storage general-purpose transactions. Nevertheless, the fact that
layer in MonetDB/X100 [38]. Another system that does many Google products successfully use Bigtable demon-
vertical and horizontal data partioning into flat files and strates that our design works well in practice.
achieves good data compression ratios is AT&T’s Day- We are in the process of implementing several addi-
tona database [19]. Locality groups do not support CPU- tional Bigtable features, such as support for secondary
cache-level optimizations, such as those described by indices and infrastructure for building cross-data-center
Ailamaki [2]. replicated Bigtables with multiple master replicas. We
The manner in which Bigtable uses memtables and have also begun deploying Bigtable as a service to prod-
SSTables to store updates to tablets is analogous to the uct groups, so that individual groups do not need to main-
way that the Log-Structured Merge Tree [26] stores up- tain their own clusters. As our service clusters scale,
dates to index data. In both systems, sorted data is we will need to deal with more resource-sharing issues
buffered in memory before being written to disk, and within Bigtable itself [3, 5].
reads must merge data from memory and disk. Finally, we have found that there are significant ad-
C-Store and Bigtable share many characteristics: both vantages to building our own storage solution at Google.
systems use a shared-nothing architecture and have two We have gotten a substantial amount of flexibility from
different data structures, one for recent writes, and one designing our own data model for Bigtable. In addi-
for storing long-lived data, with a mechanism for mov- tion, our control over Bigtable’s implementation, and
ing data from one form to the other. The systems dif- the other Google infrastructure upon which Bigtable de-
fer significantly in their API: C-Store behaves like a pends, means that we can remove bottlenecks and ineffi-
relational database, whereas Bigtable provides a lower ciencies as they arise.
level read and write interface and is designed to support
many thousands of such operations per second per server. Acknowledgements
C-Store is also a “read-optimized relational DBMS”,
whereas Bigtable provides good performance on both We thank the anonymous reviewers, David Nagle, and
read-intensive and write-intensive applications. our shepherd Brad Calder, for their feedback on this pa-
Bigtable’s load balancer has to solve some of the same per. The Bigtable system has benefited greatly from the
kinds of load and memory balancing problems faced by feedback of our many users within Google. In addition,
shared-nothing databases (e.g., [11, 35]). Our problem is we thank the following people for their contributions to
somewhat simpler: (1) we do not consider the possibility Bigtable: Dan Aguayo, Sameer Ajmani, Zhifeng Chen,
of multiple copies of the same data, possibly in alternate Bill Coughran, Mike Epstein, Healfdene Goguen, Robert
forms due to views or indices; (2) we let the user tell us Griesemer, Jeremy Hylton, Josh Hyman, Alex Khesin,
what data belongs in memory and what data should stay Joanna Kulik, Alberto Lerner, Sherry Listgarten, Mike
on disk, rather than trying to determine this dynamically; Maloney, Eduardo Pinheiro, Kathy Polizzi, Frank Yellin,
(3) we have no complex queries to execute or optimize. and Arthur Zwiegincew.
References
11 Conclusions [1] A BADI , D. J., M ADDEN , S. R., AND F ERREIRA ,
M. C. Integrating compression and execution in column-
We have described Bigtable, a distributed system for oriented database systems. Proc. of SIGMOD (2006).
storing structured data at Google. Bigtable clusters have [2] A ILAMAKI , A., D E W ITT, D. J., H ILL , M. D., AND S K -
been in production use since April 2005, and we spent OUNAKIS , M. Weaving relations for cache performance.
roughly seven person-years on design and implementa- In The VLDB Journal (2001), pp. 169–180.
tion before that date. As of August 2006, more than sixty [3] BANGA , G., D RUSCHEL , P., AND M OGUL , J. C. Re-
projects are using Bigtable. Our users like the perfor- source containers: A new facility for resource manage-
mance and high availability provided by the Bigtable im- ment in server systems. In Proc. of the 3rd OSDI (Feb.
plementation, and that they can scale the capacity of their 1999), pp. 45–58.
clusters by simply adding more machines to the system [4] BARU , C. K., F ECTEAU , G., G OYAL , A., H SIAO ,
as their resource demands change over time. H., J HINGRAN , A., PADMANABHAN , S., C OPELAND ,
To appear in OSDI 2006 13
14. G. P., AND W ILSON , W. G. DB2 parallel edition. IBM [22] KX . COM . kx.com/products/database.php. Product page.
Systems Journal 34, 2 (1995), 292–322. [23] L AMPORT, L. The part-time parliament. ACM TOCS 16,
[5] BAVIER , A., B OWMAN , M., C HUN , B., C ULLER , D., 2 (1998), 133–169.
K ARLIN , S., P ETERSON , L., ROSCOE , T., S PALINK , T., [24] M AC C ORMICK , J., M URPHY, N., NAJORK , M.,
AND WAWRZONIAK , M. Operating system support for T HEKKATH , C. A., AND Z HOU , L. Boxwood: Abstrac-
planetary-scale network services. In Proc. of the 1st NSDI tions as the foundation for storage infrastructure. In Proc.
(Mar. 2004), pp. 253–266. of the 6th OSDI (Dec. 2004), pp. 105–120.
[6] B ENTLEY, J. L., AND M C I LROY, M. D. Data compres- [25] M C C ARTHY, J. Recursive functions of symbolic expres-
sion using long common strings. In Data Compression sions and their computation by machine. CACM 3, 4 (Apr.
Conference (1999), pp. 287–295. 1960), 184–195.
[7] B LOOM , B. H. Space/time trade-offs in hash coding with [26] O’N EIL , P., C HENG , E., G AWLICK , D., AND O’N EIL ,
allowable errors. CACM 13, 7 (1970), 422–426. E. The log-structured merge-tree (LSM-tree). Acta Inf.
[8] B URROWS , M. The Chubby lock service for loosely- 33, 4 (1996), 351–385.
coupled distributed systems. In Proc. of the 7th OSDI [27] ORACLE . COM . www.oracle.com/technology/products/-
(Nov. 2006). database/clustering/index.html. Product page.
[9] C HANDRA , T., G RIESEMER , R., AND R EDSTONE , J. [28] P IKE , R., D ORWARD , S., G RIESEMER , R., AND Q UIN -
Paxos made live — An engineering perspective. In Proc. LAN , S. Interpreting the data: Parallel analysis with
of PODC (2007). Sawzall. Scientific Programming Journal 13, 4 (2005),
227–298.
[10] C OMER , D. Ubiquitous B-tree. Computing Surveys 11, 2
(June 1979), 121–137. [29] R ATNASAMY, S., F RANCIS , P., H ANDLEY, M., K ARP,
R., AND S HENKER , S. A scalable content-addressable
[11] C OPELAND , G. P., A LEXANDER , W., B OUGHTER ,
network. In Proc. of SIGCOMM (Aug. 2001), pp. 161–
E. E., AND K ELLER , T. W. Data placement in Bubba. In
172.
Proc. of SIGMOD (1988), pp. 99–108.
[30] ROWSTRON , A., AND D RUSCHEL , P. Pastry: Scal-
[12] D EAN , J., AND G HEMAWAT, S. MapReduce: Simplified able, distributed object location and routing for large-
data processing on large clusters. In Proc. of the 6th OSDI scale peer-to-peer systems. In Proc. of Middleware 2001
(Dec. 2004), pp. 137–150. (Nov. 2001), pp. 329–350.
[13] D E W ITT, D., K ATZ , R., O LKEN , F., S HAPIRO , L., [31] SENSAGE . COM . sensage.com/products-sensage.htm.
S TONEBRAKER , M., AND W OOD , D. Implementation Product page.
techniques for main memory database systems. In Proc.
[32] S TOICA , I., M ORRIS , R., K ARGER , D., K AASHOEK ,
of SIGMOD (June 1984), pp. 1–8.
M. F., AND BALAKRISHNAN , H. Chord: A scalable
[14] D E W ITT, D. J., AND G RAY, J. Parallel database sys- peer-to-peer lookup service for Internet applications. In
tems: The future of high performance database systems. Proc. of SIGCOMM (Aug. 2001), pp. 149–160.
CACM 35, 6 (June 1992), 85–98.
[33] S TONEBRAKER , M. The case for shared nothing.
[15] F RENCH , C. D. One size fits all database architectures Database Engineering Bulletin 9, 1 (Mar. 1986), 4–9.
do not work for DSS. In Proc. of SIGMOD (May 1995),
[34] S TONEBRAKER , M., A BADI , D. J., BATKIN , A., C HEN ,
pp. 449–450.
X., C HERNIACK , M., F ERREIRA , M., L AU , E., L IN ,
[16] G AWLICK , D., AND K INKADE , D. Varieties of concur- A., M ADDEN , S., O’N EIL , E., O’N EIL , P., R ASIN ,
rency control in IMS/VS fast path. Database Engineering A., T RAN , N., AND Z DONIK , S. C-Store: A column-
Bulletin 8, 2 (1985), 3–10. oriented DBMS. In Proc. of VLDB (Aug. 2005), pp. 553–
[17] G HEMAWAT, S., G OBIOFF , H., AND L EUNG , S.-T. The 564.
Google file system. In Proc. of the 19th ACM SOSP (Dec. [35] S TONEBRAKER , M., AOKI , P. M., D EVINE , R.,
2003), pp. 29–43. L ITWIN , W., AND O LSON , M. A. Mariposa: A new ar-
[18] G RAY, J. Notes on database operating systems. In Oper- chitecture for distributed data. In Proc. of the Tenth ICDE
ating Systems — An Advanced Course, vol. 60 of Lecture (1994), IEEE Computer Society, pp. 54–65.
Notes in Computer Science. Springer-Verlag, 1978. [36] SYBASE . COM . www.sybase.com/products/database-
[19] G REER , R. Daytona and the fourth-generation language servers/sybaseiq. Product page.
Cymbal. In Proc. of SIGMOD (1999), pp. 525–526. [37] Z HAO , B. Y., K UBIATOWICZ , J., AND J OSEPH , A. D.
Tapestry: An infrastructure for fault-tolerant wide-area
[20] H AGMANN , R. Reimplementing the Cedar file system
location and routing. Tech. Rep. UCB/CSD-01-1141, CS
using logging and group commit. In Proc. of the 11th
Division, UC Berkeley, Apr. 2001.
SOSP (Dec. 1987), pp. 155–162.
[38] Z UKOWSKI , M., B ONCZ , P. A., N ES , N., AND H EMAN ,
[21] H ARTMAN , J. H., AND O USTERHOUT, J. K. The Zebra
S. MonetDB/X100 — A DBMS in the CPU cache. IEEE
striped network file system. In Proc. of the 14th SOSP
Data Eng. Bull. 28, 2 (2005), 17–22.
(Asheville, NC, 1993), pp. 29–43.
To appear in OSDI 2006 14