Query Execution in Column-Oriented Database Systems. Abadi, D. J. MIT PhD Dissertation, 2008. SIGMOD Jim Gray Doctoral Dissertation Award![Query Execution in Column-Oriented Database Systems [pdf]](https://bibbase.org/img/filetypes/pdf.svg "pdf")
Paper abstract bibtex There are two obvious ways to map a two-dimension relational database table onto a one-dimensional storage interface: store the table row-by-row, or store the table column-by-column. Historically, database system implementations and research have focused on the row-by row data layout, since it performs best on the most common application for database systems: business transactional data processing. However, there are a set of emerging applications for database systems for which the row-by-row layout performs poorly. These applications are more analytical in nature, whose goal is to read through the data to gain new insight and use it to drive decision making and planning. In this dissertation, we study the problem of poor performance of row-by-row data layout for these emerging applications, and evaluate the column-by-column data layout opportunity as a solution to this problem. There have been a variety of proposals in the literature for how to build a database system on top of column-by-column layout. These proposals have different levels of implementation effort, and have different performance characteristics. If one wanted to build a new database system that utilizes the column-by-column data layout, it is unclear which proposal to follow. This dissertation provides (to the best of our knowledge) the only detailed study of mutliple implementation approaches of such systems, categorizing the different approaches into three broad categories, and evaluating the tradeoffs between approaches. We conclude that building a query executer specifically designed for the column-by-column query layout is essensial to acheive good performance. Consequently, we describe the implementation of C-Store, a new database system with a storage layer and query executer built for column-by-column data layout. We introduce three new query execution technqiues that significantly improve performance. First, we look at the problem of integrating compression and execution so that the query executer is capable of directly operating on compressed data. This improves performance by improving I/O (less data needs to be read off disk), and CPU (the data need not be decompressed). We describe our solution to the problem of executer extensibility - how can new compression techniques be added to the system without having to rewrite the operator code? Second, we analyze the problem of tuple construction (stitching together attributes from multiple columns into a row-oriented ``tuple''). Tuple construction is required when operators need to access multiple attributes from the same tuple; however, if done at the wrong point in a query plan, a significant performance penalty is paid. We introduce an analytical model and some heuristics to use that help decide when in a query plan tuple construction should occur. Third, we introduce a new join technique, the ``invisible join'' that improves performance of a specific type of join that is common in the applications for which column-by-column data layout is a good idea. Finally, we benchmark performance of the complete C-Store database system against other column-oriented database system implementation approachs, and against row-oriented databases. We benchmark two applications. The first application is a typical analytical application for which column-by-column data layout is known to outperform row-by-row data layout. The second application is another emerging application, the Semantic Web, for which column-oriented database systems are not currently used. We find that on the first application, the complete C-Store system performed 10 to 18 times faster than alternative column-store implementation approaches, and 6 to 12 times faster than a commercial database system that uses a row-by-row data layout. On the Semantic Web application, we find that C-Store outperforms other state-of-the-art data management techniques by an order of magnitude, and outperforms other common data management technqiues by almost two orders of magnitude. Benchmark queries, which used to take multiple minutes to execute, can now be answered in several seconds.
@misc{abadi-phd,
author = {Daniel J. Abadi},
title = {Query Execution in Column-Oriented Database Systems},
howpublished = {MIT PhD Dissertation},
year = {2008},
url_Paper = "http://www.cs.umd.edu/~abadi/papers/abadiphd.pdf",
abstract = "There are two obvious ways to map a two-dimension relational database table onto a one-dimensional storage interface: store the table row-by-row, or store the table column-by-column. Historically, database system implementations and research have focused on the row-by row data layout, since it performs best on the most common application for database systems: business transactional data processing. However, there are a set of emerging applications for database systems for which the row-by-row layout performs poorly. These applications are more analytical in nature, whose goal is to read through the data to gain new insight and use it to drive decision making and planning. In this dissertation, we study the problem of poor performance of row-by-row data layout for these emerging applications, and evaluate the column-by-column data layout opportunity as a solution to this problem. There have been a variety of proposals in the literature for how to build a database system on top of column-by-column layout. These proposals have different levels of implementation effort, and have different performance characteristics. If one wanted to build a new database system that utilizes the column-by-column data layout, it is unclear which proposal to follow. This dissertation provides (to the best of our knowledge) the only detailed study of mutliple implementation approaches of such systems, categorizing the different approaches into three broad categories, and evaluating the tradeoffs between approaches. We conclude that building a query executer specifically designed for the column-by-column query layout is essensial to acheive good performance. Consequently, we describe the implementation of C-Store, a new database system with a storage layer and query executer built for column-by-column data layout. We introduce three new query execution technqiues that significantly improve performance. First, we look at the problem of integrating compression and execution so that the query executer is capable of directly operating on compressed data. This improves performance by improving I/O (less data needs to be read off disk), and CPU (the data need not be decompressed). We describe our solution to the problem of executer extensibility - how can new compression techniques be added to the system without having to rewrite the operator code? Second, we analyze the problem of tuple construction (stitching together attributes from multiple columns into a row-oriented ``tuple''). Tuple construction is required when operators need to access multiple attributes from the same tuple; however, if done at the wrong point in a query plan, a significant performance penalty is paid. We introduce an analytical model and some heuristics to use that help decide when in a query plan tuple construction should occur. Third, we introduce a new join technique, the ``invisible join'' that improves performance of a specific type of join that is common in the applications for which column-by-column data layout is a good idea. Finally, we benchmark performance of the complete C-Store database system against other column-oriented database system implementation approachs, and against row-oriented databases. We benchmark two applications. The first application is a typical analytical application for which column-by-column data layout is known to outperform row-by-row data layout. The second application is another emerging application, the Semantic Web, for which column-oriented database systems are not currently used. We find that on the first application, the complete C-Store system performed 10 to 18 times faster than alternative column-store implementation approaches, and 6 to 12 times faster than a commercial database system that uses a row-by-row data layout. On the Semantic Web application, we find that C-Store outperforms other state-of-the-art data management techniques by an order of magnitude, and outperforms other common data management technqiues by almost two orders of magnitude. Benchmark queries, which used to take multiple minutes to execute, can now be answered in several seconds.",
pdfKB = "1301",
publicationtype = "Thesis",
oldnote = "PhD Thesis",
award = "SIGMOD Jim Gray Doctoral Dissertation Award (2008)",
note = "<u>SIGMOD Jim Gray Doctoral Dissertation Award</u>",
displayCategory = "Phd Thesis",
keywords = "Scalable queries,Parallel database systems,Analytical database systems,Column-stores,C-Store",
project:multiple = "C-Store",
}
Downloads: 0
{"_id":"jg8QxWuwznh75ym37","bibbaseid":"abadi-queryexecutionincolumnorienteddatabasesystems-2008","downloads":0,"creationDate":"2018-07-19T20:49:30.518Z","title":"Query Execution in Column-Oriented Database Systems","author_short":["Abadi, D. J."],"year":2008,"bibtype":"misc","biburl":"https://www.cs.umd.edu/~abadi/pubs/abadirefs.bib","bibdata":{"bibtype":"misc","type":"misc","author":[{"firstnames":["Daniel","J."],"propositions":[],"lastnames":["Abadi"],"suffixes":[]}],"title":"Query Execution in Column-Oriented Database Systems","howpublished":"MIT PhD Dissertation","year":"2008","url_paper":"http://www.cs.umd.edu/~abadi/papers/abadiphd.pdf","abstract":"There are two obvious ways to map a two-dimension relational database table onto a one-dimensional storage interface: store the table row-by-row, or store the table column-by-column. Historically, database system implementations and research have focused on the row-by row data layout, since it performs best on the most common application for database systems: business transactional data processing. However, there are a set of emerging applications for database systems for which the row-by-row layout performs poorly. These applications are more analytical in nature, whose goal is to read through the data to gain new insight and use it to drive decision making and planning. In this dissertation, we study the problem of poor performance of row-by-row data layout for these emerging applications, and evaluate the column-by-column data layout opportunity as a solution to this problem. There have been a variety of proposals in the literature for how to build a database system on top of column-by-column layout. These proposals have different levels of implementation effort, and have different performance characteristics. If one wanted to build a new database system that utilizes the column-by-column data layout, it is unclear which proposal to follow. This dissertation provides (to the best of our knowledge) the only detailed study of mutliple implementation approaches of such systems, categorizing the different approaches into three broad categories, and evaluating the tradeoffs between approaches. We conclude that building a query executer specifically designed for the column-by-column query layout is essensial to acheive good performance. Consequently, we describe the implementation of C-Store, a new database system with a storage layer and query executer built for column-by-column data layout. We introduce three new query execution technqiues that significantly improve performance. First, we look at the problem of integrating compression and execution so that the query executer is capable of directly operating on compressed data. This improves performance by improving I/O (less data needs to be read off disk), and CPU (the data need not be decompressed). We describe our solution to the problem of executer extensibility - how can new compression techniques be added to the system without having to rewrite the operator code? Second, we analyze the problem of tuple construction (stitching together attributes from multiple columns into a row-oriented ``tuple''). Tuple construction is required when operators need to access multiple attributes from the same tuple; however, if done at the wrong point in a query plan, a significant performance penalty is paid. We introduce an analytical model and some heuristics to use that help decide when in a query plan tuple construction should occur. Third, we introduce a new join technique, the ``invisible join'' that improves performance of a specific type of join that is common in the applications for which column-by-column data layout is a good idea. Finally, we benchmark performance of the complete C-Store database system against other column-oriented database system implementation approachs, and against row-oriented databases. We benchmark two applications. The first application is a typical analytical application for which column-by-column data layout is known to outperform row-by-row data layout. The second application is another emerging application, the Semantic Web, for which column-oriented database systems are not currently used. We find that on the first application, the complete C-Store system performed 10 to 18 times faster than alternative column-store implementation approaches, and 6 to 12 times faster than a commercial database system that uses a row-by-row data layout. On the Semantic Web application, we find that C-Store outperforms other state-of-the-art data management techniques by an order of magnitude, and outperforms other common data management technqiues by almost two orders of magnitude. Benchmark queries, which used to take multiple minutes to execute, can now be answered in several seconds.","pdfkb":"1301","publicationtype":"Thesis","oldnote":"PhD Thesis","award":"SIGMOD Jim Gray Doctoral Dissertation Award (2008)","note":"<u>SIGMOD Jim Gray Doctoral Dissertation Award</u>","displaycategory":"Phd Thesis","keywords":"Scalable queries,Parallel database systems,Analytical database systems,Column-stores,C-Store","project:multiple":"C-Store","bibtex":"@misc{abadi-phd,\n author = {Daniel J. Abadi},\n title = {Query Execution in Column-Oriented Database Systems},\n howpublished = {MIT PhD Dissertation},\n year = {2008},\n url_Paper = \"http://www.cs.umd.edu/~abadi/papers/abadiphd.pdf\",\n abstract = \"There are two obvious ways to map a two-dimension relational database table onto a one-dimensional storage interface: store the table row-by-row, or store the table column-by-column. Historically, database system implementations and research have focused on the row-by row data layout, since it performs best on the most common application for database systems: business transactional data processing. However, there are a set of emerging applications for database systems for which the row-by-row layout performs poorly. These applications are more analytical in nature, whose goal is to read through the data to gain new insight and use it to drive decision making and planning. In this dissertation, we study the problem of poor performance of row-by-row data layout for these emerging applications, and evaluate the column-by-column data layout opportunity as a solution to this problem. There have been a variety of proposals in the literature for how to build a database system on top of column-by-column layout. These proposals have different levels of implementation effort, and have different performance characteristics. If one wanted to build a new database system that utilizes the column-by-column data layout, it is unclear which proposal to follow. This dissertation provides (to the best of our knowledge) the only detailed study of mutliple implementation approaches of such systems, categorizing the different approaches into three broad categories, and evaluating the tradeoffs between approaches. We conclude that building a query executer specifically designed for the column-by-column query layout is essensial to acheive good performance. Consequently, we describe the implementation of C-Store, a new database system with a storage layer and query executer built for column-by-column data layout. We introduce three new query execution technqiues that significantly improve performance. First, we look at the problem of integrating compression and execution so that the query executer is capable of directly operating on compressed data. This improves performance by improving I/O (less data needs to be read off disk), and CPU (the data need not be decompressed). We describe our solution to the problem of executer extensibility - how can new compression techniques be added to the system without having to rewrite the operator code? Second, we analyze the problem of tuple construction (stitching together attributes from multiple columns into a row-oriented ``tuple''). Tuple construction is required when operators need to access multiple attributes from the same tuple; however, if done at the wrong point in a query plan, a significant performance penalty is paid. We introduce an analytical model and some heuristics to use that help decide when in a query plan tuple construction should occur. Third, we introduce a new join technique, the ``invisible join'' that improves performance of a specific type of join that is common in the applications for which column-by-column data layout is a good idea. Finally, we benchmark performance of the complete C-Store database system against other column-oriented database system implementation approachs, and against row-oriented databases. We benchmark two applications. The first application is a typical analytical application for which column-by-column data layout is known to outperform row-by-row data layout. The second application is another emerging application, the Semantic Web, for which column-oriented database systems are not currently used. We find that on the first application, the complete C-Store system performed 10 to 18 times faster than alternative column-store implementation approaches, and 6 to 12 times faster than a commercial database system that uses a row-by-row data layout. On the Semantic Web application, we find that C-Store outperforms other state-of-the-art data management techniques by an order of magnitude, and outperforms other common data management technqiues by almost two orders of magnitude. Benchmark queries, which used to take multiple minutes to execute, can now be answered in several seconds.\",\n pdfKB = \"1301\",\n publicationtype = \"Thesis\",\n oldnote = \"PhD Thesis\",\n award = \"SIGMOD Jim Gray Doctoral Dissertation Award (2008)\",\n note = \"<u>SIGMOD Jim Gray Doctoral Dissertation Award</u>\",\n displayCategory = \"Phd Thesis\",\n keywords = \"Scalable queries,Parallel database systems,Analytical database systems,Column-stores,C-Store\",\n project:multiple = \"C-Store\",\n}\n\n","author_short":["Abadi, D. J."],"key":"abadi-phd","id":"abadi-phd","bibbaseid":"abadi-queryexecutionincolumnorienteddatabasesystems-2008","role":"author","urls":{" paper":"http://www.cs.umd.edu/~abadi/papers/abadiphd.pdf"},"keyword":["Scalable queries","Parallel database systems","Analytical database systems","Column-stores","C-Store"],"metadata":{"authorlinks":{"abadi, d":"https://www.cs.umd.edu/~abadi/pubs/pubs.shtml"}},"downloads":0,"html":""},"search_terms":["query","execution","column","oriented","database","systems","abadi"],"keywords":["scalable queries","parallel database systems","analytical database systems","column-stores","c-store"],"authorIDs":["545a372eb43425b772000d33","5GWfruXC8LGzsXQXZ","5dfafc2efa2bbbde01000123","5dfb4da1e04f92df01000122","5e0293fd64e549de01000015","5e07201f865432df01000050","5e0f3ab32c4a31df01000058","5e10fe46d6a01ede0100002d","5e18dd1da382e2de0100010a","5e196b6773bf69de01000051","5e1ed08b875c69df01000020","5e26cfec8535cedf01000169","5e28e675a3df5bdf0100013e","5e399a48d14579de0100029c","5e4aad9315f6c7df010000b3","5e59b208103b4fde0100000e","5e64a5a32551dede01000064","KDBQuK7XWc7CSqeit","LJreXapK6mk9Rc2Pu","N6yBEFnvRGqjThfK2","RspDsBhJKZKQBkgAw","Wp5ihSMdeiMT82YBn","e6qD3P7b8FZJE3FJf","ffuc7EABFba74ArWY","jhL6i2R8YgkXCbPae","oHD5MJpPt7u6NoDGo","qJmCcnJn6k7RTKK8o","wBCK972mKn88A3K3r","zfX7BeExuv4gc7kfg"],"dataSources":["YdtR8AbetSqiZGCey","MPg4deo7Xr6HYSthD","bHTCYJduhkrS5AHxu"]}