
<!DOCTYPE html>
<!--
 Generated by Apache Maven Doxia at 2016-02-24
 Rendered using Reflow Maven Skin 1.1.1 (http://andriusvelykis.github.io/reflow-maven-skin)
-->
<html  xml:lang="en" lang="en">

	<head>
		<meta charset="UTF-8" />
		<title>Apache Trafodion Frequently Asked Questions</title>
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<meta name="description" content="" />
		<meta http-equiv="content-language" content="en" />

		<link href="http://netdna.bootstrapcdn.com/bootswatch/2.3.2/cerulean/bootstrap.min.css" rel="stylesheet" />
		<link href="http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.1/css/bootstrap-responsive.min.css" rel="stylesheet" />
		<link href="./css/bootswatch.css" rel="stylesheet" />
		<link href="./css/reflow-skin.css" rel="stylesheet" />

		<link href="http://yandex.st/highlightjs/7.5/styles/default.min.css" rel="stylesheet" />

		<link href="./css/lightbox.css" rel="stylesheet" />

		<link href="./css/site.css" rel="stylesheet" />
		<link href="./css/print.css" rel="stylesheet" media="print" />

		<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
		<!--[if lt IE 9]>
			<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
		<![endif]-->



		<!-- Google Analytics -->
		<script type="text/javascript">

			var _gaq = _gaq || [];
			_gaq.push(['_setAccount', 'UA-72491210-1']);
			_gaq.push(['_trackPageview']);

			(function() {
				var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
				ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
				var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
			})();

		</script>
		</head>

	<body class="page-faq project-trafodion" data-spy="scroll" data-offset="60" data-target="#toc-scroll-target">

		<div class="navbar navbar-fixed-top">
			<div class="navbar-inner">
				<div class="container">
					<a class="btn btn-navbar" data-toggle="collapse" data-target="#top-nav-collapse">
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
					</a>
					<a class="brand" href="index.html">Apache <span class="color-highlight">Trafodion</span></a>
					<div class="nav-collapse collapse" id="top-nav-collapse">
						<ul class="nav pull-right">
							<li ><a href="download.html" title="Download">Download</a></li>
							<li ><a href="quickstart.html" title="Quick Start">Quick Start</a></li>
							<li ><a href="documentation.html" title="Docs">Docs</a></li>
							<li ><a href="contributing-redirect.html" title="Contribute">Contribute</a></li>
							<li class="dropdown active">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Project <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="index.html" title="Overview">Overview</a></li>
									<li class="active"><a href="" title="FAQ">FAQ</a></li>
									<li ><a href="release-notes.html" title="Release Notes">Release Notes</a></li>
									<li ><a href="management.html" title="Managing Trafodion">Managing Trafodion</a></li>
									<li ><a href="http:divider" title=""></a></li>
									<li ><a href="team-redirect.html" title="Team">Team</a></li>
									<li ><a href="presentations.html" title="Presentations">Presentations</a></li>
									<li ><a href="mail-lists.html" title="Mailing List">Mailing List</a></li>
									<li ><a href="http:divider" title=""></a></li>
									<li ><a href="source-repository.html" title="Source Repository">Source Repository</a></li>
									<li ><a href="issue-tracking.html" title="Issue Tracking">Issue Tracking</a></li>
									<li ><a href="license.html" title="License">License</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Features <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="architecture-overview.html" title="Architecture Overview">Architecture Overview</a></li>
									<li ><a href="http:divider" title=""></a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/security-ansi-schemas" title="ANSI Schema Support" class="externalLink">ANSI Schema Support</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/ustat-automation" title="Automated Update Statistics" class="externalLink">Automated Update Statistics</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/bulkunload" title="Bulk Unload" class="externalLink">Bulk Unload</a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Trafodion_Manageability#Logging_Events" title="Event Handling" class="externalLink">Event Handling</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/hybrid-query-cache" title="Hybrid Query Cache" class="externalLink">Hybrid Query Cache</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/identity-column" title="Identity Column" class="externalLink">Identity Column</a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Creating_Statistics_During_Bulk_Load" title="Immediate Update Statistics" class="externalLink">Immediate Update Statistics</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/lob-support" title="Large Object (LOB)" class="externalLink">Large Object (LOB)</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/ddl-query-invalidation" title="Metadata Query Invalidation" class="externalLink">Metadata Query Invalidation</a></li>
									<li ><a href="https://cwiki.apache.org/confluence/display/TRAFODION/Cmp-divisioning" title="Multi-Temperature Data" class="externalLink">Multi-Temperature Data</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/access-external-hbase-tables" title="Native HBase Tables" class="externalLink">Native HBase Tables</a></li>
									<li ><a href="docs/odb_user/index.html" title="ODB">ODB</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/sql-query-cancel" title="Query Cancel" class="externalLink">Query Cancel</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/security-privilege-updates" title="Privilege Checking" class="externalLink">Privilege Checking</a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Trafodion_Manageability" title="Repository" class="externalLink">Repository</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/enable-get-statistics-thru-rms" title="Runtime Management System" class="externalLink">Runtime Management System</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/sequence-numbers" title="Sequence Numbers" class="externalLink">Sequence Numbers</a></li>
									<li ><a href="https://blueprints.launchpad.net/trafodion/+spec/skew-buster" title="Skew Buster" class="externalLink">Skew Buster</a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Tutorial:_The_object-oriented_UDF_interface" title="Table-Oriented UDF" class="externalLink">Table-Oriented UDF</a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Data_Loading#Trickle_Loading_Data_Into_Trafodion_Tables" title="Trickle Load" class="externalLink">Trickle Load</a></li>
									<li ><a href="http:divider" title=""></a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Backup_and_Restore" title="Backup/Restore Utility" class="externalLink">Backup/Restore Utility</a></li>
									<li ><a href="https://wiki.trafodion.org/wiki/index.php/Metadata_Cleanup" title="Metadata Cleanup Utility" class="externalLink">Metadata Cleanup Utility</a></li>
								</ul>
							</li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Apache <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="http://incubator.apache.org/projects/trafodion.html" title="Project Status" target="_blank" class="externalLink">Project Status</a></li>
									<li ><a href="http://www.apache.org/foundation/how-it-works.html" title="Apache Foundation" target="_blank" class="externalLink">Apache Foundation</a></li>
									<li ><a href="http://www.apache.org/licenses/" title="Apache License" target="_blank" class="externalLink">Apache License</a></li>
									<li ><a href="http://www.apache.org/security/" title="Apache Security" target="_blank" class="externalLink">Apache Security</a></li>
									<li ><a href="http:divider" title=""></a></li>
									<li ><a href="http://www.apache.org/foundation/sponsorship.html" title="Sponsorship" target="_blank" class="externalLink">Sponsorship</a></li>
									<li ><a href="http://www.apache.org/foundation/thanks.html" title="Thanks" target="_blank" class="externalLink">Thanks</a></li>
								</ul>
							</li>
						</ul>
					</div><!--/.nav-collapse -->
				</div>
			</div>
		</div>

	<div class="container">

	<!-- Masthead
	================================================== -->

	<header>
	<div class="jumbotron subhead">
		<div class="row" id="banner">
			<div class="span12">
				<div class="pull-left">
					<a href="index.html" id="bannerLeft"><h1><img src="images/logos/trafodion-logo.jpg" alt="Trafodion Logo"></h1></a>
					<p class="lead">Transactional SQL-on-Hadoop Database</p>
				</div>
				<div class="pull-right">
				</div>
			</div>
		</div>
	</div>
		<div>
			<ul class="breadcrumb">
				<li><a href="index.html" title="Trafodion">Trafodion</a></li>
				<li class="divider">/</li>
				<li>Frequently Asked Questions</li>
			</ul>
		</div>
		<hr class="toc-separator" />
		<div id="toc-bar" class="navbar" data-spy="affix" data-offset-top="250">
			<div class="navbar-inner">
				<div id="toc-scroll-target" class="container">
					<a class="btn btn-navbar" data-toggle="collapse" data-target="#toc-nav-collapse">
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
						<span class="icon-bar"></span>
					</a>
					<div class="nav-collapse collapse" id="toc-nav-collapse">
						<ul id="toc" class="nav">
						<li class="dropdown">
							<a href="#project" title="Project" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Project <b class="caret"></b></a>
							<ul class="dropdown-menu" role="menu">
								<!-- Repeat the item, otherwise it is not clickable as the dropdown root -->
								<li><a href="#project" title="Project">Project</a></li>
								<li class="divider"></li>
								<li><a href="#What_is_Project_Trafodion" title="What is Project Trafodion?">What is Project Trafodion?</a></li>
								<li><a href="#When_is_Trafodion_available" title="When is Trafodion available?">When is Trafodion available?</a></li>
								<li><a href="#What_are_the_key_features_of_Trafodion" title="What are the key features of Trafodion?">What are the key features of Trafodion?</a></li>
								<li><a href="#What_are_the_key_benefits_of_Trafodion" title="What are the key benefits of Trafodion?">What are the key benefits of Trafodion?</a></li>
								<li><a href="#Why_is_it_called_Trafodion" title="Why is it called Trafodion?">Why is it called Trafodion?</a></li>
								<li><a href="#What_are_the_primary_use_cases_for_Trafodion" title="What are the primary use cases for Trafodion?">What are the primary use cases for Trafodion?</a></li>
								<li><a href="#What_is_the_heritage_of_the_Trafodion_software" title="What is the heritage of the Trafodion software?">What is the heritage of the Trafodion software?</a></li>
								<li><a href="#What_do_you_mean_by_Transactional_or_Operational_SQL" title="What do you mean by “Transactional or Operational SQL”?">What do you mean by “Transactional or Operational SQL”?</a></li>

							</ul>
						</li>
						<li class="divider-vertical"></li>
						<li class="dropdown">
							<a href="#using" title="Using" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Using <b class="caret"></b></a>
							<ul class="dropdown-menu" role="menu">
								<!-- Repeat the item, otherwise it is not clickable as the dropdown root -->
								<li><a href="#using" title="Using">Using</a></li>
								<li class="divider"></li>
								<li><a href="#Why_would_Trafodion_be_used_over_a_commercial_OLTP_database" title="Why would Trafodion be used over a commercial OLTP database?">Why would Trafodion be used over a commercial OLTP database?</a></li>
								<li><a href="#Is_Trafodion_mainly_an_extension_to_HBase" title="Is Trafodion mainly an extension to HBase?">Is Trafodion mainly an extension to HBase?</a></li>
								<li><a href="#Besides_data_access_via_SQL_database_connection_what_other_advantages_does_Trafodion_offer_over_existing_distributed_database_technologies" title="Besides data access via SQL database connection, what other advantages does Trafodion offer over existing distributed database technologies?">Besides data access via SQL database connection, what other advantages does Trafodion offer over existing distributed database technologies?</a></li>
								<li><a href="#Can_Trafodion_modify_tables" title="Can Trafodion modify tables?">Can Trafodion modify tables?</a></li>
								<li><a href="#What_is_the_benchmarked_performance_for_a_transaction_workload" title="What is the benchmarked performance for a transaction workload?">What is the benchmarked performance for a transaction workload?</a></li>
								<li><a href="#Where_would_you_position_Trafodion_according_to_the_CAP_theorem_Is_it_CP_consistent_and_partition_tolerant_as_HBase_or_CA_consistent_and_highly_available" title="Where would you position Trafodion according to the CAP theorem? Is it CP (consistent and partition tolerant as HBase) or CA (consistent and highly available)?">Where would you position Trafodion according to the CAP theorem? Is it CP (consistent and partition tolerant as HBase) or CA (consistent and highly available)?</a></li>
								<li><a href="#How_does_Trafodion_scale_in_terms_of_database_size" title="How does Trafodion scale in terms of database size?">How does Trafodion scale in terms of database size?</a></li>
								<li><a href="#What_about_high_availability_Does_Trafodion_have_a_single_point_of_failure" title="What about high availability? Does Trafodion have a single point of failure?">What about high availability? Does Trafodion have a single point of failure?</a></li>
								<li><a href="#Is_Trafodion_best_suited_for_reads_or_for_writes" title="Is Trafodion best suited for reads or for writes?">Is Trafodion best suited for reads or for writes?</a></li>
								<li><a href="#Does_Trafodion_have_full_text_search_capabilities" title="Does Trafodion have full text search capabilities?">Does Trafodion have full text search capabilities?</a></li>

							</ul>
						</li>
						<li class="divider-vertical"></li>
						<li class="dropdown">
							<a href="#transactions" title="Transactions" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Transactions <b class="caret"></b></a>
							<ul class="dropdown-menu" role="menu">
								<!-- Repeat the item, otherwise it is not clickable as the dropdown root -->
								<li><a href="#transactions" title="Transactions">Transactions</a></li>
								<li class="divider"></li>
								<li><a href="#Is_Trafodions_transaction_management_an_eventually_consistent_model" title="Is Trafodion’s transaction management an eventually consistent model?">Is Trafodion’s transaction management an eventually consistent model?</a></li>
								<li><a href="#Does_Trafodion_provide_transaction_management_for_native_HBase_tables" title="Does Trafodion provide transaction management for native HBase tables?">Does Trafodion provide transaction management for native HBase tables?</a></li>
								<li><a href="#Does_Trafodion_support_read_consistency" title="Does Trafodion support read consistency?">Does Trafodion support read consistency?</a></li>
								<li><a href="#Does_Trafodion_offer_ability_to_rollback_transactions" title="Does Trafodion offer ability to rollback transactions?">Does Trafodion offer ability to rollback transactions?</a></li>
								<li><a href="#Is_there_a_transaction_log_and_can_the_log_be_shipped_to_a_DR_site" title="Is there a transaction log and can the log be shipped to a DR site?">Is there a transaction log and can the log be shipped to a DR site?</a></li>
								<li><a href="#Does_Trafodion_support_distributed_transaction_management_across_multiple_data_centers" title="Does Trafodion support distributed transaction management across multiple data centers?">Does Trafodion support distributed transaction management across multiple data centers?</a></li>
								<li><a href="#How_does_two-phase_commit_scale_linearly_on_large_clusters" title="How does two-phase commit scale linearly on large clusters?">How does two-phase commit scale linearly on large clusters?</a></li>

							</ul>
						</li>
						<li class="divider-vertical"></li>
						<li class="dropdown">
							<a href="#hadoop_integration" title="Hadoop Integration" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Hadoop Integration <b class="caret"></b></a>
							<ul class="dropdown-menu" role="menu">
								<!-- Repeat the item, otherwise it is not clickable as the dropdown root -->
								<li><a href="#hadoop_integration" title="Hadoop Integration">Hadoop Integration</a></li>
								<li class="divider"></li>
								<li><a href="#Does_Trafodion_work_as_a_Hadoop_Yarn_application" title="Does Trafodion work as a Hadoop Yarn application?">Does Trafodion work as a Hadoop Yarn application?</a></li>
								<li><a href="#Can_Trafodion_access_Hive_stored_data" title="Can Trafodion access Hive stored data?">Can Trafodion access Hive stored data?</a></li>
								<li><a href="#Can_we_access_Trafodion_data_with_MapReduce" title="Can we access Trafodion data with MapReduce?">Can we access Trafodion data with MapReduce?</a></li>
								<li><a href="#Can_Trafodion_data_be_accessed_through_Hive_Can_we_publish_a_Trafodion_table_to_HCatalog_and_query_it_using_Hive" title="Can Trafodion data be accessed through Hive? Can we publish a Trafodion table to HCatalog and query it using Hive?">Can Trafodion data be accessed through Hive? Can we publish a Trafodion table to HCatalog and query it using Hive?</a></li>

							</ul>
						</li>
						<li class="divider-vertical"></li>
						<li class="dropdown">
							<a href="#security" title="Security" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Security <b class="caret"></b></a>
							<ul class="dropdown-menu" role="menu">
								<!-- Repeat the item, otherwise it is not clickable as the dropdown root -->
								<li><a href="#security" title="Security">Security</a></li>
								<li class="divider"></li>
								<li><a href="#How_is_Database_security_management_supported_in_Trafodion" title="How is Database security management supported in Trafodion?">How is Database security management supported in Trafodion?</a></li>
								<li><a href="#Does_Trafodion_have_role-based_security_authorization" title="Does Trafodion have role-based security authorization?">Does Trafodion have role-based security authorization?</a></li>
								<li><a href="#What_is_Trafodions_security_authorization_granularity" title="What is Trafodion’s security authorization granularity?">What is Trafodion’s security authorization granularity?</a></li>

							</ul>
						</li>
						<li class="divider-vertical"></li>
						<li class="dropdown">
							<a href="#infrastructure" title="Infrastructure" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Infrastructure <b class="caret"></b></a>
							<ul class="dropdown-menu" role="menu">
								<!-- Repeat the item, otherwise it is not clickable as the dropdown root -->
								<li><a href="#infrastructure" title="Infrastructure">Infrastructure</a></li>
								<li class="divider"></li>
								<li><a href="#What_hardware_do_I_need_to_run_Trafodion_Is_it_hardware_vendor_neutral" title="What hardware do I need to run Trafodion? Is it hardware vendor neutral?">What hardware do I need to run Trafodion? Is it hardware vendor neutral?</a></li>
								<li><a href="#Does_Trafodion_need_to_be_installed_on_all_the_Hadoop_cluster_nodes" title="Does Trafodion need to be installed on all the Hadoop cluster nodes?">Does Trafodion need to be installed on all the Hadoop cluster nodes?</a></li>
								<li><a href="#What_does_Trafodion_software_require" title="What does Trafodion software require?">What does Trafodion software require?</a></li>
								<li><a href="#Are_there_any_recommended_configurations_in_terms_of_nodes_memory_etc" title="Are there any recommended configurations in terms of nodes, memory, etc.?">Are there any recommended configurations in terms of nodes, memory, etc.?</a></li>
								<li><a href="#Does_Trafodion_need_dedicated_hardware" title="Does Trafodion need dedicated hardware?">Does Trafodion need dedicated hardware?</a></li>

							</ul>
						</li>
						</ul>
					</div>
				</div>
			</div>
		</div>
	</header>

	<div class="main-body">
	<div class="row">
		<div class="span12">
			<div class="body-content">
<!-- Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the 
  License. --> 
<p>This page provides frequently-asked questions about the Trafodion project and their answers.</p> 
<div class="page-header">
 <h1 id="project">Project</h1>
</div> 
<div class="section"> 
 <h2 id="What_is_Project_Trafodion">What is Project Trafodion?</h2> 
 <p>Project Trafodion is an open source initiative originally cultivated by HP Labs and HP IT to develop an enterprise-class SQL-on-HBase solution targeted for big data transactional or operational workloads as opposed to analytic workloads.</p> 
</div> 
<div class="section"> 
 <h2 id="When_is_Trafodion_available">When is Trafodion available?</h2> 
 <p>Trafodion is currently available at downloads.trafodion.org. There, you can find an installer and executable code. For installation instructions, see Installation.</p> 
</div> 
<div class="section"> 
 <h2 id="What_are_the_key_features_of_Trafodion">What are the key features of Trafodion?</h2> 
 <p>The key features are:</p> 
 <ul> 
  <li>Full-functioned ANSI SQL language support</li> 
  <li>JDBC/ODBC connectivity for Linux/Windows clients</li> 
  <li>Distributed ACID transaction protection across multiple statements, tables and/or rows</li> 
  <li>Transaction recovery to achieve database consistency</li> 
  <li>Optimization for low-latency read and write transactions</li> 
  <li>Support for large data sets using a parallel-aware query optimizer</li> 
  <li>Performance improvements for OLTP workloads with compile-time and run-time optimizations</li> 
  <li>Distributed parallel-processing architecture designed for scalability</li> 
 </ul> 
</div> 
<div class="section"> 
 <h2 id="What_are_the_key_benefits_of_Trafodion">What are the key benefits of Trafodion?</h2> 
 <p>Trafodion delivers a full-featured and optimized transactional SQL-on-HBase DBMS solution with full transactional data protection. These capabilities help overcome basic Hadoop limitations in supporting transactional workloads.</p> 
 <p>With Trafodion, users gain the following benefits:</p> 
 <ul> 
  <li>Ability to leverage in-house SQL expertise versus complex MapReduce programming</li> 
  <li>Seamless support for existing transactional applications</li> 
  <li>Ability to develop next generation highly scalable, real-time transaction processing applications</li> 
  <li>Reduction in data latency for down-steam analytic workloads</li> 
  <li>Adoption of data reuse by different application domains</li> 
 </ul> 
 <p>And operational SQL users also gain the following benefits inherent in Hadoop ecosystem.</p> 
 <ul> 
  <li>Reduced infrastructure costs</li> 
  <li>Massive scalability and granular elasticity</li> 
  <li>Improved data availability and disaster recovery protection</li> 
 </ul> 
</div> 
<div class="section"> 
 <h2 id="Why_is_it_called_Trafodion">Why is it called Trafodion?</h2> 
 <p>Trafodion is Welsh for transactions.</p> 
</div> 
<div class="section"> 
 <h2 id="What_are_the_primary_use_cases_for_Trafodion">What are the primary use cases for Trafodion?</h2> 
 <p>Primary use cases on Trafodion consist of existing HBase workloads enhanced through SQL with transactional data protection. Another class of use cases consist of new or rehosted existing operational applications to address scalability issues, complex application programming, or prohibitive licensing costs.</p> 
</div> 
<div class="section"> 
 <h2 id="What_is_the_heritage_of_the_Trafodion_software">What is the heritage of the Trafodion software?</h2> 
 <p>Trafodion is based on HP’s 20+ year history in developing database products for OLTP. Building on this heritage, Trafodion provides distributed transaction management protection over multiple SQL statements, multiple tables and multiple rows.</p> 
</div> 
<div class="section"> 
 <h2 id="What_do_you_mean_by_Transactional_or_Operational_SQL">What do you mean by “Transactional or Operational SQL”?</h2> 
 <p>Transactional or Operational SQL describe workloads were previously described simply as OLTP (online transaction processing) workloads. This expands that definition from the broad range of enterprise-level transactional applications (ERP, CRM, etc.) to include the new transactions generated from social and mobile data interactions and observations and the new mixing of structured and semi-structured data.</p> 
 <!-- 20151117 Gunnar Tapper

   Commented out this section since the reference is no longer valid.
   
   Also, markdown does not like the equal signs in the actual URL, which is why tinyurl
   is used. Original URL is:
   
      http://www.gartner.com/technology/reprints.do?id=1-1M9YEHW&ct=131028&st=sb
   
Further details on Operational DBMS can be found in Gartner’s [Magic Quadrant for Operational Database Management Systems][gartner].

[gartner]: http://tinyurl.com/p5cwass --> 
 <hr /> 
 <h1 id="using">Using</h1> 
</div> 
<div class="section"> 
 <h2 id="Why_would_Trafodion_be_used_over_a_commercial_OLTP_database">Why would Trafodion be used over a commercial OLTP database?</h2> 
 <p>Trafodion is an open source product and like other products in the Hadoop ecosystem, it obtains two key advantages over the tradional proprietary OLTP database systems: Cost structure and Data reuse.</p> 
</div> 
<div class="section"> 
 <h2 id="Is_Trafodion_mainly_an_extension_to_HBase">Is Trafodion mainly an extension to HBase?</h2> 
 <p>Not quite. Trafodion runs on top of HBase using the HBase APIs to perform the typical SQL functions of insert, update, delete, and query data with transactional protection. However, there are plans to include database capabilities using the coprocessor mechanism provided by HBase.</p> 
</div> 
<div class="section"> 
 <h2 id="Besides_data_access_via_SQL_database_connection_what_other_advantages_does_Trafodion_offer_over_existing_distributed_database_technologies">Besides data access via SQL database connection, what other advantages does Trafodion offer over existing distributed database technologies?</h2> 
 <p>With Trafodion, users can make use of standard HBase APIs as well as use Trafodion for SQL access to the HBase tables. This includes Trafodion’s ability to use powerful SQL capabilities to do joins against both HBase and Trafodion tables and run queries against them while providing transaction management capability.</p> 
 <p>This allows application developers to choose the best access methods for each particular data usage, based on skill set, data size and usage, and access pattern requirements.</p> 
</div> 
<div class="section"> 
 <h2 id="Can_Trafodion_modify_tables">Can Trafodion modify tables?</h2> 
 <p>Yes, Trafodion provides full-featured ANSI DML operations including INSERT, UPDATE, DELETE, MERGE, and UPSERT statement support.</p> 
</div> 
<div class="section"> 
 <h2 id="What_is_the_benchmarked_performance_for_a_transaction_workload">What is the benchmarked performance for a transaction workload?</h2> 
 <p>Benchmark results will be posted as the community publishes them.</p> 
</div> 
<div class="section"> 
 <h2 id="Where_would_you_position_Trafodion_according_to_the_CAP_theorem_Is_it_CP_consistent_and_partition_tolerant_as_HBase_or_CA_consistent_and_highly_available">Where would you position Trafodion according to the CAP theorem? Is it CP (consistent and partition tolerant as HBase) or CA (consistent and highly available)?</h2> 
 <p>Trafodion is hosted on top of HBase and HDFS. HBase is generally viewed as being CA (Consistent, Available) in the context of the CAP theorem. </p> 
 <p>Unlike regular HBase, Trafodion extends the definition of consistency to provide ACID protection across transactions comprised of multiple SQL statements, tables, and rows.</p> 
</div> 
<div class="section"> 
 <h2 id="How_does_Trafodion_scale_in_terms_of_database_size">How does Trafodion scale in terms of database size?</h2> 
 <p>As Trafodion is hosted on HBase/HDFS, in theory, Trafodion’s database should scale as HBase/HDFS scales. To this point (due to available hardware limitations), Trafodion has been tested with configurations up to 10 nodes and 50 terabytes.</p> 
</div> 
<div class="section"> 
 <h2 id="What_about_high_availability_Does_Trafodion_have_a_single_point_of_failure">What about high availability? Does Trafodion have a single point of failure?</h2> 
 <p>HBase and HDFS are considered highly available with many built in features for HA including name node redundancy, HDFS k-safety data replication, HBase replication, HBase snapshots, Zookeeper’s highly reliable distributed coordination of Hadoop hosted services, and so on. </p> 
 <p>Additionally, the planned release of HBase 1.0 is advertised as having many additional HA features which Trafodion incorporates as it supports HBase 1.0. Furthermore, many Hadoop distributions have added their own HA features at the HBase or HDFS layers.</p> 
 <p>Trafodion leverages HBase and HDFS capabilities for providing extended HA to the connectivity and SQL layers. For example, Trafodion registers its connection services using Zookeeper to ensure persistent connectivity services. Trafodion is designed as an MPP service with replicated service points for HA and no single points of failure.</p> 
</div> 
<div class="section"> 
 <h2 id="Is_Trafodion_best_suited_for_reads_or_for_writes">Is Trafodion best suited for reads or for writes?</h2> 
 <p>Trafodion provides a bulk load capability that interfaces directly with HDFS for high-performance data loading. HBase leverages large-scale cached memory to host data in memory until the HFile buffer becomes filled and is then written to HDFS. </p> 
 <p>Additionally, Trafodion provides many low-latency read optimizations on top of HBase to significantly improve the both the random and parallel read performance of the database engine. These include:</p> 
 <ul> 
  <li>Statistics-based plan generation</li> 
  <li>Degree of parallelism optimization</li> 
  <li>In-memory data-flow, scheduler-driven executor</li> 
  <li>Query plan caching</li> 
  <li>Key-based access with SQL “pushdown”</li> 
  <li>Multi-dimensional access method (MDAM)</li> 
  <li>Composite key support</li> 
  <li>Secondary index support</li> 
  <li>Table structure optimizations</li> 
  <li>Salting of row-keys for workload balancing</li> 
 </ul> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_have_full_text_search_capabilities">Does Trafodion have full text search capabilities?</h2> 
 <p>Trafodion provides SQL search capabilities using search functions such as POSITION (equivalent to INDEX) and SUBSTRING. Once large object (LOB) support is made available, a user-written or third-party UDF could be plugged in to add search capabilities into documents and images. This is a great area for community contribution.</p> 
 <hr /> 
 <h1 id="transactions">Transactions</h1> 
</div> 
<div class="section"> 
 <h2 id="Is_Trafodions_transaction_management_an_eventually_consistent_model">Is Trafodion’s transaction management an eventually consistent model?</h2> 
 <p>No, Trafodion supports full ACID properties. Distributed Transaction Management provides transaction consistency across multiple row updates, updates across multiple tables, and transactions spanning multiple update statements. At the return from a COMMIT WORK statement, all rows and tables are in consistent form with regards to that transaction.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_provide_transaction_management_for_native_HBase_tables">Does Trafodion provide transaction management for native HBase tables?</h2> 
 <p>Yes, Trafodion supports transaction management for native HBase tables.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_support_read_consistency">Does Trafodion support read consistency?</h2> 
 <p>Yes, all the reads in Trafodion are completely consistent.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_offer_ability_to_rollback_transactions">Does Trafodion offer ability to rollback transactions?</h2> 
 <p>Yes, Trafodion offers full ACID protection across multiple SQL statements, tables, or rows. Transactions can be aborted using the ROLLBACK WORK statement.</p> 
</div> 
<div class="section"> 
 <h2 id="Is_there_a_transaction_log_and_can_the_log_be_shipped_to_a_DR_site">Is there a transaction log and can the log be shipped to a DR site?</h2> 
 <p>Not really. There are two logs that the transaction manager uses to coordinate transaction history, one at an HBase regionserver level and the other at the transaction manager level. But there is no support for shipping and replaying these logs on a remote DR site in a transactionally consistent manner.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_support_distributed_transaction_management_across_multiple_data_centers">Does Trafodion support distributed transaction management across multiple data centers?</h2> 
 <p>There is no support for transaction management between Trafodion instances in different data centers.</p> 
</div> 
<div class="section"> 
 <h2 id="How_does_two-phase_commit_scale_linearly_on_large_clusters">How does two-phase commit scale linearly on large clusters?</h2> 
 <p>Trafodion employs a Distributed Transaction Manager (DTM) model where a DTM runs on every datanode and each DTM works with its peers in other datanodes to coordinate the two-phase commit protocol. For efficiency purposes, the DTM is invoked only when necessary:</p> 
 <ul> 
  <li>If the transaction involves only a single region, then two-phase commit coordination is not necessary.</li> 
  <li>The DTM is not involved with read-only transactions.</li> 
  <li>The DTM is not involved in loading data into empty tables or during index creation.</li> 
  <li>If the transaction impacts only a single table row, then standard HBase ACID protection is used instead of the DTM right now. In the future,these transactions might be fast-tracked using a different mechanism.</li> 
 </ul> 
 <hr /> 
 <h1 id="hadoop_integration">Hadoop Integration</h1> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_work_as_a_Hadoop_Yarn_application">Does Trafodion work as a Hadoop Yarn application?</h2> 
 <p>Trafodion has not been tested with Yarn yet, but there is nothing in Trafodion that precludes it from being treated as a regular application running in a Yarn container.</p> 
</div> 
<div class="section"> 
 <h2 id="Can_Trafodion_access_Hive_stored_data">Can Trafodion access Hive stored data?</h2> 
 <p>Trafodion does provide the capability for SQL statements submitted to Trafodion to access, join, and aggregate a combination of Trafodion database objects, native HBase objects, and Hive tables (via the HCatalog).</p> 
</div> 
<div class="section"> 
 <h2 id="Can_we_access_Trafodion_data_with_MapReduce">Can we access Trafodion data with MapReduce?</h2> 
 <p>While theoretically possible since Trafodion data is stored in HBase/HDFS, the data would not be easily interpreted due to the encoding mechanisms Trafodion employs for transaction performance and efficiency.</p> 
 <p>Trafodion provides automatic access parallelism without the need for writing MapReduce. If the optimized plan calls for parallel execution, the Trafodion Master process divides the work among Executive Server Processes (ESPs) to perform the work in parallel on behalf of the Master process. The results are passed back to the Master for consolidation. </p> 
 <p>In some situations where there a highly complex plan specified (for example, large n-way joins or aggregations), multiple layers of ESPs may be requested. See the diagram below.</p> 
 <center> 
  <img src="images/multi-layer-esps.png" alt="" /> 
 </center> 
</div> 
<div class="section"> 
 <h2 id="Can_Trafodion_data_be_accessed_through_Hive_Can_we_publish_a_Trafodion_table_to_HCatalog_and_query_it_using_Hive">Can Trafodion data be accessed through Hive? Can we publish a Trafodion table to HCatalog and query it using Hive?</h2> 
 <p>While theoretically possible since Trafodion data is stored in HBase/HDFS, the data would not be easily interpreted due to the encoding mechanisms Trafodion employs for transaction performance and efficiency. </p> 
 <p>Trafodion maintains its own catalog for metadata that provides the relational abstraction layer for accessing the physical storage layer via SQL commands. Trafodion objects are complex as they can have tables, indexes, views, constraints, which are represented in Trafodion’s own catalog. HCatalog can represent only simple objects like tables or column families currently but does not contain support for representing other more complex relational objects.</p> 
 <p>Alternatively, Trafodion data could be loaded into Hive/HDFS and then accessed using Hive specific operations or native MapReduce jobs.</p> 
 <hr /> 
 <h1 id="security">Security</h1> 
</div> 
<div class="section"> 
 <h2 id="How_is_Database_security_management_supported_in_Trafodion">How is Database security management supported in Trafodion?</h2> 
 <p>Currently, Trafodion provides security management based on HBase capabilities. There are projects as part of roadmap to provide full GRANT/REVOKE capability at the table and schema level for users and roles, along with support for directory based authentication.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_have_role-based_security_authorization">Does Trafodion have role-based security authorization?</h2> 
 <p>Yes, Trafodion supports ANSI GRANT/REVOKE on both an individual user and role basis. See Enabling Security Features in Trafodion. For details on the GRANT/REVOKE syntax, see the Trafodion SQL Reference Manual (pdf, 3.98 MB).</p> 
</div> 
<div class="section"> 
 <h2 id="What_is_Trafodions_security_authorization_granularity">What is Trafodion’s security authorization granularity?</h2> 
 <p>Trafodion supports authorization (that is, privileges) at the system and database-object level. System privileges are valid across SQL, such as the ability to create schemas and objects. Object privileges include tables, views, and other databse objects. Views can be used to restrict access to the subset of table rows referenced within the view.</p> 
 <hr /> 
 <h1 id="infrastructure">Infrastructure</h1> 
</div> 
<div class="section"> 
 <h2 id="What_hardware_do_I_need_to_run_Trafodion_Is_it_hardware_vendor_neutral">What hardware do I need to run Trafodion? Is it hardware vendor neutral?</h2> 
 <p>Trafodion is designed to be hosted on vendor neutral, commodity hardware. As Trafodion runs on top of HBase and HDFS, a vendor’s recommended reference architectur such as HP Reference Architecture for Hadoop or similar server configuration is recommended as a starting point for a new installation.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_need_to_be_installed_on_all_the_Hadoop_cluster_nodes">Does Trafodion need to be installed on all the Hadoop cluster nodes?</h2> 
 <p>Trafodion needs to be installed on all nodes that host an HBase RegionServer. Trafodion comes with an install script to make the installation process easy. For more information, see the Trafodion installation instructions.</p> 
</div> 
<div class="section"> 
 <h2 id="What_does_Trafodion_software_require">What does Trafodion software require?</h2> 
 <p>Trafodion software requires an x86-64 bit hardware platform running RedHat Enterprise Linux or CentOS 6.x kernel (64-bit). It supports Cloudera and Hortonworks Hadoop distributions; for details, see Supported Hadoop Distributions. The software is intended to be Linux and Hadoop distribution neutral, but other distributions have not been tested at this time.</p> 
</div> 
<div class="section"> 
 <h2 id="Are_there_any_recommended_configurations_in_terms_of_nodes_memory_etc">Are there any recommended configurations in terms of nodes, memory, etc.?</h2> 
 <p>Recommended sizings for Trafodion are still being developed, and vary based on the amount of data, anticipated query workload (types, rates/respose times, concurrency) and the peak number of supported concurrent connections). </p> 
 <p>What’s the process like when we add a new node to the cluster? Does the system grow elastically? The underlying HBase/HDFS infrastructure supports elastic scalability allowing for incremental node expansion, that is, datanode expansion. Trafodion could then access the HBase tables (or ‘regions’ of the HBase tables) that now span the new node(s). Trafodion services (that is, connection, compiler, master, ESP) can be made to leverage these additional nodes by restarting Trafodion with a new coniguration.</p> 
</div> 
<div class="section"> 
 <h2 id="Does_Trafodion_need_dedicated_hardware">Does Trafodion need dedicated hardware?</h2> 
 <p>Trafodion can run on dedicated hardware, cloud or VM configurations. For best and consistent performance, dedicated hardware is recommended where feasible.</p> 
</div>
			</div>
		</div>
	</div>
	</div>

	</div><!-- /container -->

	<!-- Footer
	================================================== -->
	<footer class="well">
		<div class="container">
			<div class="row">
				<div class="span4 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Project</li>
						<li >
							<a href="index.html" title="Overview">Overview</a>
						</li>
						<li class="active">
							<a href="#" title="FAQ">FAQ</a>
						</li>
						<li >
							<a href="release-notes.html" title="Release Notes">Release Notes</a>
						</li>
						<li >
							<a href="management.html" title="Managing Trafodion">Managing Trafodion</a>
						</li>
						<li >
							<a href="http:divider" title=""></a>
						</li>
						<li >
							<a href="team-redirect.html" title="Team">Team</a>
						</li>
						<li >
							<a href="presentations.html" title="Presentations">Presentations</a>
						</li>
						<li >
							<a href="mail-lists.html" title="Mailing List">Mailing List</a>
						</li>
						<li >
							<a href="http:divider" title=""></a>
						</li>
						<li >
							<a href="source-repository.html" title="Source Repository">Source Repository</a>
						</li>
						<li >
							<a href="issue-tracking.html" title="Issue Tracking">Issue Tracking</a>
						</li>
						<li >
							<a href="license.html" title="License">License</a>
						</li>
					</ul>
				</div>
				<div class="span4 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Features</li>
						<li >
							<a href="architecture-overview.html" title="Architecture Overview">Architecture Overview</a>
						</li>
						<li >
							<a href="http:divider" title=""></a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/security-ansi-schemas" title="ANSI Schema Support" class="externalLink">ANSI Schema Support</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/ustat-automation" title="Automated Update Statistics" class="externalLink">Automated Update Statistics</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/bulkunload" title="Bulk Unload" class="externalLink">Bulk Unload</a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Trafodion_Manageability#Logging_Events" title="Event Handling" class="externalLink">Event Handling</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/hybrid-query-cache" title="Hybrid Query Cache" class="externalLink">Hybrid Query Cache</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/identity-column" title="Identity Column" class="externalLink">Identity Column</a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Creating_Statistics_During_Bulk_Load" title="Immediate Update Statistics" class="externalLink">Immediate Update Statistics</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/lob-support" title="Large Object (LOB)" class="externalLink">Large Object (LOB)</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/ddl-query-invalidation" title="Metadata Query Invalidation" class="externalLink">Metadata Query Invalidation</a>
						</li>
						<li >
							<a href="https://cwiki.apache.org/confluence/display/TRAFODION/Cmp-divisioning" title="Multi-Temperature Data" class="externalLink">Multi-Temperature Data</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/access-external-hbase-tables" title="Native HBase Tables" class="externalLink">Native HBase Tables</a>
						</li>
						<li >
							<a href="docs/odb_user/index.html" title="ODB">ODB</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/sql-query-cancel" title="Query Cancel" class="externalLink">Query Cancel</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/security-privilege-updates" title="Privilege Checking" class="externalLink">Privilege Checking</a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Trafodion_Manageability" title="Repository" class="externalLink">Repository</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/enable-get-statistics-thru-rms" title="Runtime Management System" class="externalLink">Runtime Management System</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/sequence-numbers" title="Sequence Numbers" class="externalLink">Sequence Numbers</a>
						</li>
						<li >
							<a href="https://blueprints.launchpad.net/trafodion/+spec/skew-buster" title="Skew Buster" class="externalLink">Skew Buster</a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Tutorial:_The_object-oriented_UDF_interface" title="Table-Oriented UDF" class="externalLink">Table-Oriented UDF</a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Data_Loading#Trickle_Loading_Data_Into_Trafodion_Tables" title="Trickle Load" class="externalLink">Trickle Load</a>
						</li>
						<li >
							<a href="http:divider" title=""></a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Backup_and_Restore" title="Backup/Restore Utility" class="externalLink">Backup/Restore Utility</a>
						</li>
						<li >
							<a href="https://wiki.trafodion.org/wiki/index.php/Metadata_Cleanup" title="Metadata Cleanup Utility" class="externalLink">Metadata Cleanup Utility</a>
						</li>
					</ul>
				</div>
				<div class="span4 bottom-description">
					<blockquote><a href="http://trafodion.apache.org/">Apache Trafodion</a> is a webscale SQL-on-Hadoop solution enabling transactional or operational
          workloads on Hadoop. <br /><br />The name &quot;Trafodion&quot; (the Welsh word for transactions, pronounced
          &quot;Tra-vod-eee-on&quot;) was chosen specifically to emphasize the differentiation that 
          Trafodion provides in closing a critical gap in the Hadoop ecosystem.<br /><br />          
          Trafodion builds on the scalability, elasticity, and flexibility of Hadoop. Trafodion extends 
          Hadoop to provide guaranteed transactional integrity, enabling new kinds of big data 
          applications to run on Hadoop.</blockquote>
				</div>
			</div>
		</div>
	</footer>

	<div class="container subfooter">
		<div class="row">
			<div class="span12">
				<p class="pull-right"><a href="#">Back to top</a></p>
				<p class="copyright">Copyright &copy;2015-2016 <a href="http://www.apache.org">Apache Software Foundation</a>. All Rights Reserved.</p>
		
<hr/>
<div class="row span16">
  <span>Disclaimer: Apache Trafodion is an effort undergoing incubation at the Apache Software Foundation (ASF), sponsored by the Apache Incubator PMC. 
        Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making 
        process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the 
        completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.</span>
  <br/>
  <br/>
  <span>Apache, Apache Maven, Apache Maven Fluido Skin, the Apache feather logo, the Apache Maven project logo and the Apache Incubator project logo 
        are trademarks of The Apache Software Foundation.</span>
  <br/>
  <br/>
  <span>
    <a target="_blank" href="http://incubator.apache.org/">
      <img id="incubator-logo" alt="Apache Incubator" src="images/logos/egg-logo.png"/>
    </a>
  </span>
</div>			</div>
		</div>
	</div>

	<!-- Le javascript
	================================================== -->
	<!-- Placed at the end of the document so the pages load faster -->
	<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

	<script src="http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/js/bootstrap.min.js"></script>
	<script src="./js/lightbox.min.js"></script>
	<script src="./js/reflow-scroll.js"></script>
	<script src="http://yandex.st/highlightjs/7.5/highlight.min.js"></script>

	<script src="./js/reflow-skin.js"></script>

	</body>
</html>
