
<!DOCTYPE html>
<!--
 Generated by Apache Maven Doxia at 2016-02-12
 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 Install</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-install 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="contributing-redirect.html" title="Contributing">Contributing</a></li>
							<li class="dropdown">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">About <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="index.html" title="Project Overview">Project Overview</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 active">
								<a href="#" class="dropdown-toggle" data-toggle="dropdown">Using <b class="caret"></b></a>
								<ul class="dropdown-menu">
									<li ><a href="download.html" title="Download">Download</a></li>
									<li class="active"><a href="" title="Install">Install</a></li>
									<li ><a href="uninstall.html" title="Uninstall">Uninstall</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="documentation.html" title="Documentation">Documentation</a></li>
									<li ><a href="port-assignment.html" title="Port Assignments">Port Assignments</a></li>
									<li ><a href="faq.html" title="FAQ">FAQ</a></li>
									<li ><a href="release-notes.html" title="Release Notes">Release Notes</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>Apache <span class="color-highlight">Trafodion</span></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>Install</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="toplevel"><a href="#preparation" title="Preparation">Preparation</a></li>
						<li class="divider-vertical"></li>
						<li class="toplevel"><a href="#security_considerations" title="Security Considerations">Security Considerations</a></li>
						<li class="divider-vertical"></li>
						<li class="dropdown">
							<a href="#install_procedure" title="Install Procedure" class="dropdown-toggle" role="button" data-toggle="dropdown" data-target="#">Install Procedure <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="#install_procedure" title="Install Procedure">Install Procedure</a></li>
								<li class="divider"></li>
								<li><a href="#Upgrade" title="Upgrade">Upgrade</a></li>
								<li><a href="#Installation" title="Installation">Installation</a></li>
								<li><a href="#Start_and_Initialize" title="Start and Initialize">Start and Initialize</a></li>
								<li><a href="#Validate_Installation" title="Validate Installation">Validate Installation</a></li>
								<li><a href="#Install_Client_Software" title="Install Client Software">Install Client Software</a></li>

							</ul>
						</li>
						<li class="divider-vertical"></li>
						<li class="toplevel"><a href="#troubleshooting" title="Troubleshooting">Troubleshooting</a></li>
						<li class="divider-vertical"></li>
						<li class="toplevel"><a href="#uninstall" title="Uninstall">Uninstall</a></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 describes how to install the Trafodion end-user environment. Refer to the <a class="externalLink" href="https://cwiki.apache.org/confluence/display/TRAFODION/Trafodion+Contributor+Guide">Trafodion Contributor Guide</a> for information how to build the Trafodion source and run the Trafodion developer test environment.</p> 
<p>The Trafodion end-user environment is installed using the Trafodion Installer, which operates on Trafodion binaries only. Refer to the <a href="download.html">Download</a> page for instructions about how you download/create the Trafodion binaries.</p> 
<div class="page-header">
 <h1 id="preparation">Preparation</h1>
</div> 
<p>The Trafodion Installer assumes that you’ve performed the following steps before a Trafodion install:</p> 
<ol style="list-style-type: decimal"> 
 <li><b>Cluster Requirements</b>: Ensure that your cluster meets the Trafodion requirements.</li> 
 <li><b>Security Requirements</b>: Create the user ID that is used to run the Trafodion Installer. Review and configure LDAP, if desired.</li> 
 <li><b>PC Tools</b>: Install software used when installing Trafodion on your PC.</li> 
 <li><b>Install Hadoop</b>: Install Hadoop software supported by Trafodion.</li> 
 <li><b>Validate Hadoop</b>: Validate that required Hadoop services are running.</li> 
</ol> 
<p>Please refer to <a href="install-preparation.html">Install Preparation</a> for information about how to perform the steps above.</p> 
<h1 id="security_considerations">Security Considerations</h1> 
<p>You use the following user IDs and passwords during the Trafodion installation.</p> 
<table border="0" class="bodyTable table table-striped table-hover"> 
 <thead> 
  <tr class="a"> 
   <th>Logon </th> 
   <th>User ID </th> 
   <th>Password </th> 
   <th>Description</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr class="b"> 
   <td>Cloudera Manager Web GUI logon </td> 
   <td><b><tt>admin (default)</tt></b> </td> 
   <td><b><tt>admin (default)</tt></b> </td> 
   <td>Cloudera only. After installing Cloudera, you will be instructed to log on to the Cloudera Manager Web GUI. Use the default user ID and password (<b><tt>admin</tt></b>, <b><tt>admin</tt></b>). If you already had Cloudera installed, please use your previously defined user ID and password.</td> 
  </tr> 
  <tr class="a"> 
   <td>Ambari Web GUI logon </td> 
   <td><b><tt>admin (default)</tt></b> </td> 
   <td><b><tt>admin (default)</tt></b> </td> 
   <td>Hortonworks only. After downloading and setting up the Ambari repository, you will be instructed to log on to the Ambari Web GUI. Use the default user ID and password (<b><tt>admin</tt></b>, <b><tt>admin</tt></b>). If you already had Ambari installed, please use your previously defined user ID and password.</td> 
  </tr> 
  <tr class="b"> 
   <td>User ID with sudo Access </td> 
   <td><b><tt>&lt;sudo-username&gt;</tt></b> </td> 
   <td><b><tt>&lt;password&gt;</tt></b> </td> 
   <td>In the installation steps, you may be instructed to use <b><tt>sudo</tt></b> or <b><tt>sudo userid</tt></b> access. You will be using your user ID, which has been enabled with <b><tt>sudo</tt></b> access and <a href="passwordless-ssh.html">passwordless ssh</a> to all nodes of the cluster.</td> 
  </tr> 
  <tr class="a"> 
   <td>Trafodion Logon </td> 
   <td><b><tt>trafodion</tt></b> </td> 
   <td><b><tt>traf123 (default)</tt></b> </td> 
   <td>The Trafodion installer <b>automatically creates</b> this user ID when Trafodion is installed. Do not create this user ID manually.</td> 
  </tr> 
  <tr class="b"> 
   <td>VNC Server Logon </td> 
   <td><b><tt>trafodion</tt></b> </td> 
   <td><b><tt>traf123 (default)</tt></b> </td> 
   <td>After installing Trafodion, you will be instructed to log on to the VNC server at port 1. Use the <b><tt>trafodion</tt></b> user ID and <b><tt>password</tt></b>.</td> 
  </tr> 
 </tbody> 
</table> 
<h1 id="install_procedure">Install Procedure</h1> 
<div class="section"> 
 <h2 id="Upgrade">Upgrade</h2> 
 <p>Follow these steps if you have an older version of Trafodion that you want to upgrade:</p> 
 <ol style="list-style-type: decimal"> 
  <li><i>Shutdown Trafodion</i>: Please refer to <a href="management.html">Manage Trafodion</a>.</li> 
  <li><i>Backup Data</i>: Backup metadata and user objects. Please refer to <a href="backuprestore.html">Backup/Restore</a>.</li> 
  <li> <p><i>Install Trafodion</i>: The <b><tt>trafodion_install</tt></b> script automatically detects the previous version of Trafodion and performs an upgrade operation, including initializing Trafodion, upgrading the metadata, and restarting all processes. Please refer to <a href="#Installation">Installation</a> below for more information about <b><tt>trafodion_install</tt></b>.</p> <p>If something goes wrong during the installation, restore your data from the backed up objects and repeat the previous step.</p></li> 
 </ol> 
 <table border="0" class="bodyTable table table-striped table-hover"> 
  <tbody> 
   <tr class="a"> 
    <td><b>NOTE</b> <p>If you are doing an upgrade outside of the installation environment, then you will need to restart your services and processes, such as sqlci, the DCS server, and the qms servers. If you do not restart those services and processes, your system will not work properly.</p> </td> 
   </tr> 
  </tbody> 
 </table> 
</div> 
<div class="section"> 
 <h2 id="Installation">Installation</h2> 
 <p>At a high level, the following instructions consist of a single step:</p> 
 <table border="0" class="bodyTable table table-striped table-hover"> 
  <thead> 
   <tr class="a"> 
    <th>Command </th> 
    <th>User ID </th> 
    <th>Comments</th> 
   </tr> 
  </thead> 
  <tbody> 
   <tr class="b"> 
    <td><b><tt>trafodion_install</tt></b> </td> 
    <td><b><tt>&lt;sudo-username&gt;</tt></b> </td> 
    <td>Installs necessary RPMs, creates the <b><tt>trafodion</tt></b> user ID, sets up passwordless ssh for the <b><tt>trafodion</tt></b> user ID, copies the Trafodion distribution files across the cluster, generates startup files, and starts Trafodion, including Database Connectivity Services (DCS) (the ODBC/JDBC server), among other things.</td> 
   </tr> 
  </tbody> 
 </table> 
 <table border="0" class="bodyTable table table-striped table-hover"> 
  <tbody> 
   <tr class="a"> 
    <td> <b>IMPORTANT</b> <p>The Trafodion commands should all be done from the first node of the cluster. Do not run them from a machine that is not part of the Trafodion cluster. Trafodion must be installed on all nodes that host an HBase RegionServer (that is, where a supported Hadoop distribution is installed).</p> <p>For example, if Cloudera or Hortonworks is installed on nodes <b><tt>n001</tt></b>, <b><tt>n002</tt></b>, and <b><tt>n003</tt></b>, then you must install Trafodion on those same nodes (<b><tt>--nodes &quot;n001 n002 n003&quot;</tt></b>).</p> </td> 
   </tr> 
  </tbody> 
 </table> 
 <table border="0" class="bodyTable table table-striped table-hover"> 
  <thead> 
   <tr class="a"> 
    <th width="5%">Step</th> 
    <th width="35%">Description</th> 
    <th width="60%">Commands</th> 
   </tr> 
  </thead> 
  <tbody> 
   <tr class="b"> 
    <td><b>Download</b></td> 
    <td>If you haven't done so already, then please download the Trafodion software.</td> 
    <td>Please refer to <a href="download.html">Download</a>.</td> 
   </tr> 
   <tr class="a"> 
    <td><b>Upgrade</b></td> 
    <td> <p>If you are upgrading to a newer version of Trafodion, copy the installation files for the previous version to a directory outside of <b><tt>$HOME/trafodion_downloads</tt></b>.</p> <p>For example:</p> 
     <div> 
      <pre>mkdir $HOME/trafodion_downloads_v1.0</pre> 
     </div> </td> 
    <td> 
     <div> 
      <pre>cp –r $HOME/trafodion_downloads/* $HOME/trafodion_downloads_v1.0
rm –rf $HOME/trafodion_downloads/*</pre> 
     </div> </td> 
   </tr> 
   <tr class="b"> 
    <td><b>Create <tt>trafodion_downloads</tt></b></td> 
    <td>Create the <b><tt>trafodion_downloads</tt></b> directory if you have not done so already and place the downloaded <b><tt>trafodion-1.1.&lt;n&gt;.tar.gz</tt></b> and <b><tt>installer-1.1.&lt;n&gt;_v&lt;num&gt;.tar.gz</tt></b> tar files into it.</td> 
    <td> 
     <div> 
      <pre>
mkdir $HOME/trafodion_downloads
mv &lt;your-download-path&gt;/trafodion-1.1.&lt;n&gt;.tar.gz $HOME/trafodion_downloads
mv &lt;your-download-path&gt;/installer-1.1.&lt;n&gt;_v&lt;num&gt;.tar.gz $HOME/trafodion_downloads
cd $HOME/trafodion_downloads
       </pre> 
     </div> </td> 
   </tr> 
   <tr class="a"> 
    <td><b>Unpack tar File</b></td> 
    <td>Untar the downloaded installer file.</td> 
    <td> 
     <div> 
      <pre>tar -xzf installer-1.1.&lt;n&gt;_v&lt;num&gt;.tar.gz</pre> 
     </div></td> 
   </tr> 
   <tr class="b"> 
    <td><b>Run <tt>trafodion_install</tt></b></td> 
    <td> <p>The scripts is run without parameters. Instead, you'll be prompted for information.</p> <p><b>NOTE</b></p> <p>The <b><tt>trafodion_install</tt></b> script automatically checks the cluster for attributes that commonly cause installation issues, runtime performance problems, and so on. Also, various system information is collected for future reference, such as to aid with troubleshooting. The installation will abort if any configuration errors are discovered. You will need to correct such errors before re-running the <b><tt>trafodion_install</tt></b> script.</p> </td> 
    <td> 
     <div> 
      <pre>
cd installer
./trafodion_install
       </pre> 
     </div> <p>Type &quot;accept&quot; to accept the license agreement when prompted.</p> <p>Provide the requested information according to the prompts.</p> <p><b>NOTE</b></p> <p>If you choose not to start Trafodion after the installation (that is, if you enter <b><tt>N</tt></b> for <b><tt>Start Trafodion after install (Y/N)</tt></b>), you will need to manually start and initialize Trafodion after <b><tt>trafodion_install</tt></b> completes.</p> </td> 
   </tr> 
   <tr class="a"> 
    <td><b><tt>trafodion_install</tt> Completion</b></td> 
    <td>Wait for <b><tt>trafodion_install</tt></b> to complete. </td> 
    <td> <p>You will see the following message:</p> 
     <div> 
      <pre>***INFO: Installation completed successfully.</pre> 
     </div></td> 
   </tr> 
   <tr class="b"> 
    <td><b>Connect</b></td> 
    <td>Once <b><tt>trafodion_install</tt></b> completes without error, your Trafodion system should be up and running.</td> 
    <td> <p>Start a new VNC session using port :1.</p> <p>Log in as the <b><tt>trafodion</tt></b> user with the password for the VNC, which is <b><tt>traf123</tt></b> by default unless you changed it.</p> </td> 
   </tr> 
  </tbody> 
 </table> 
</div> 
<div class="section"> 
 <h2 id="Start_and_Initialize">Start and Initialize</h2> 
 <p>If you chose not to start Trafodion after the installation, start and initialize Trafodion as follows:</p> 
 <div class="source"> 
  <div class="source"> 
   <pre>cds
sqstart

[trafodion@n001 ~]$ sqlci
Trafodion Conversational Interface 1.1.0
(c) Copyright 2015 Apache Software Foundation
&gt;&gt;initialize trafodion ;
.
.
.
</pre> 
  </div> 
 </div> 
</div> 
<div class="section"> 
 <h2 id="Validate_Installation">Validate Installation</h2> 
 <p>Perform a quick sanity check using the Trafodion Conversational Interface (<b><tt>sqlci</tt></b>). Create a table with a couple of records. </p> 
 <p><b>Example</b></p> 
 <div class="source"> 
  <div class="source"> 
   <pre>[trafodion@n001 ~]$ sqlci
Trafodion Conversational Interface 1.1.0
(c) Copyright 2015 Apache Software Foundation
&gt;&gt; create table test1 (f1 int, f2 int);

--- SQL operation complete.
&gt;&gt; insert into test1 values(1,1);

--- 1 row(s) inserted.
&gt;&gt; insert into test1 values(2,2);

--- 1 row(s) inserted.
&gt;&gt; select * from test1;

F1            F2
-----------   -----------
          1             1
          2             2

--- 2 row(s) selected.
&gt;&gt; get tables;

Tables in Schema TRAFODION.SEABASE
==================================

TEST1

--- SQL operation complete.
&gt;&gt; drop table test1;
&gt;&gt; exit;
</pre> 
  </div> 
 </div> 
 <p>The SQL commands above should run successfully.</p> 
</div> 
<div class="section"> 
 <h2 id="Install_Client_Software">Install Client Software</h2> 
 <p>Download and install the Trafodion JDBC and/or ODBC drivers on your client workstation to be able to connect to Trafodion from a client application. Please refer to the <a href="docs/Trafodion_Client_Installation_Guide.html">Trafodion Client Installation Guide</a>, which describes how to install the JDBC and ODBC drivers, how to connect to Trafodion, and how to run sample programs to test the connection.</p> 
 <h1 id="troubleshooting">Troubleshooting</h1> 
 <p>Please refer to <a href="install-troubleshoot.html">Troubleshoot Trafodion Installation</a>.</p> 
 <h1 id="uninstall">Uninstall</h1> 
 <p>Please refer to <a href="uninstall.html">Unistall Trafodion</a>.</p> 
</div>
			</div>
		</div>
	</div>
	</div>

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

	<!-- Footer
	================================================== -->
	<footer class="well">
		<div class="container">
			<div class="row">
				<div class="span2 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">About</li>
						<li >
							<a href="index.html" title="Project Overview">Project Overview</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="span2 bottom-nav">
					<ul class="nav nav-list">
						<li class="nav-header">Using</li>
						<li >
							<a href="download.html" title="Download">Download</a>
						</li>
						<li class="active">
							<a href="#" title="Install">Install</a>
						</li>
						<li >
							<a href="uninstall.html" title="Uninstall">Uninstall</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="documentation.html" title="Documentation">Documentation</a>
						</li>
						<li >
							<a href="port-assignment.html" title="Port Assignments">Port Assignments</a>
						</li>
						<li >
							<a href="faq.html" title="FAQ">FAQ</a>
						</li>
						<li >
							<a href="release-notes.html" title="Release Notes">Release Notes</a>
						</li>
					</ul>
				</div>
				<div class="span2 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="span2 bottom-nav">
					<ul class="nav nav-list">
					</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>
