/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/*
* This source file is based on code taken from SQLLine 1.0.2
* See SQLLine notice in LICENSE
*/
package org.apache.hive.beeline;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.Closeable;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.SequenceInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Statement;
import java.text.ChoiceFormat;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import jline.console.completer.Completer;
import jline.console.completer.StringsCompleter;
import jline.console.completer.FileNameCompleter;
import jline.console.ConsoleReader;
import jline.console.history.FileHistory;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.io.IOUtils;
import org.apache.hive.beeline.cli.CliOptionsProcessor;
import org.apache.hive.common.util.ShutdownHookManager;
import org.apache.hive.beeline.hs2connection.BeelineHS2ConnectionFileParseException;
import org.apache.hive.beeline.hs2connection.HS2ConnectionFileUtils;
import org.apache.hive.beeline.hs2connection.UserHS2ConnectionFileParser;
import org.apache.hive.beeline.hs2connection.HS2ConnectionFileParser;
import org.apache.hive.beeline.hs2connection.HiveSiteHS2ConnectionFileParser;
import org.apache.thrift.transport.TTransportException;
import com.google.common.annotations.VisibleForTesting;
import org.apache.hive.jdbc.Utils;
import org.apache.hive.jdbc.Utils.JdbcConnectionParams;
/**
* A console SQL shell with command completion.
* <p>
* TODO:
* <ul>
* <li>User-friendly connection prompts</li>
* <li>Page results</li>
* <li>Handle binary data (blob fields)</li>
* <li>Implement command aliases</li>
* <li>Stored procedure execution</li>
* <li>Binding parameters to prepared statements</li>
* <li>Scripting language</li>
* <li>XA transactions</li>
* </ul>
*
*/
@SuppressWarnings("static-access")
public class BeeLine implements Closeable {
private static final ResourceBundle resourceBundle =
ResourceBundle.getBundle(BeeLine.class.getSimpleName());
private final BeeLineSignalHandler signalHandler;
private final Runnable shutdownHook;
private static final String separator = System.getProperty("line.separator");
private boolean exit = false;
private final DatabaseConnections connections = new DatabaseConnections();
public static final String COMMAND_PREFIX = "!";
private Collection<Driver> drivers = null;
private final BeeLineOpts opts = new BeeLineOpts(this, System.getProperties());
private String lastProgress = null;
private final Map<SQLWarning, Date> seenWarnings = new HashMap<SQLWarning, Date>();
private final Commands commands = new Commands(this);
private OutputFile scriptOutputFile = null;
private OutputFile recordOutputFile = null;
private PrintStream outputStream = new PrintStream(System.out, true);
private PrintStream errorStream = new PrintStream(System.err, true);
private InputStream inputStream = System.in;
private ConsoleReader consoleReader;
private List<String> batch = null;
private final Reflector reflector = new Reflector(this);
private String dbName = null;
private String currentDatabase = null;
private FileHistory history;
// Indicates if this instance of beeline is running in compatibility mode, or beeline mode
private boolean isBeeLine = true;
// Indicates that we are in test mode.
// Print only the errors, the operation log and the query results.
private boolean isTestMode = false;
private static final Options options = new Options();
public static final String BEELINE_DEFAULT_JDBC_DRIVER = "org.apache.hive.jdbc.HiveDriver";
public static final String DEFAULT_DATABASE_NAME = "default";
private static final String SCRIPT_OUTPUT_PREFIX = ">>>";
private static final int SCRIPT_OUTPUT_PAD_SIZE = 5;
private static final int ERRNO_OK = 0;
private static final int ERRNO_ARGS = 1;
private static final int ERRNO_OTHER = 2;
private static final String HIVE_VAR_PREFIX = "--hivevar";
private static final String HIVE_CONF_PREFIX = "--hiveconf";
private static final String PROP_FILE_PREFIX = "--property-file";
static final String PASSWD_MASK = "[passwd stripped]";
private final Map<Object, Object> formats = map(new Object[] {
"vertical", new VerticalOutputFormat(this),
"table", new TableOutputFormat(this),
"csv2", new SeparatedValuesOutputFormat(this, ','),
"tsv2", new SeparatedValuesOutputFormat(this, '\t'),
"dsv", new SeparatedValuesOutputFormat(this, BeeLineOpts.DEFAULT_DELIMITER_FOR_DSV),
"csv", new DeprecatedSeparatedValuesOutputFormat(this, ','),
"tsv", new DeprecatedSeparatedValuesOutputFormat(this, '\t'),
"xmlattr", new XMLAttributeOutputFormat(this),
"xmlelements", new XMLElementOutputFormat(this),
});
private List<String> supportedLocalDriver =
new ArrayList<String>(Arrays.asList("com.mysql.jdbc.Driver", "org.postgresql.Driver"));
final CommandHandler[] commandHandlers = new CommandHandler[] {
new ReflectiveCommandHandler(this, new String[] {"quit", "done", "exit"},
null),
new ReflectiveCommandHandler(this, new String[] {"connect", "open"},
new Completer[] {new StringsCompleter(getConnectionURLExamples())}),
new ReflectiveCommandHandler(this, new String[] {"describe"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"indexes"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"primarykeys"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"exportedkeys"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"manual"},
null),
new ReflectiveCommandHandler(this, new String[] {"importedkeys"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"procedures"},
null),
new ReflectiveCommandHandler(this, new String[] {"tables"},
null),
new ReflectiveCommandHandler(this, new String[] {"typeinfo"},
null),
new ReflectiveCommandHandler(this, new String[] {"columns"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"reconnect"},
null),
new ReflectiveCommandHandler(this, new String[] {"dropall"},
new Completer[] {new TableNameCompletor(this)}),
new ReflectiveCommandHandler(this, new String[] {"history"},
null),
new ReflectiveCommandHandler(this, new String[] {"metadata"},
new Completer[] {
new StringsCompleter(getMetadataMethodNames())}),
new ReflectiveCommandHandler(this, new String[] {"nativesql"},
null),
new ReflectiveCommandHandler(this, new String[] {"dbinfo"},
null),
new ReflectiveCommandHandler(this, new String[] {"rehash"},
null),
new ReflectiveCommandHandler(this, new String[] {"verbose"},
null),
new ReflectiveCommandHandler(this, new String[] {"run"},
new Completer[] {new FileNameCompleter()}),
new ReflectiveCommandHandler(this, new String[] {"batch"},
null),
new ReflectiveCommandHandler(this, new String[] {"list"},
null),
new ReflectiveCommandHandler(this, new String[] {"all"},
null),
new ReflectiveCommandHandler(this, new String[] {"go", "#"},
null),
new ReflectiveCommandHandler(this, new String[] {"script"},
new Completer[] {new FileNameCompleter()}),
new ReflectiveCommandHandler(this, new String[] {"record"},
new Completer[] {new FileNameCompleter()}),
new ReflectiveCommandHandler(this, new String[] {"brief"},
null),
new ReflectiveCommandHandler(this, new String[] {"close"},
null),
new ReflectiveCommandHandler(this, new String[] {"closeall"},
null),
new ReflectiveCommandHandler(this, new String[] {"isolation"},
new Completer[] {new StringsCompleter(getIsolationLevels())}),
new ReflectiveCommandHandler(this, new String[] {"outputformat"},
new Completer[] {new StringsCompleter(
formats.keySet().toArray(new String[0]))}),
new ReflectiveCommandHandler(this, new String[] {"autocommit"},
null),
new ReflectiveCommandHandler(this, new String[] {"commit"},
null),
new ReflectiveCommandHandler(this, new String[] {"properties"},
new Completer[] {new FileNameCompleter()}),
new ReflectiveCommandHandler(this, new String[] {"rollback"},
null),
new ReflectiveCommandHandler(this, new String[] {"help", "?"},
null),
new ReflectiveCommandHandler(this, new String[] {"set"},
getOpts().optionCompleters()),
new ReflectiveCommandHandler(this, new String[] {"save"},
null),
new ReflectiveCommandHandler(this, new String[] {"scan"},
null),
new ReflectiveCommandHandler(this, new String[] {"sql"},
null),
new ReflectiveCommandHandler(this, new String[] {"sh"},
null),
new ReflectiveCommandHandler(this, new String[] {"call"},
null),
new ReflectiveCommandHandler(this, new String[] {"nullemptystring"},
new Completer[] {new BooleanCompleter()}),
new ReflectiveCommandHandler(this, new String[]{"addlocaldriverjar"},
null),
new ReflectiveCommandHandler(this, new String[]{"addlocaldrivername"},
null),
new ReflectiveCommandHandler(this, new String[]{"delimiter"},
null)
};
private final Completer beeLineCommandCompleter = new BeeLineCommandCompleter(Arrays.asList(commandHandlers));
static final SortedSet<String> KNOWN_DRIVERS = new TreeSet<String>(Arrays.asList(
new String[] {
"org.apache.hive.jdbc.HiveDriver",
"org.apache.hadoop.hive.jdbc.HiveDriver",
}));
static {
try {
Class.forName("jline.console.ConsoleReader");
} catch (Throwable t) {
throw new ExceptionInInitializerError("jline-missing");
}
}
static {
// -d <driver class>
options.addOption(OptionBuilder
.hasArg()
.withArgName("driver class")
.withDescription("the driver class to use")
.create('d'));
// -u <database url>
options.addOption(OptionBuilder
.hasArg()
.withArgName("database url")
.withDescription("the JDBC URL to connect to")
.create('u'));
// -r
options.addOption(OptionBuilder
.withLongOpt("reconnect")
.withDescription("Reconnect to last saved connect url (in conjunction with !save)")
.create('r'));
// -n <username>
options.addOption(OptionBuilder
.hasArg()
.withArgName("username")
.withDescription("the username to connect as")
.create('n'));
// -p <password>
options.addOption(OptionBuilder
.hasArg()
.withArgName("password")
.withDescription("the password to connect as")
.hasOptionalArg()
.create('p'));
// -w (or) --password-file <file>
options.addOption(OptionBuilder
.hasArg()
.withArgName("password-file")
.withDescription("the password file to read password from")
.withLongOpt("password-file")
.create('w'));
// -a <authType>
options.addOption(OptionBuilder
.hasArg()
.withArgName("authType")
.withDescription("the authentication type")
.create('a'));
// -i <init file>
options.addOption(OptionBuilder
.hasArg()
.withArgName("init")
.withDescription("script file for initialization")
.create('i'));
// -e <query>
options.addOption(OptionBuilder
.hasArgs()
.withArgName("query")
.withDescription("query that should be executed")
.create('e'));
// -f <script file>
options.addOption(OptionBuilder
.hasArg()
.withArgName("file")
.withDescription("script file that should be executed")
.create('f'));
// -help
options.addOption(OptionBuilder
.withLongOpt("help")
.withDescription("display this message")
.create('h'));
// Substitution option --hivevar
options.addOption(OptionBuilder
.withValueSeparator()
.hasArgs(2)
.withArgName("key=value")
.withLongOpt("hivevar")
.withDescription("hive variable name and value")
.create());
//hive conf option --hiveconf
options.addOption(OptionBuilder
.withValueSeparator()
.hasArgs(2)
.withArgName("property=value")
.withLongOpt("hiveconf")
.withDescription("Use value for given property")
.create());
// --property-file <file>
options.addOption(OptionBuilder
.hasArg()
.withLongOpt("property-file")
.withDescription("the file to read configuration properties from")
.create());
}
static Manifest getManifest() throws IOException {
URL base = BeeLine.class.getResource("/META-INF/MANIFEST.MF");
URLConnection c = base.openConnection();
if (c instanceof JarURLConnection) {
return ((JarURLConnection) c).getManifest();
}
return null;
}
String getManifestAttribute(String name) {
try {
Manifest m = getManifest();
if (m == null) {
return "??";
}
Attributes attrs = m.getAttributes("beeline");
if (attrs == null) {
return "???";
}
String val = attrs.getValue(name);
if (val == null || "".equals(val)) {
return "????";
}
return val;
} catch (Exception e) {
e.printStackTrace(errorStream);
return "?????";
}
}
String getApplicationTitle() {
Package pack = BeeLine.class.getPackage();
return loc("app-introduction", new Object[] { "Beeline",
pack.getImplementationVersion() == null ? "???" : pack.getImplementationVersion(),
"Apache Hive",
// getManifestAttribute ("Specification-Title"),
// getManifestAttribute ("Implementation-Version"),
// getManifestAttribute ("Implementation-ReleaseDate"),
// getManifestAttribute ("Implementation-Vendor"),
// getManifestAttribute ("Implementation-License"),
});
}
String getApplicationContactInformation() {
return getManifestAttribute("Implementation-Vendor");
}
String loc(String res) {
return loc(res, new Object[0]);
}
String loc(String res, int param) {
try {
return MessageFormat.format(
new ChoiceFormat(resourceBundle.getString(res)).format(param),
new Object[] {new Integer(param)});
} catch (Exception e) {
return res + ": " + param;
}
}
String loc(String res, Object param1) {
return loc(res, new Object[] {param1});
}
String loc(String res, Object param1, Object param2) {
return loc(res, new Object[] {param1, param2});
}
String loc(String res, Object[] params) {
try {
return MessageFormat.format(resourceBundle.getString(res), params);
} catch (Exception e) {
e.printStackTrace(getErrorStream());
try {
return res + ": " + Arrays.asList(params);
} catch (Exception e2) {
return res;
}
}
}
protected String locElapsedTime(long milliseconds) {
if (getOpts().getShowElapsedTime()) {
return loc("time-ms", new Object[] {new Double(milliseconds / 1000d)});
}
return "";
}
/**
* Starts the program.
*/
public static void main(String[] args) throws IOException {
mainWithInputRedirection(args, null);
}
/**
* Starts the program with redirected input. For redirected output,
* setOutputStream() and setErrorStream can be used.
* Exits with 0 on success, 1 on invalid arguments, and 2 on any other error
*
* @param args
* same as main()
*
* @param inputStream
* redirected input, or null to use standard input
*/
public static void mainWithInputRedirection(String[] args, InputStream inputStream)
throws IOException {
BeeLine beeLine = new BeeLine();
try {
int status = beeLine.begin(args, inputStream);
if (!Boolean.getBoolean(BeeLineOpts.PROPERTY_NAME_EXIT)) {
System.exit(status);
}
} finally {
beeLine.close();
}
}
public BeeLine() {
this(true);
}
public BeeLine(boolean isBeeLine) {
this.isBeeLine = isBeeLine;
this.signalHandler = new SunSignalHandler(this);
this.shutdownHook = new Runnable() {
@Override
public void run() {
try {
if (history != null) {
history.setMaxSize(getOpts().getMaxHistoryRows());
history.flush();
}
} catch (IOException e) {
error(e);
} finally {
close();
}
}
};
}
DatabaseConnection getDatabaseConnection() {
return getDatabaseConnections().current();
}
Connection getConnection() throws SQLException {
if (getDatabaseConnections().current() == null
|| getDatabaseConnections().current().getConnection() == null) {
throw new IllegalArgumentException(loc("no-current-connection"));
}
return getDatabaseConnections().current().getConnection();
}
DatabaseMetaData getDatabaseMetaData() {
if (getDatabaseConnections().current() == null) {
throw new IllegalArgumentException(loc("no-current-connection"));
}
if (getDatabaseConnections().current().getDatabaseMetaData() == null) {
throw new IllegalArgumentException(loc("no-current-connection"));
}
return getDatabaseConnections().current().getDatabaseMetaData();
}
public String[] getIsolationLevels() {
return new String[] {
"TRANSACTION_NONE",
"TRANSACTION_READ_COMMITTED",
"TRANSACTION_READ_UNCOMMITTED",
"TRANSACTION_REPEATABLE_READ",
"TRANSACTION_SERIALIZABLE",
};
}
public String[] getMetadataMethodNames() {
try {
TreeSet<String> mnames = new TreeSet<String>();
Method[] m = DatabaseMetaData.class.getDeclaredMethods();
for (int i = 0; m != null && i < m.length; i++) {
mnames.add(m[i].getName());
}
return mnames.toArray(new String[0]);
} catch (Throwable t) {
return new String[0];
}
}
public String[] getConnectionURLExamples() {
return new String[] {
"jdbc:JSQLConnect://<hostname>/database=<database>",
"jdbc:cloudscape:<database>;create=true",
"jdbc:twtds:sqlserver://<hostname>/<database>",
"jdbc:daffodilDB_embedded:<database>;create=true",
"jdbc:datadirect:db2://<hostname>:50000;databaseName=<database>",
"jdbc:inetdae:<hostname>:1433",
"jdbc:datadirect:oracle://<hostname>:1521;SID=<database>;MaxPooledStatements=0",
"jdbc:datadirect:sqlserver://<hostname>:1433;SelectMethod=cursor;DatabaseName=<database>",
"jdbc:datadirect:sybase://<hostname>:5000",
"jdbc:db2://<hostname>/<database>",
"jdbc:hive2://<hostname>",
"jdbc:hsqldb:<database>",
"jdbc:idb:<database>.properties",
"jdbc:informix-sqli://<hostname>:1526/<database>:INFORMIXSERVER=<database>",
"jdbc:interbase://<hostname>//<database>.gdb",
"jdbc:microsoft:sqlserver://<hostname>:1433;DatabaseName=<database>;SelectMethod=cursor",
"jdbc:mysql://<hostname>/<database>?autoReconnect=true",
"jdbc:oracle:thin:@<hostname>:1521:<database>",
"jdbc:pointbase:<database>,database.home=<database>,create=true",
"jdbc:postgresql://<hostname>:5432/<database>",
"jdbc:postgresql:net//<hostname>/<database>",
"jdbc:sybase:Tds:<hostname>:4100/<database>?ServiceName=<database>",
"jdbc:weblogic:mssqlserver4:<database>@<hostname>:1433",
"jdbc:odbc:<database>",
"jdbc:sequelink://<hostname>:4003/[Oracle]",
"jdbc:sequelink://<hostname>:4004/[Informix];Database=<database>",
"jdbc:sequelink://<hostname>:4005/[Sybase];Database=<database>",
"jdbc:sequelink://<hostname>:4006/[SQLServer];Database=<database>",
"jdbc:sequelink://<hostname>:4011/[ODBC MS Access];Database=<database>",
"jdbc:openlink://<hostname>/DSN=SQLServerDB/UID=sa/PWD=",
"jdbc:solid://<hostname>:<port>/<UID>/<PWD>",
"jdbc:dbaw://<hostname>:8889/<database>",
};
}
/**
* Entry point to creating a {@link ColorBuffer} with color
* enabled or disabled depending on the value of {@link BeeLineOpts#getColor}.
*/
ColorBuffer getColorBuffer() {
return new ColorBuffer(getOpts().getColor());
}
/**
* Entry point to creating a {@link ColorBuffer} with color
* enabled or disabled depending on the value of {@link BeeLineOpts#getColor}.
*/
ColorBuffer getColorBuffer(String msg) {
return new ColorBuffer(msg, getOpts().getColor());
}
public class BeelineParser extends GnuParser {
private boolean isPasswordOptionSet = false;
@Override
protected void processOption(String arg, final ListIterator iter) throws ParseException {
if (isBeeLineOpt(arg)) {
processBeeLineOpt(arg);
} else {
//-p with the next argument being for BeeLineOpts
if ("-p".equals(arg)) {
isPasswordOptionSet = true;
if(iter.hasNext()) {
String next = (String) iter.next();
if(isBeeLineOpt(next)) {
processBeeLineOpt(next);
return;
} else {
iter.previous();
}
}
}
super.processOption(arg, iter);
}
}
private void processBeeLineOpt(final String arg) {
String stripped = arg.substring(2, arg.length());
String[] parts = split(stripped, "=");
debug(loc("setting-prop", Arrays.asList(parts)));
if (parts.length >= 2) {
getOpts().set(parts[0], parts[1], true);
} else {
getOpts().set(parts[0], "true", true);
}
}
private boolean isBeeLineOpt(String arg) {
return arg.startsWith("--") && !(HIVE_VAR_PREFIX.equals(arg) || (HIVE_CONF_PREFIX.equals(arg))
|| "--help".equals(arg) || PROP_FILE_PREFIX.equals(arg));
}
}
int initArgsFromCliVars(String[] args) {
List<String> commands = Collections.emptyList();
CliOptionsProcessor optionsProcessor = new CliOptionsProcessor();
if (!optionsProcessor.process(args)) {
return 1;
}
CommandLine commandLine = optionsProcessor.getCommandLine();
Properties confProps = commandLine.getOptionProperties("hiveconf");
for (String propKey : confProps.stringPropertyNames()) {
setHiveConfVar(propKey, confProps.getProperty(propKey));
}
Properties hiveVars = commandLine.getOptionProperties("define");
for (String propKey : hiveVars.stringPropertyNames()) {
getOpts().getHiveConfVariables().put(propKey, hiveVars.getProperty(propKey));
}
Properties hiveVars2 = commandLine.getOptionProperties("hivevar");
for (String propKey : hiveVars2.stringPropertyNames()) {
getOpts().getHiveConfVariables().put(propKey, hiveVars2.getProperty(propKey));
}
getOpts().setScriptFile(commandLine.getOptionValue("f"));
if (commandLine.getOptionValues("i") != null) {
getOpts().setInitFiles(commandLine.getOptionValues("i"));
}
dbName = commandLine.getOptionValue("database");
getOpts().setVerbose(Boolean.parseBoolean(commandLine.getOptionValue("verbose")));
getOpts().setSilent(Boolean.parseBoolean(commandLine.getOptionValue("slient")));
int code = 0;
if (commandLine.getOptionValues("e") != null) {
commands = Arrays.asList(commandLine.getOptionValues("e"));
}
if (!commands.isEmpty() && getOpts().getScriptFile() != null) {
System.err.println("The '-e' and '-f' options cannot be specified simultaneously");
optionsProcessor.printCliUsage();
return 1;
}
if (!commands.isEmpty()) {
embeddedConnect();
connectDBInEmbededMode();
for (Iterator<String> i = commands.iterator(); i.hasNext(); ) {
String command = i.next().toString();
debug(loc("executing-command", command));
if (!dispatch(command)) {
code++;
}
}
exit = true; // execute and exit
}
return code;
}
int initArgs(String[] args) {
List<String> commands = Collections.emptyList();
CommandLine cl;
BeelineParser beelineParser;
try {
beelineParser = new BeelineParser();
cl = beelineParser.parse(options, args);
} catch (ParseException e1) {
output(e1.getMessage());
usage();
return -1;
}
boolean connSuccessful = connectUsingArgs(beelineParser, cl);
// checks if default hs2 connection configuration file is present
// and uses it to connect if found
// no-op if the file is not present
if(!connSuccessful && !exit) {
connSuccessful = defaultBeelineConnect();
}
int code = 0;
if (cl.getOptionValues('e') != null) {
commands = Arrays.asList(cl.getOptionValues('e'));
}
if (!commands.isEmpty() && getOpts().getScriptFile() != null) {
error("The '-e' and '-f' options cannot be specified simultaneously");
return 1;
} else if(!commands.isEmpty() && !connSuccessful) {
error("Cannot run commands specified using -e. No current connection");
return 1;
}
if (!commands.isEmpty()) {
for (Iterator<String> i = commands.iterator(); i.hasNext();) {
String command = i.next().toString();
debug(loc("executing-command", command));
if (!dispatch(command)) {
code++;
}
}
exit = true; // execute and exit
}
return code;
}
/*
* Connects using the command line arguments. There are two
* possible ways to connect here 1. using the cmd line arguments like -u
* or using !properties <property-file>
*/
private boolean connectUsingArgs(BeelineParser beelineParser, CommandLine cl) {
String driver = null, user = null, pass = "", url = null;
String auth = null;
if (cl.hasOption("help")) {
usage();
getOpts().setHelpAsked(true);
return true;
}
Properties hiveVars = cl.getOptionProperties("hivevar");
for (String key : hiveVars.stringPropertyNames()) {
getOpts().getHiveVariables().put(key, hiveVars.getProperty(key));
}
Properties hiveConfs = cl.getOptionProperties("hiveconf");
for (String key : hiveConfs.stringPropertyNames()) {
setHiveConfVar(key, hiveConfs.getProperty(key));
}
driver = cl.getOptionValue("d");
auth = cl.getOptionValue("a");
user = cl.getOptionValue("n");
getOpts().setAuthType(auth);
if (cl.hasOption("w")) {
pass = obtainPasswordFromFile(cl.getOptionValue("w"));
} else {
if (beelineParser.isPasswordOptionSet) {
pass = cl.getOptionValue("p");
}
}
url = cl.getOptionValue("u");
if ((url == null) && cl.hasOption("reconnect")){
// If url was not specified with -u, but -r was present, use that.
url = getOpts().getLastConnectedUrl();
}
getOpts().setInitFiles(cl.getOptionValues("i"));
getOpts().setScriptFile(cl.getOptionValue("f"));
if (url != null) {
String com;
String comForDebug;
if(pass != null) {
com = constructCmd(url, user, pass, driver, false);
comForDebug = constructCmd(url, user, pass, driver, true);
} else {
com = constructCmdUrl(url, user, driver, false);
comForDebug = constructCmdUrl(url, user, driver, true);
}
debug(comForDebug);
return dispatch(com);
}
// load property file
String propertyFile = cl.getOptionValue("property-file");
if (propertyFile != null) {
try {
this.consoleReader = new ConsoleReader();
} catch (IOException e) {
handleException(e);
}
if (!dispatch("!properties " + propertyFile)) {
exit = true;
return false;
}
}
return false;
}
private void setHiveConfVar(String key, String val) {
getOpts().getHiveConfVariables().put(key, val);
if (HiveConf.ConfVars.HIVE_EXECUTION_ENGINE.varname.equals(key) && "mr".equals(val)) {
info(HiveConf.generateMrDeprecationWarning());
}
}
private String constructCmd(String url, String user, String pass, String driver, boolean stripPasswd) {
return new StringBuilder()
.append("!connect ")
.append(url)
.append(" ")
.append(user == null || user.length() == 0 ? "''" : user)
.append(" ")
.append(stripPasswd ? PASSWD_MASK : (pass.length() == 0 ? "''" : pass))
.append(" ")
.append((driver == null ? "" : driver))
.toString();
}
/**
* This is an internal method used to create !connect command when -p option is used without
* providing the password on the command line. Connect command returned should be ; separated
* key-value pairs along with the url. We cannot use space separated !connect url user [password]
* [driver] here since both password and driver are optional and there would be no way to
* distinguish if the last string is password or driver
*
* @param url connection url passed using -u argument on the command line
* @param user username passed through command line
* @param driver driver passed through command line -d option
* @param stripPasswd when set to true generates a !connect command which strips the password for
* logging purposes
* @return !connect command
*/
private String constructCmdUrl(String url, String user, String driver,
boolean stripPasswd) {
StringBuilder command = new StringBuilder("!connect ");
command.append(url);
//if the url does not have a database name add the trailing '/'
if(isTrailingSlashNeeded(url)) {
command.append('/');
}
command.append(';');
// if the username is not already available in the URL add the one provided
if (Utils.parsePropertyFromUrl(url, JdbcConnectionParams.AUTH_USER) == null) {
command.append(JdbcConnectionParams.AUTH_USER);
command.append('=');
command.append((user == null || user.length() == 0 ? "''" : user));
}
if (stripPasswd) {
// if password is available in url it needs to be striped
int startIndex = command.indexOf(JdbcConnectionParams.AUTH_PASSWD + "=")
+ JdbcConnectionParams.AUTH_PASSWD.length() + 2;
if(startIndex != -1) {
int endIndex = command.toString().indexOf(";", startIndex);
command.replace(startIndex, (endIndex == -1 ? command.length() : endIndex),
BeeLine.PASSWD_MASK);
}
}
// if the driver is not already available in the URL add the one provided
if (Utils.parsePropertyFromUrl(url, JdbcConnectionParams.PROPERTY_DRIVER) == null
&& driver != null) {
command.append(';');
command.append(JdbcConnectionParams.PROPERTY_DRIVER);
command.append("=");
command.append(driver);
}
return command.toString();
}
/*
* Returns true if trailing slash is needed to be appended to the url
*/
private boolean isTrailingSlashNeeded(String url) {
if (url.toLowerCase().startsWith("jdbc:hive2://")) {
return url.indexOf('/', "jdbc:hive2://".length()) < 0;
}
return false;
}
/**
* Obtains a password from the passed file path.
*/
private String obtainPasswordFromFile(String passwordFilePath) {
try {
Path path = Paths.get(passwordFilePath);
byte[] passwordFileContents = Files.readAllBytes(path);
return new String(passwordFileContents, "UTF-8").trim();
} catch (Exception e) {
throw new RuntimeException("Unable to read user password from the password file: "
+ passwordFilePath, e);
}
}
public void updateOptsForCli() {
getOpts().updateBeeLineOptsFromConf();
getOpts().setShowHeader(false);
getOpts().setOutputFormat("dsv");
getOpts().setDelimiterForDSV(' ');
getOpts().setNullEmptyString(true);
}
/**
* Start accepting input from stdin, and dispatch it
* to the appropriate {@link CommandHandler} until the
* global variable <code>exit</code> is true.
*/
public int begin(String[] args, InputStream inputStream) throws IOException {
try {
// load the options first, so we can override on the command line
getOpts().load();
} catch (Exception e) {
// nothing
}
setupHistory();
//add shutdown hook to cleanup the beeline for smooth exit
addBeelineShutdownHook();
//this method also initializes the consoleReader which is
//needed by initArgs for certain execution paths
ConsoleReader reader = initializeConsoleReader(inputStream);
if (isBeeLine) {
int code = initArgs(args);
if (code != 0) {
return code;
}
} else {
int code = initArgsFromCliVars(args);
if (code != 0 || exit) {
return code;
}
defaultConnect(false);
}
if (getOpts().isHelpAsked()) {
return 0;
}
if (getOpts().getScriptFile() != null) {
return executeFile(getOpts().getScriptFile());
}
try {
info(getApplicationTitle());
} catch (Exception e) {
// ignore
}
return execute(reader, false);
}
/*
* Attempts to make a connection using default HS2 connection config file if available
* if there connection is not made return false
*
*/
private boolean defaultBeelineConnect() {
String url;
try {
url = getDefaultConnectionUrl();
if (url == null) {
debug("Default hs2 connection config file not found");
return false;
}
} catch (BeelineHS2ConnectionFileParseException e) {
error(e);
return false;
}
return dispatch("!connect " + url);
}
private String getDefaultConnectionUrl() throws BeelineHS2ConnectionFileParseException {
HS2ConnectionFileParser userHS2ConnFileParser = getUserHS2ConnFileParser();
if (!userHS2ConnFileParser.configExists()) {
// nothing to do if there is no user HS2 connection configuration file
return null;
}
// get the connection properties from user specific config file
Properties userConnectionProperties = userHS2ConnFileParser.getConnectionProperties();
// load the HS2 connection url properties from hive-site.xml if it is present in the classpath
HS2ConnectionFileParser hiveSiteParser = getHiveSiteHS2ConnectionFileParser();
Properties hiveSiteConnectionProperties = hiveSiteParser.getConnectionProperties();
// add/override properties found from hive-site with user-specific properties
for (String key : userConnectionProperties.stringPropertyNames()) {
if (hiveSiteConnectionProperties.containsKey(key)) {
debug("Overriding connection url property " + key
+ " from user connection configuration file");
}
hiveSiteConnectionProperties.setProperty(key, userConnectionProperties.getProperty(key));
}
// return the url based on the aggregated connection properties
return HS2ConnectionFileUtils.getUrl(hiveSiteConnectionProperties);
}
/*
* Increased visibility of this method is only for providing better test coverage
*/
@VisibleForTesting
public HS2ConnectionFileParser getUserHS2ConnFileParser() {
return new UserHS2ConnectionFileParser();
}
/*
* Increased visibility of this method is only for providing better test coverage
*/
@VisibleForTesting
public HS2ConnectionFileParser getHiveSiteHS2ConnectionFileParser() {
return new HiveSiteHS2ConnectionFileParser();
}
int runInit() {
String initFiles[] = getOpts().getInitFiles();
if (initFiles != null && initFiles.length != 0) {
for (String initFile : initFiles) {
info("Running init script " + initFile);
try {
return executeFile(initFile);
} finally {
exit = false;
}
}
}
return ERRNO_OK;
}
private int embeddedConnect() {
if (!execCommandWithPrefix("!connect " + Utils.URL_PREFIX + " '' ''")) {
return ERRNO_OTHER;
} else {
return ERRNO_OK;
}
}
private int connectDBInEmbededMode() {
if (dbName != null && !dbName.isEmpty()) {
if (!dispatch("use " + dbName + ";")) {
return ERRNO_OTHER;
}
}
return ERRNO_OK;
}
public int defaultConnect(boolean exitOnError) {
if (embeddedConnect() != ERRNO_OK && exitOnError) {
return ERRNO_OTHER;
}
if (connectDBInEmbededMode() != ERRNO_OK && exitOnError) {
return ERRNO_OTHER;
}
return ERRNO_OK;
}
private int executeFile(String fileName) {
InputStream fileStream = null;
try {
if (!isBeeLine) {
org.apache.hadoop.fs.Path path = new org.apache.hadoop.fs.Path(fileName);
FileSystem fs;
HiveConf conf = getCommands().getHiveConf(true);
if (!path.toUri().isAbsolute()) {
fs = FileSystem.getLocal(conf);
path = fs.makeQualified(path);
} else {
fs = FileSystem.get(path.toUri(), conf);
}
fileStream = fs.open(path);
} else {
fileStream = new FileInputStream(fileName);
}
return execute(initializeConsoleReader(fileStream), !getOpts().getForce());
} catch (Throwable t) {
handleException(t);
return ERRNO_OTHER;
} finally {
IOUtils.closeStream(fileStream);
output(""); // dummy new line
}
}
private int execute(ConsoleReader reader, boolean exitOnError) {
int lastExecutionResult = ERRNO_OK;
while (!exit) {
try {
// Execute one instruction; terminate on executing a script if there is an error
// in silent mode, prevent the query and prompt being echoed back to terminal
String line = (getOpts().isSilent() && getOpts().getScriptFile() != null) ? reader
.readLine(null, ConsoleReader.NULL_MASK) : reader.readLine(getPrompt());
// trim line
if (line != null) {
line = line.trim();
}
if (!dispatch(line)) {
lastExecutionResult = ERRNO_OTHER;
if (exitOnError) break;
} else if (line != null) {
lastExecutionResult = ERRNO_OK;
}
} catch (Throwable t) {
handleException(t);
return ERRNO_OTHER;
}
}
return lastExecutionResult;
}
@Override
public void close() {
commands.closeall(null);
}
private void setupHistory() throws IOException {
if (this.history != null) {
return;
}
this.history = new FileHistory(new File(getOpts().getHistoryFile()));
}
private void addBeelineShutdownHook() throws IOException {
// add shutdown hook to flush the history to history file and it also close all open connections
ShutdownHookManager.addShutdownHook(getShutdownHook());
}
public ConsoleReader initializeConsoleReader(InputStream inputStream) throws IOException {
if (inputStream != null) {
// ### NOTE: fix for sf.net bug 879425.
// Working around an issue in jline-2.1.2, see https://github.com/jline/jline/issues/10
// by appending a newline to the end of inputstream
InputStream inputStreamAppendedNewline = new SequenceInputStream(inputStream,
new ByteArrayInputStream((new String("\n")).getBytes()));
consoleReader = new ConsoleReader(inputStreamAppendedNewline, getErrorStream());
consoleReader.setCopyPasteDetection(true); // jline will detect if <tab> is regular character
} else {
consoleReader = new ConsoleReader(getInputStream(), getErrorStream());
}
//disable the expandEvents for the purpose of backward compatibility
consoleReader.setExpandEvents(false);
try {
// now set the output for the history
consoleReader.setHistory(this.history);
} catch (Exception e) {
handleException(e);
}
if (inputStream instanceof FileInputStream || inputStream instanceof FSDataInputStream) {
// from script.. no need to load history and no need of completer, either
return consoleReader;
}
consoleReader.addCompleter(new BeeLineCompleter(this));
return consoleReader;
}
void usage() {
output(loc("cmd-usage"));
}
/**
* This method is used for executing commands beginning with !
* @param line
* @return
*/
public boolean execCommandWithPrefix(String line) {
Map<String, CommandHandler> cmdMap = new TreeMap<String, CommandHandler>();
line = line.substring(1);
for (int i = 0; i < commandHandlers.length; i++) {
String match = commandHandlers[i].matches(line);
if (match != null) {
cmdMap.put(match, commandHandlers[i]);
}
}
if (cmdMap.size() == 0) {
return error(loc("unknown-command", line));
}
if (cmdMap.size() > 1) {
// any exact match?
CommandHandler handler = cmdMap.get(line);
if (handler == null) {
return error(loc("multiple-matches", cmdMap.keySet().toString()));
}
return handler.execute(line);
}
return cmdMap.values().iterator().next().execute(line);
}
/**
* Dispatch the specified line to the appropriate {@link CommandHandler}.
*
* @param line
* the command-line to dispatch
* @return true if the command was "successful"
*/
boolean dispatch(String line) {
if (line == null) {
// exit
exit = true;
return true;
}
if (line.trim().length() == 0) {
return true;
}
if (isComment(line)) {
return true;
}
line = line.trim();
// save it to the current script, if any
if (scriptOutputFile != null) {
scriptOutputFile.addLine(line);
}
if (isHelpRequest(line)) {
line = "!help";
}
if (isBeeLine) {
if (line.startsWith(COMMAND_PREFIX)) {
// handle SQLLine command in beeline which starts with ! and does not end with ;
return execCommandWithPrefix(line);
} else {
return commands.sql(line, getOpts().getEntireLineAsCommand());
}
} else {
return commands.sql(line, getOpts().getEntireLineAsCommand());
}
}
/**
* Test whether a line requires a continuation.
*
* @param line
* the line to be tested
*
* @return true if continuation required
*/
boolean needsContinuation(String line) {
if (isHelpRequest(line)) {
return false;
}
if (line.startsWith(COMMAND_PREFIX)) {
return false;
}
if (isComment(line)) {
return false;
}
String trimmed = line.trim();
if (trimmed.length() == 0) {
return false;
}
if (!getOpts().isAllowMultiLineCommand()) {
return false;
}
return !trimmed.endsWith(getOpts().getDelimiter());
}
/**
* Test whether a line is a help request other than !help.
*
* @param line
* the line to be tested
*
* @return true if a help request
*/
boolean isHelpRequest(String line) {
return line.equals("?") || line.equalsIgnoreCase("help");
}
/**
* Test whether a line is a comment.
*
* @param line
* the line to be tested
*
* @return true if a comment
*/
boolean isComment(String line) {
// SQL92 comment prefix is "--"
// beeline also supports shell-style "#" prefix
String lineTrimmed = line.trim();
return lineTrimmed.startsWith("#") || lineTrimmed.startsWith("--");
}
String[] getCommands(File file) throws IOException {
List<String> cmds = new LinkedList<String>();
try (BufferedReader reader =
new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"))) {
StringBuilder cmd = null;
while (true) {
String scriptLine = reader.readLine();
if (scriptLine == null) {
break;
}
String trimmedLine = scriptLine.trim();
if (getOpts().getTrimScripts()) {
scriptLine = trimmedLine;
}
if (cmd != null) {
// we're continuing an existing command
cmd.append("\n");
cmd.append(scriptLine);
if (trimmedLine.endsWith(getOpts().getDelimiter())) {
// this command has terminated
cmds.add(cmd.toString());
cmd = null;
}
} else {
// we're starting a new command
if (needsContinuation(scriptLine)) {
// multi-line
cmd = new StringBuilder(scriptLine);
} else {
// single-line
cmds.add(scriptLine);
}
}
}
if (cmd != null) {
// ### REVIEW: oops, somebody left the last command
// unterminated; should we fix it for them or complain?
// For now be nice and fix it.
cmd.append(getOpts().getDelimiter());
cmds.add(cmd.toString());
}
}
return cmds.toArray(new String[0]);
}
/**
* Print the specified message to the console
*
* @param msg
* the message to print
*/
void output(String msg) {
output(msg, true);
}
void info(String msg) {
if (!(getOpts().isSilent())) {
output(msg, true, getErrorStream());
}
}
void info(ColorBuffer msg) {
if (!(getOpts().isSilent())) {
output(msg, true, getErrorStream());
}
}
/**
* Issue the specified error message
*
* @param msg
* the message to issue
* @return false always
*/
boolean error(String msg) {
output(getColorBuffer().red(msg), true, getErrorStream());
return false;
}
boolean error(Throwable t) {
handleException(t);
return false;
}
void debug(String msg) {
if (getOpts().getVerbose()) {
output(getColorBuffer().blue(msg), true, getErrorStream());
}
}
void output(ColorBuffer msg) {
output(msg, true);
}
void output(String msg, boolean newline, PrintStream out) {
output(getColorBuffer(msg), newline, out);
}
void output(ColorBuffer msg, boolean newline) {
output(msg, newline, getOutputStream());
}
void output(ColorBuffer msg, boolean newline, PrintStream out) {
if (newline) {
out.println(msg.getColor());
} else {
out.print(msg.getColor());
}
if (recordOutputFile == null) {
return;
}
// only write to the record file if we are writing a line ...
// otherwise we might get garbage from backspaces and such.
if (newline) {
recordOutputFile.addLine(msg.getMono()); // always just write mono
} else {
recordOutputFile.print(msg.getMono());
}
}
/**
* Print the specified message to the console
*
* @param msg
* the message to print
* @param newline
* if false, do not append a newline
*/
void output(String msg, boolean newline) {
output(getColorBuffer(msg), newline);
}
void autocommitStatus(Connection c) throws SQLException {
info(loc("autocommit-status", c.getAutoCommit() + ""));
}
/**
* Ensure that autocommit is on for the current connection
*
* @return true if autocommit is set
*/
boolean assertAutoCommit() {
if (!(assertConnection())) {
return false;
}
try {
if (getDatabaseConnection().getConnection().getAutoCommit()) {
return error(loc("autocommit-needs-off"));
}
} catch (Exception e) {
return error(e);
}
return true;
}
/**
* Assert that we have an active, living connection. Print
* an error message if we do not.
*
* @return true if there is a current, active connection
*/
boolean assertConnection() {
try {
if (getDatabaseConnection() == null || getDatabaseConnection().getConnection() == null) {
return error(loc("no-current-connection"));
}
if (getDatabaseConnection().getConnection().isClosed()) {
return error(loc("connection-is-closed"));
}
} catch (SQLException sqle) {
return error(loc("no-current-connection"));
}
return true;
}
/**
* Print out any warnings that exist for the current connection.
*/
void showWarnings() {
try {
if (getDatabaseConnection().getConnection() == null
|| !getOpts().getVerbose()) {
return;
}
showWarnings(getDatabaseConnection().getConnection().getWarnings());
} catch (Exception e) {
handleException(e);
}
}
/**
* Print the specified warning on the console, as well as
* any warnings that are returned from {@link SQLWarning#getNextWarning}.
*
* @param warn
* the {@link SQLWarning} to print
*/
void showWarnings(SQLWarning warn) {
if (warn == null) {
return;
}
if (seenWarnings.get(warn) == null) {
// don't re-display warnings we have already seen
seenWarnings.put(warn, new java.util.Date());
handleSQLException(warn);
}
SQLWarning next = warn.getNextWarning();
if (next != warn) {
showWarnings(next);
}
}
String getPrompt() {
if (isBeeLine) {
return getPromptForBeeline();
} else {
return getPromptForCli();
}
}
String getPromptForCli() {
String prompt;
// read prompt configuration and substitute variables.
HiveConf conf = getCommands().getHiveConf(true);
prompt = conf.getVar(HiveConf.ConfVars.CLIPROMPT);
prompt = getCommands().substituteVariables(conf, prompt);
return prompt + getFormattedDb() + "> ";
}
/**
* Retrieve the current database name string to display, based on the
* configuration value.
*
* @return String to show user for current db value
*/
String getFormattedDb() {
if (!getOpts().getShowDbInPrompt()) {
return "";
}
String currDb = getCurrentDatabase();
if (currDb == null) {
return "";
}
return " (" + currDb + ")";
}
String getPromptForBeeline() {
if (getDatabaseConnection() == null || getDatabaseConnection().getUrl() == null) {
return "beeline> ";
} else {
String printClosed = getDatabaseConnection().isClosed() ? " (closed)" : "";
return getPromptForBeeline(getDatabaseConnections().getIndex()
+ ": " + getDatabaseConnection().getUrl()) + printClosed + getFormattedDb() + "> ";
}
}
static String getPromptForBeeline(String url) {
if (url == null || url.length() == 0) {
url = "beeline";
}
if (url.indexOf(";") > -1) {
url = url.substring(0, url.indexOf(";"));
}
if (url.indexOf("?") > -1) {
url = url.substring(0, url.indexOf("?"));
}
if (url.length() > 45) {
url = url.substring(0, 45);
}
return url;
}
/**
* Try to obtain the current size of the specified {@link ResultSet} by jumping to the last row
* and getting the row number.
*
* @param rs
* the {@link ResultSet} to get the size for
* @return the size, or -1 if it could not be obtained
*/
int getSize(ResultSet rs) {
try {
if (rs.getType() == rs.TYPE_FORWARD_ONLY) {
return -1;
}
rs.last();
int total = rs.getRow();
rs.beforeFirst();
return total;
} catch (SQLException sqle) {
return -1;
}
// JDBC 1 driver error
catch (AbstractMethodError ame) {
return -1;
}
}
ResultSet getColumns(String table) throws SQLException {
if (!(assertConnection())) {
return null;
}
return getDatabaseConnection().getDatabaseMetaData().getColumns(
getDatabaseConnection().getDatabaseMetaData().getConnection().getCatalog(), null, table, "%");
}
ResultSet getTables() throws SQLException {
if (!(assertConnection())) {
return null;
}
return getDatabaseConnection().getDatabaseMetaData().getTables(
getDatabaseConnection().getDatabaseMetaData().getConnection().getCatalog(), null, "%",
new String[] {"TABLE"});
}
String[] getColumnNames(DatabaseMetaData meta) throws SQLException {
Set<String> names = new HashSet<String>();
info(loc("building-tables"));
try {
ResultSet columns = getColumns("%");
try {
int total = getSize(columns);
int index = 0;
while (columns.next()) {
// add the following strings:
// 1. column name
// 2. table name
// 3. tablename.columnname
progress(index++, total);
String name = columns.getString("TABLE_NAME");
names.add(name);
names.add(columns.getString("COLUMN_NAME"));
names.add(columns.getString("TABLE_NAME") + "."
+ columns.getString("COLUMN_NAME"));
}
progress(index, index);
} finally {
columns.close();
}
info(loc("done"));
return names.toArray(new String[0]);
} catch (Throwable t) {
handleException(t);
return new String[0];
}
}
// //////////////////
// String utilities
// //////////////////
/**
* Split the line into an array by tokenizing on space characters
*
* @param line
* the line to break up
* @return an array of individual words
*/
String[] split(String line) {
return split(line, " ");
}
String dequote(String str) {
if (str == null) {
return null;
}
while ((str.startsWith("'") && str.endsWith("'"))
|| (str.startsWith("\"") && str.endsWith("\""))) {
str = str.substring(1, str.length() - 1);
}
return str;
}
String[] split(String line, String delim) {
StringTokenizer tok = new StringTokenizer(line, delim);
String[] ret = new String[tok.countTokens()];
int index = 0;
while (tok.hasMoreTokens()) {
String t = tok.nextToken();
t = dequote(t);
ret[index++] = t;
}
return ret;
}
static Map<Object, Object> map(Object[] obs) {
Map<Object, Object> m = new HashMap<Object, Object>();
for (int i = 0; i < obs.length - 1; i += 2) {
m.put(obs[i], obs[i + 1]);
}
return Collections.unmodifiableMap(m);
}
static boolean getMoreResults(Statement stmnt) {
try {
return stmnt.getMoreResults();
} catch (Throwable t) {
return false;
}
}
static String xmlattrencode(String str) {
str = replace(str, "\"", """);
str = replace(str, "<", "<");
return str;
}
static String replace(String source, String from, String to) {
if (source == null) {
return null;
}
if (from.equals(to)) {
return source;
}
StringBuilder replaced = new StringBuilder();
int index = -1;
while ((index = source.indexOf(from)) != -1) {
replaced.append(source.substring(0, index));
replaced.append(to);
source = source.substring(index + from.length());
}
replaced.append(source);
return replaced.toString();
}
/**
* Split the line based on spaces, asserting that the
* number of words is correct.
*
* @param line
* the line to split
* @param assertLen
* the number of words to assure
* @param usage
* the message to output if there are an incorrect
* number of words.
* @return the split lines, or null if the assertion failed.
*/
String[] split(String line, int assertLen, String usage) {
String[] ret = split(line);
if (ret.length != assertLen) {
error(usage);
return null;
}
return ret;
}
/**
* Wrap the specified string by breaking on space characters.
*
* @param toWrap
* the string to wrap
* @param len
* the maximum length of any line
* @param start
* the number of spaces to pad at the
* beginning of a line
* @return the wrapped string
*/
String wrap(String toWrap, int len, int start) {
StringBuilder buff = new StringBuilder();
StringBuilder line = new StringBuilder();
char[] head = new char[start];
Arrays.fill(head, ' ');
for (StringTokenizer tok = new StringTokenizer(toWrap, " "); tok.hasMoreTokens();) {
String next = tok.nextToken();
if (line.length() + next.length() > len) {
buff.append(line).append(separator).append(head);
line.setLength(0);
}
line.append(line.length() == 0 ? "" : " ").append(next);
}
buff.append(line);
return buff.toString();
}
/**
* Output a progress indicator to the console.
*
* @param cur
* the current progress
* @param max
* the maximum progress, or -1 if unknown
*/
void progress(int cur, int max) {
StringBuilder out = new StringBuilder();
if (lastProgress != null) {
char[] back = new char[lastProgress.length()];
Arrays.fill(back, '\b');
out.append(back);
}
String progress = cur + "/"
+ (max == -1 ? "?" : "" + max) + " "
+ (max == -1 ? "(??%)"
: ("(" + (cur * 100 / (max == 0 ? 1 : max)) + "%)"));
if (cur >= max && max != -1) {
progress += " " + loc("done") + separator;
lastProgress = null;
} else {
lastProgress = progress;
}
out.append(progress);
outputStream.print(out.toString());
outputStream.flush();
}
// /////////////////////////////
// Exception handling routines
// /////////////////////////////
void handleException(Throwable e) {
while (e instanceof InvocationTargetException) {
e = ((InvocationTargetException) e).getTargetException();
}
if (e instanceof SQLException) {
handleSQLException((SQLException) e);
} else if (e instanceof EOFException) {
setExit(true); // CTRL-D
} else if (!(getOpts().getVerbose())) {
if (e.getMessage() == null) {
error(e.getClass().getName());
} else {
error(e.getMessage());
}
} else {
e.printStackTrace(getErrorStream());
}
}
void handleSQLException(SQLException e) {
if (e instanceof SQLWarning && !(getOpts().getShowWarnings())) {
return;
}
if (e.getCause() instanceof TTransportException) {
switch (((TTransportException)e.getCause()).getType()) {
case TTransportException.ALREADY_OPEN:
error(loc("hs2-connection-already-open"));
break;
case TTransportException.END_OF_FILE:
error(loc("hs2-unexpected-end-of-file"));
break;
case TTransportException.NOT_OPEN:
error(loc("hs2-could-not-open-connection"));
break;
case TTransportException.TIMED_OUT:
error(loc("hs2-connection-timed-out"));
break;
case TTransportException.UNKNOWN:
error(loc("hs2-unknown-connection-problem"));
break;
default:
error(loc("hs2-unexpected-error"));
}
}
error(loc(e instanceof SQLWarning ? "Warning" : "Error",
new Object[] {
e.getMessage() == null ? "" : e.getMessage().trim(),
e.getSQLState() == null ? "" : e.getSQLState().trim(),
new Integer(e.getErrorCode())}));
if (getOpts().getVerbose()) {
e.printStackTrace(getErrorStream());
}
if (!getOpts().getShowNestedErrs()) {
return;
}
for (SQLException nested = e.getNextException(); nested != null && nested != e; nested = nested
.getNextException()) {
handleSQLException(nested);
}
}
boolean scanForDriver(String url) {
try {
// already registered
if (findRegisteredDriver(url) != null) {
return true;
}
// first try known drivers...
scanDrivers(true);
if (findRegisteredDriver(url) != null) {
return true;
}
// now really scan...
scanDrivers(false);
if (findRegisteredDriver(url) != null) {
return true;
}
// find whether exists a local driver to accept the url
if (findLocalDriver(url) != null) {
return true;
}
return false;
} catch (Exception e) {
debug(e.toString());
return false;
}
}
private Driver findRegisteredDriver(String url) {
for (Enumeration drivers = DriverManager.getDrivers(); drivers != null
&& drivers.hasMoreElements();) {
Driver driver = (Driver) drivers.nextElement();
try {
if (driver.acceptsURL(url)) {
return driver;
}
} catch (Exception e) {
}
}
return null;
}
public Driver findLocalDriver(String url) throws Exception {
if(drivers == null){
return null;
}
for (Driver d : drivers) {
try {
String clazzName = d.getClass().getName();
Driver driver = (Driver) Class.forName(clazzName, true,
Thread.currentThread().getContextClassLoader()).newInstance();
if (driver.acceptsURL(url) && isSupportedLocalDriver(driver)) {
return driver;
}
} catch (SQLException e) {
error(e);
throw new Exception(e);
}
}
return null;
}
public boolean isSupportedLocalDriver(Driver driver) {
String driverName = driver.getClass().getName();
for (String name : supportedLocalDriver) {
if (name.equals(driverName)) {
return true;
}
}
return false;
}
public void addLocalDriverClazz(String driverClazz) {
supportedLocalDriver.add(driverClazz);
}
Driver[] scanDrivers(String line) throws IOException {
return scanDrivers(false);
}
Driver[] scanDrivers(boolean knownOnly) throws IOException {
long start = System.currentTimeMillis();
Set<String> classNames = new HashSet<String>();
if (!knownOnly) {
classNames.addAll(Arrays.asList(
ClassNameCompleter.getClassNames()));
}
classNames.addAll(KNOWN_DRIVERS);
Set driverClasses = new HashSet();
for (Iterator<String> i = classNames.iterator(); i.hasNext();) {
String className = i.next().toString();
if (className.toLowerCase().indexOf("driver") == -1) {
continue;
}
try {
Class c = Class.forName(className, false,
Thread.currentThread().getContextClassLoader());
if (!Driver.class.isAssignableFrom(c)) {
continue;
}
if (Modifier.isAbstract(c.getModifiers())) {
continue;
}
// now instantiate and initialize it
driverClasses.add(c.newInstance());
} catch (Throwable t) {
}
}
info("scan complete in "
+ (System.currentTimeMillis() - start) + "ms");
return (Driver[]) driverClasses.toArray(new Driver[0]);
}
private Driver[] scanDriversOLD(String line) {
long start = System.currentTimeMillis();
Set<String> paths = new HashSet<String>();
Set driverClasses = new HashSet();
for (StringTokenizer tok = new StringTokenizer(
System.getProperty("java.ext.dirs"),
System.getProperty("path.separator")); tok.hasMoreTokens();) {
File[] files = new File(tok.nextToken()).listFiles();
for (int i = 0; files != null && i < files.length; i++) {
paths.add(files[i].getAbsolutePath());
}
}
for (StringTokenizer tok = new StringTokenizer(
System.getProperty("java.class.path"),
System.getProperty("path.separator")); tok.hasMoreTokens();) {
paths.add(new File(tok.nextToken()).getAbsolutePath());
}
for (Iterator<String> i = paths.iterator(); i.hasNext();) {
File f = new File(i.next());
output(getColorBuffer().pad(loc("scanning", f.getAbsolutePath()), 60),
false);
try {
ZipFile zf = new ZipFile(f);
int total = zf.size();
int index = 0;
for (Enumeration zfEnum = zf.entries(); zfEnum.hasMoreElements();) {
ZipEntry entry = (ZipEntry) zfEnum.nextElement();
String name = entry.getName();
progress(index++, total);
if (name.endsWith(".class")) {
name = name.replace('/', '.');
name = name.substring(0, name.length() - 6);
try {
// check for the string "driver" in the class
// to see if we should load it. Not perfect, but
// it is far too slow otherwise.
if (name.toLowerCase().indexOf("driver") != -1) {
Class c = Class.forName(name, false,
getClass().getClassLoader());
if (Driver.class.isAssignableFrom(c)
&& !(Modifier.isAbstract(
c.getModifiers()))) {
try {
// load and initialize
Class.forName(name);
} catch (Exception e) {
}
driverClasses.add(c.newInstance());
}
}
} catch (Throwable t) {
}
}
}
progress(total, total);
} catch (Exception e) {
}
}
info("scan complete in "
+ (System.currentTimeMillis() - start) + "ms");
return (Driver[]) driverClasses.toArray(new Driver[0]);
}
// /////////////////////////////////////
// ResultSet output formatting classes
// /////////////////////////////////////
int print(ResultSet rs) throws SQLException {
String format = getOpts().getOutputFormat();
OutputFormat f = (OutputFormat) formats.get(format);
if (f == null) {
error(loc("unknown-format", new Object[] {
format, formats.keySet()}));
f = new TableOutputFormat(this);
}
Rows rows;
if (f instanceof TableOutputFormat) {
if (getOpts().getIncremental()) {
rows = new IncrementalRowsWithNormalization(this, rs);
} else {
rows = new BufferedRows(this, rs);
}
} else {
rows = new IncrementalRows(this, rs);
}
return f.print(rows);
}
Statement createStatement() throws SQLException {
Statement stmnt = getDatabaseConnection().getConnection().createStatement();
if (getOpts().timeout > -1) {
stmnt.setQueryTimeout(getOpts().timeout);
}
if (signalHandler != null) {
signalHandler.setStatement(stmnt);
}
return stmnt;
}
void runBatch(List<String> statements) {
try {
Statement stmnt = createStatement();
try {
for (Iterator<String> i = statements.iterator(); i.hasNext();) {
stmnt.addBatch(i.next().toString());
}
int[] counts = stmnt.executeBatch();
output(getColorBuffer().pad(getColorBuffer().bold("COUNT"), 8)
.append(getColorBuffer().bold("STATEMENT")));
for (int i = 0; counts != null && i < counts.length; i++) {
output(getColorBuffer().pad(counts[i] + "", 8)
.append(statements.get(i).toString()));
}
} finally {
try {
stmnt.close();
} catch (Exception e) {
}
}
} catch (Exception e) {
handleException(e);
}
}
public int runCommands(String[] cmds) {
return runCommands(Arrays.asList(cmds));
}
public int runCommands(List<String> cmds) {
int successCount = 0;
try {
// TODO: Make script output prefixing configurable. Had to disable this since
// it results in lots of test diffs.
for (String cmd : cmds) {
info(getColorBuffer().pad(SCRIPT_OUTPUT_PREFIX, SCRIPT_OUTPUT_PAD_SIZE).append(cmd));
// if we do not force script execution, abort
// when a failure occurs.
if (dispatch(cmd) || getOpts().getForce()) {
++successCount;
} else {
error(loc("abort-on-error", cmd));
return successCount;
}
}
} catch (Exception e) {
handleException(e);
}
return successCount;
}
// ////////////////////////
// Command methods follow
// ////////////////////////
void setCompletions() throws SQLException, IOException {
if (getDatabaseConnection() != null) {
getDatabaseConnection().setCompletions(getOpts().getFastConnect());
}
}
public BeeLineOpts getOpts() {
return opts;
}
DatabaseConnections getDatabaseConnections() {
return connections;
}
Runnable getShutdownHook() {
return shutdownHook;
}
Completer getCommandCompletor() {
return beeLineCommandCompleter;
}
public boolean isExit() {
return exit;
}
public void setExit(boolean exit) {
this.exit = exit;
}
Collection<Driver> getDrivers() {
return drivers;
}
void setDrivers(Collection<Driver> drivers) {
this.drivers = drivers;
}
public static String getSeparator() {
return separator;
}
Commands getCommands() {
return commands;
}
OutputFile getScriptOutputFile() {
return scriptOutputFile;
}
void setScriptOutputFile(OutputFile script) {
this.scriptOutputFile = script;
}
OutputFile getRecordOutputFile() {
return recordOutputFile;
}
void setRecordOutputFile(OutputFile record) {
this.recordOutputFile = record;
}
public void setOutputStream(PrintStream outputStream) {
this.outputStream = new PrintStream(outputStream, true);
}
PrintStream getOutputStream() {
return outputStream;
}
public void setErrorStream(PrintStream errorStream) {
this.errorStream = new PrintStream(errorStream, true);
}
PrintStream getErrorStream() {
return errorStream;
}
InputStream getInputStream() {
return inputStream;
}
ConsoleReader getConsoleReader() {
return consoleReader;
}
void setConsoleReader(ConsoleReader reader) {
this.consoleReader = reader;
}
List<String> getBatch() {
return batch;
}
void setBatch(List<String> batch) {
this.batch = batch;
}
protected Reflector getReflector() {
return reflector;
}
public boolean isBeeLine() {
return isBeeLine;
}
public void setBeeLine(boolean isBeeLine) {
this.isBeeLine = isBeeLine;
}
public String getCurrentDatabase() {
if (currentDatabase == null) {
currentDatabase = DEFAULT_DATABASE_NAME;
}
return currentDatabase;
}
public void setCurrentDatabase(String currentDatabase) {
this.currentDatabase = currentDatabase;
}
/**
* Setting the BeeLine into test mode.
* Print only the errors, the operation log and the query results.
* Should be used only by tests.
*
* @param isTestMode
*/
void setIsTestMode(boolean isTestMode) {
this.isTestMode = isTestMode;
}
boolean isTestMode() {
return isTestMode;
}
}