#!/usr/bin/env compileAndGo
# -*- coding: utf-8 mode: java -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
compiler=javac
mainClass=sqlcsv
compileAndGo
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.Charset;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.logging.ConsoleHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.prefs.Preferences;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class sqlcsv {
static final String CLASS_NAME = sqlcsv.class.getName();
static final Logger log = Logger.getLogger(CLASS_NAME);
static {
ConsoleHandler handler = new ConsoleHandler();
handler.setLevel(Level.ALL);
log.addHandler(handler);
log.setUseParentHandlers(false);
}
static final Charset UTF8;
static {
UTF8 = Charset.forName("UTF-8");
}
static final String USER_CONFDIR = System.getProperty("user.home") + "/." + CLASS_NAME;
static final String SYSTEM_CONFDIR = "/etc/" + CLASS_NAME;
static final String DEFAULT_CONFIG = CLASS_NAME + ".properties";
static final String USER_CONFIG = USER_CONFDIR + "/" + DEFAULT_CONFIG,
SYSTEM_CONFIG = SYSTEM_CONFDIR + "/" + DEFAULT_CONFIG;
// ------------------------------------------------------------------------
public static final File getCanonical(File file) {
try {
return file.getCanonicalFile();
} catch (IOException e) {
return file.getAbsoluteFile();
}
}
private static final File[] ROOTS = File.listRoots();
public static final boolean isRoot(File file) {
if (file == null) return false;
for (File root : ROOTS) {
if (root.equals(file)) return true;
}
return false;
}
// ------------------------------------------------------------------------
public static class ResultSetHelper {
public static final int CLOBBUFFERSIZE = 2048;
// note: we want to maintain compatibility with Java 5 VM's
// These types don't exist in Java 5
protected static final int NVARCHAR = -9, NCHAR = -15, LONGNVARCHAR = -16, NCLOB = 2011;
public static final String[] getColumnNames(ResultSet rs) throws SQLException {
List<String> names = new ArrayList<String>();
ResultSetMetaData metadata = rs.getMetaData();
for (int i = 0; i < metadata.getColumnCount(); i++) {
names.add(metadata.getColumnName(i + 1));
}
String[] nameArray = new String[names.size()];
return names.toArray(nameArray);
}
public String[] getColumnValues(ResultSet rs) throws SQLException, IOException {
List<String> values = new ArrayList<String>();
ResultSetMetaData metadata = rs.getMetaData();
for (int i = 0; i < metadata.getColumnCount(); i++) {
values.add(getColumnValue(rs, metadata.getColumnType(i + 1), i + 1));
}
String[] valueArray = new String[values.size()];
return values.toArray(valueArray);
}
private String handleObject(Object obj) {
return obj == null? "": String.valueOf(obj);
}
private String handleBigDecimal(BigDecimal decimal) {
return decimal == null? "": decimal.toString();
}
private String handleLong(ResultSet rs, int columnIndex) throws SQLException {
long lv = rs.getLong(columnIndex);
return rs.wasNull()? "": Long.toString(lv);
}
private String handleInteger(ResultSet rs, int columnIndex) throws SQLException {
int i = rs.getInt(columnIndex);
return rs.wasNull()? "": Integer.toString(i);
}
private String handleDate(ResultSet rs, int columnIndex) throws SQLException {
java.sql.Date date = rs.getDate(columnIndex);
String value = null;
if (date != null) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
value = dateFormat.format(date);
}
return value;
}
private String handleTime(Time time) {
return time == null? null: time.toString();
}
private String handleTimestamp(Timestamp timestamp) {
SimpleDateFormat timeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return timestamp == null? null: timeFormat.format(timestamp);
}
private String getColumnValue(ResultSet rs, int colType, int colIndex) throws SQLException,
IOException {
String value = "";
switch (colType) {
case Types.BIT:
case Types.JAVA_OBJECT:
value = handleObject(rs.getObject(colIndex));
break;
case Types.BOOLEAN:
boolean b = rs.getBoolean(colIndex);
value = Boolean.valueOf(b).toString();
break;
case NCLOB: // todo : use rs.getNClob
case Types.CLOB:
Clob c = rs.getClob(colIndex);
if (c != null) value = read(c);
break;
case Types.BIGINT:
value = handleLong(rs, colIndex);
break;
case Types.DECIMAL:
case Types.DOUBLE:
case Types.FLOAT:
case Types.REAL:
case Types.NUMERIC:
value = handleBigDecimal(rs.getBigDecimal(colIndex));
break;
case Types.INTEGER:
case Types.TINYINT:
case Types.SMALLINT:
value = handleInteger(rs, colIndex);
break;
case Types.DATE:
value = handleDate(rs, colIndex);
break;
case Types.TIME:
value = handleTime(rs.getTime(colIndex));
break;
case Types.TIMESTAMP:
value = handleTimestamp(rs.getTimestamp(colIndex));
break;
case NVARCHAR: // todo : use rs.getNString
case NCHAR: // todo : use rs.getNString
case LONGNVARCHAR: // todo : use rs.getNString
case Types.LONGVARCHAR:
case Types.VARCHAR:
case Types.CHAR:
value = rs.getString(colIndex);
break;
default:
value = "";
}
if (value == null) value = "";
return value;
}
private static String read(Clob c) throws SQLException, IOException {
StringBuilder sb = new StringBuilder((int)c.length());
Reader r = c.getCharacterStream();
char[] cbuf = new char[CLOBBUFFERSIZE];
int n;
while ((n = r.read(cbuf, 0, cbuf.length)) != -1) {
sb.append(cbuf, 0, n);
}
return sb.toString();
}
}
public static class CSVWriter implements Closeable {
public static final int INITIAL_STRING_SIZE = 128;
public static final char DEFAULT_ESCAPE_CHARACTER = '"';
public static final char DEFAULT_SEPARATOR = ',';
public static final char DEFAULT_QUOTE_CHARACTER = '"';
public static final char NO_QUOTE_CHARACTER = '\u0000';
public static final char NO_ESCAPE_CHARACTER = '\u0000';
public static final String DEFAULT_LINE_END = "\n";
public static final StringBuilder quoteCsv(String s, char escapechar, char quotechar,
StringBuilder sb) {
if (sb == null) sb = new StringBuilder(INITIAL_STRING_SIZE);
for (int j = 0; j < s.length(); j++) {
char nextChar = s.charAt(j);
if (escapechar != NO_ESCAPE_CHARACTER && nextChar == quotechar) {
sb.append(escapechar).append(nextChar);
} else if (escapechar != NO_ESCAPE_CHARACTER && nextChar == escapechar) {
sb.append(escapechar).append(nextChar);
} else {
sb.append(nextChar);
}
}
return sb;
}
public static final String quoteCsv(String s) {
StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
sb.append(DEFAULT_QUOTE_CHARACTER);
quoteCsv(s, DEFAULT_ESCAPE_CHARACTER, DEFAULT_QUOTE_CHARACTER, sb);
sb.append(DEFAULT_QUOTE_CHARACTER);
return sb.toString();
}
public Writer out;
protected char separator;
protected char quotechar;
protected char escapechar;
protected String lineEnd;
private ResultSetHelper resultSetHelper = new ResultSetHelper();
public CSVWriter(Writer writer) {
this(writer, DEFAULT_SEPARATOR);
}
public CSVWriter(Writer writer, char separator) {
this(writer, separator, DEFAULT_QUOTE_CHARACTER);
}
public CSVWriter(Writer writer, char separator, char quotechar) {
this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER);
}
public CSVWriter(Writer writer, char separator, char quotechar, char escapechar) {
this(writer, separator, quotechar, escapechar, DEFAULT_LINE_END);
}
public CSVWriter(Writer writer, char separator, char quotechar, String lineEnd) {
this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER, lineEnd);
}
public CSVWriter(Writer writer, char separator, char quotechar, char escapechar,
String lineEnd) {
this.out = writer;
this.separator = separator;
this.quotechar = quotechar;
this.escapechar = escapechar;
this.lineEnd = lineEnd;
}
public void writeAll(List<String[]> allLines) throws IOException {
for (String[] line : allLines) {
writeNext(line);
}
}
protected void writeColumnNames(ResultSet rs) throws SQLException, IOException {
writeNext(ResultSetHelper.getColumnNames(rs));
}
public void writeAll(java.sql.ResultSet rs, boolean includeColumnNames)
throws SQLException, IOException {
if (includeColumnNames) writeColumnNames(rs);
while (rs.next()) {
writeNext(resultSetHelper.getColumnValues(rs));
}
}
public void writeNext(String[] nextLine) throws IOException {
if (nextLine == null) return;
StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
for (int i = 0; i < nextLine.length; i++) {
if (i != 0) sb.append(separator);
String nextElement = nextLine[i];
if (nextElement == null) continue;
if (quotechar != NO_QUOTE_CHARACTER) sb.append(quotechar);
sb.append(stringContainsSpecialCharacters(nextElement)? processLine(nextElement)
: nextElement);
if (quotechar != NO_QUOTE_CHARACTER) sb.append(quotechar);
}
sb.append(lineEnd);
out.write(sb.toString());
}
protected boolean stringContainsSpecialCharacters(String line) {
return line.indexOf(quotechar) != -1 || line.indexOf(escapechar) != -1;
}
protected StringBuilder processLine(String nextElement) {
StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
for (int j = 0; j < nextElement.length(); j++) {
char nextChar = nextElement.charAt(j);
if (escapechar != NO_ESCAPE_CHARACTER && nextChar == quotechar) {
sb.append(escapechar).append(nextChar);
} else if (escapechar != NO_ESCAPE_CHARACTER && nextChar == escapechar) {
sb.append(escapechar).append(nextChar);
} else {
sb.append(nextChar);
}
}
return sb;
}
public void flush() throws IOException {
out.flush();
}
public void close() throws IOException {
flush();
out.close();
}
public void setResultSetHelper(ResultSetHelper resultSetHelper) {
this.resultSetHelper = resultSetHelper;
}
}
public static class SqlResultSetHelper extends ResultSetHelper {
@Override
public String[] getColumnValues(ResultSet rs) throws SQLException, IOException {
List<String> values = new ArrayList<String>();
ResultSetMetaData metadata = rs.getMetaData();
int columnCount = metadata.getColumnCount();
for (int i = 0; i < columnCount; i++) {
values.add(getColumnValue(rs, metadata.getColumnType(i + 1), i + 1));
}
String[] valueArray = new String[values.size()];
return values.toArray(valueArray);
}
private String getColumnValue(ResultSet rs, int colType, int colIndex) throws SQLException,
IOException {
String value = null;
switch (colType) {
case Types.BIT:
case Types.JAVA_OBJECT:
Object ov = rs.getObject(colIndex);
if (!rs.wasNull() && ov != null) value = String.valueOf(ov);
break;
case Types.BOOLEAN:
Boolean bv = rs.getBoolean(colIndex);
if (!rs.wasNull() && bv != null) value = Boolean.toString(bv);
break;
case NCLOB: // todo : use rs.getNClob
case Types.CLOB:
Clob cv = rs.getClob(colIndex);
if (!rs.wasNull() && cv != null) value = read(cv);
break;
case Types.BIGINT:
Long lv = rs.getLong(colIndex);
if (!rs.wasNull() && lv != null) value = Long.toString(lv);
break;
case Types.DECIMAL:
case Types.DOUBLE:
case Types.FLOAT:
case Types.REAL:
case Types.NUMERIC:
BigDecimal bdv = rs.getBigDecimal(colIndex);
if (!rs.wasNull() && bdv != null) value = bdv.toString();
break;
case Types.INTEGER:
case Types.TINYINT:
case Types.SMALLINT:
Integer iv = rs.getInt(colIndex);
if (!rs.wasNull() && iv != null) value = Integer.toString(iv);
break;
case Types.DATE:
Date dv = rs.getDate(colIndex);
if (!rs.wasNull() && dv != null) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
value = dateFormat.format(dv);
}
break;
case Types.TIME:
Time tv = rs.getTime(colIndex);
if (!rs.wasNull() && tv != null) value = tv.toString();
break;
case Types.TIMESTAMP:
Timestamp tsv = rs.getTimestamp(colIndex);
if (!rs.wasNull() && tsv != null) {
SimpleDateFormat timestampFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
value = timestampFormat.format(tsv);
}
break;
case NVARCHAR: // todo : use rs.getNString
case NCHAR: // todo : use rs.getNString
case LONGNVARCHAR: // todo : use rs.getNString
case Types.LONGVARCHAR:
case Types.VARCHAR:
case Types.CHAR:
value = rs.getString(colIndex);
break;
default:
value = "<unknown>";
}
return value;
}
private static final String read(Clob c) throws SQLException, IOException {
StringBuilder sb = new StringBuilder((int)c.length());
Reader r = c.getCharacterStream();
char[] cbuf = new char[CLOBBUFFERSIZE];
int n;
while ((n = r.read(cbuf, 0, cbuf.length)) != -1) {
sb.append(cbuf, 0, n);
}
return sb.toString();
}
}
public static class SqlCSVWriter extends CSVWriter {
public SqlCSVWriter(Writer writer) {
this(writer, DEFAULT_SEPARATOR);
}
public SqlCSVWriter(Writer writer, char separator) {
this(writer, separator, DEFAULT_QUOTE_CHARACTER);
}
public SqlCSVWriter(Writer writer, char separator, char quotechar) {
this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER);
}
public SqlCSVWriter(Writer writer, char separator, char quotechar, char escapechar) {
this(writer, separator, quotechar, escapechar, DEFAULT_LINE_END);
}
public SqlCSVWriter(Writer writer, char separator, char quotechar, String lineEnd) {
this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER, lineEnd);
}
public SqlCSVWriter(Writer writer, char separator, char quotechar, char escapechar,
String lineEnd) {
super(writer, separator, quotechar, escapechar, lineEnd);
setResultSetHelper(new SqlResultSetHelper());
}
@Override
public void writeNext(String[] nextLine) throws IOException {
if (nextLine == null) return;
StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
for (int i = 0; i < nextLine.length; i++) {
if (i != 0) sb.append(separator);
String nextElement = nextLine[i];
if (nextElement != null) {
if (quotechar != NO_QUOTE_CHARACTER) sb.append(quotechar);
if (stringContainsSpecialCharacters(nextElement)) {
sb.append(processLine(nextElement));
} else {
sb.append(nextElement);
}
if (quotechar != NO_QUOTE_CHARACTER) sb.append(quotechar);
} else {
sb.append("NULL");
}
}
sb.append(lineEnd);
out.write(sb.toString());
}
}
// ------------------------------------------------------------------------
static class DelegateDriver implements Driver {
private Driver driver;
DelegateDriver(Driver driver) {
this.driver = driver;
}
public boolean acceptsURL(String u) throws SQLException {
return driver.acceptsURL(u);
}
public Connection connect(String u, Properties p) throws SQLException {
return driver.connect(u, p);
}
public int getMajorVersion() {
return driver.getMajorVersion();
}
public int getMinorVersion() {
return driver.getMinorVersion();
}
public DriverPropertyInfo[] getPropertyInfo(String u, Properties p) throws SQLException {
return driver.getPropertyInfo(u, p);
}
public boolean jdbcCompliant() {
return driver.jdbcCompliant();
}
public Logger getParentLogger() {
try {
return (Logger)driver.getClass().getMethod("getParentLogger").invoke(driver);
} catch (Exception e) {
Throwable t = e;
if (t instanceof InvocationTargetException) t = t.getCause();
throw new RuntimeException(t);
}
}
}
static final String[] SUPPORTED_DRIVERS = new String[] {
"org.mariadb.jdbc.Driver",
"com.mysql.jdbc.Driver",
"oracle.jdbc.OracleDriver",
"org.hsqldb.jdbcDriver",
"org.postgresql.Driver"};
static final boolean isOracle(String jdbcUrl) {
return jdbcUrl.startsWith("jdbc:oracle:");
}
static final class Exit extends RuntimeException {
private static final long serialVersionUID = 1L;
public Exit(int exitcode, String errorMsg) {
this.exitcode = exitcode;
this.errorMsg = errorMsg;
}
public Exit(String errorMsg) {
this(1, errorMsg);
}
public Exit(int exitcode) {
this(exitcode, null);
}
public Exit() {
this(0, null);
}
private int exitcode;
public int getExitcode() {
return exitcode;
}
private String errorMsg;
public String getErrorMsg() {
return errorMsg;
}
public void exit(String prefix) {
StringBuilder sb = new StringBuilder();
if (prefix != null) sb.append(prefix);
if (errorMsg != null) sb.append(errorMsg);
if (sb.length() > 0) {
System.err.println(sb.toString());
System.err.flush();
}
System.exit(exitcode);
}
public void exit() {
if (exitcode == 0) exit(null);
else exit("ERROR: ");
}
}
static final String getArg(String[] args, int index, String errorMsg) {
if (args.length > index) return args[index];
if (errorMsg == null) return null;
throw new Exit(1, errorMsg);
}
static final String getExceptionAndMessage(String msg, Throwable t) {
if (t == null) return msg;
StringBuilder sb = new StringBuilder();
if (msg != null) sb.append(msg);
sb.append(t.getClass().getName());
sb.append(": ");
sb.append(t.getMessage());
return sb.toString();
}
static final String getSummary(String msg, Throwable t) {
if (t == null) return msg;
StringWriter sw = new StringWriter();
if (msg != null) sw.append(msg);
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
pw.flush();
return sw.toString();
}
static final void logIgnoredError(Throwable t) {
log.info(getExceptionAndMessage("Erreur ignorée: ", t));
log.finer(getSummary(null, t));
}
static final void println(String msg) {
System.out.println(msg);
System.out.flush();
}
static final void die(String msg, Throwable t) {
if (msg != null) System.err.println(msg);
if (t != null) t.printStackTrace(System.err);
System.err.flush();
System.exit(1);
}
static final boolean strIsempty(String str) {
return str == null || str.length() == 0;
}
static final boolean strEquals(String s1, String s2, boolean ignoreCase) {
if (ignoreCase) return s1 == s2 || (s1 != null && s1.equalsIgnoreCase(s2));
else return s1 == s2 || (s1 != null && s1.equals(s2));
}
static final boolean strEquals(String[] a1, String[] a2, boolean ignoreCase) {
if (a1 == null) return a2 == null;
else if (a2 == null) return false;
if (a1.length != a2.length) return false;
for (int i = 0; i < a1.length; i++) {
if (!strEquals(a1[i], a2[i], ignoreCase)) return false;
}
return true;
}
static final boolean strEquals(String s1, String s2) {
return strEquals(s1, s2, false);
}
static final String strNotnull(String str) {
return str == null? "": str;
}
static final String strSubstr(String str, int start, int end) {
if (str == null) return null;
int l = str.length();
if (l > 0) {
while (start < 0)
start += l;
while (end < 0)
end += l;
} else {
if (start < 0) start = 0;
if (end < 0) end = 0;
}
if (start >= l || start >= end) return "";
if (end >= l + 1) end = l;
return str.substring(start, end);
}
static final String strSubstr(String str, int start) {
if (str == null) return null;
return strSubstr(str, start, str.length());
}
static void close(InputStream is) {
try {
if (is != null) is.close();
} catch (IOException e) {
}
}
// static void close(OutputStream os) {
// try {
// if (os != null) os.close();
// } catch (IOException e) {
// }
// }
static void close(Reader r) {
try {
if (r != null) r.close();
} catch (IOException e) {
}
}
static void close(Writer w) {
try {
if (w != null) w.close();
} catch (IOException e) {
}
}
static void close(CSVWriter csv, String output) {
try {
if (csv != null && output != null) csv.close();
} catch (IOException e) {
}
}
static void close(Connection conn) {
try {
if (conn != null) conn.close();
} catch (SQLException e) {
}
}
static void close(PreparedStatement ps) {
try {
if (ps != null) ps.close();
} catch (SQLException e) {
}
}
static void close(ResultSet rs) {
try {
if (rs != null) rs.close();
} catch (SQLException e) {
}
}
static void rollback(Connection conn) {
try {
if (!conn.getAutoCommit()) conn.rollback();
} catch (SQLException e) {
}
}
static final Pattern RE_COMMENT = Pattern.compile("--|#|//");
static String nextLine(BufferedReader inf) throws IOException {
while (true) {
String line = inf.readLine();
if (line == null) return null;
line = line.trim();
if (!line.equals("") && !RE_COMMENT.matcher(line).lookingAt()) return line;
}
}
// requêtes à ignorer, en l'occurence lignes spéciques à sqlplus pour une connexion à Oracle
static final Pattern RE_ORACLE_IGNORE_STMT = Pattern.compile("(?i)set\\b");
static final Pattern RE_CREATE_STMT = Pattern
.compile("(?i)create\\s+(?:or\\s+replace)?(?:procedure|trigger|function|package)");
static final Pattern RE_SEPARATOR = Pattern.compile(";$");
static String nextStatement(BufferedReader inf, String jdbcUrl) throws IOException {
boolean ignore;
String line;
do {
ignore = false;
line = nextLine(inf);
if (line == null) return null;
if (isOracle(jdbcUrl) && RE_ORACLE_IGNORE_STMT.matcher(line).lookingAt()) {
ignore = true;
}
} while (ignore);
StringBuilder sb = new StringBuilder();
boolean first = true;
if (RE_CREATE_STMT.matcher(line).lookingAt()) {
// Ici, lire jusqu'à une ligne contenant simplement '/'
do {
if (line.equals("/")) break;
if (first) first = false;
else sb.append("\n");
sb.append(line);
line = nextLine(inf);
} while (line != null);
} else {
// Ici, lire jusqu'à une ligne se *terminant* par ';'
do {
if (first) first = false;
else sb.append(" ");
boolean lastLine = line.endsWith(";");
sb.append(RE_SEPARATOR.matcher(line).replaceFirst(""));
if (lastLine) break;
line = nextLine(inf);
} while (line != null);
}
return sb.toString();
}
static PreparedStatement getPreparedStatement(String query, Object[] args, Connection conn)
throws SQLException {
PreparedStatement ps = conn.prepareStatement(query);
if (args != null) {
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
if (arg instanceof java.util.Date && !(arg instanceof Date)
&& !(arg instanceof Time) && !(arg instanceof Timestamp)) {
// corriger les instances de java.util.Date en java.sql.Timestamp
if (arg == null || arg instanceof Timestamp) arg = (Timestamp)arg;
else arg = new Timestamp(((java.util.Date)arg).getTime());
}
ps.setObject(i + 1, arg);
}
}
return ps;
}
SqlCSVWriter getCSVWriter(String output, boolean append) throws FileNotFoundException {
Writer outf;
if (output != null) {
outf = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(output, append),
UTF8));
} else {
outf = new OutputStreamWriter(System.out);
}
return new SqlCSVWriter(outf);
}
static class Options {
public Options(boolean ignoreIoError, boolean ignoreAnyError, boolean noHeaders,
boolean append, boolean sameOutput, boolean forceHeaders, boolean outputUc) {
this.ignoreIoErrors = ignoreIoError;
this.ignoreAnyErrors = ignoreIoError;
this.noHeaders = noHeaders;
this.append = append;
this.sameOutput = sameOutput;
this.forceHeaders = forceHeaders;
this.outputUc = outputUc;
}
public Options() {
this(false, false, false, false, false, false, false);
}
public boolean ignoreIoErrors;
public boolean ignoreAnyErrors;
public boolean noHeaders;
public boolean append;
public boolean sameOutput;
public boolean forceHeaders;
public boolean outputUc;
}
static final String[] UC_FIELDS = new String[] {"updateCount"};
static final Pattern RE_NAME_EXT = Pattern.compile("(.+?)(?:(\\d+))?(?:(\\.[^.]+))?");
void executeQueries(Connection conn, Object[] args, ArrayList<BufferedReader> infs,
ArrayList<String> outputs, Options o, String jdbcUrl) throws IOException, SQLException {
int stcount = 0;
Iterator<String> outputIt = outputs.iterator();
String output = null, prevOutput = null, actualOutput = null;
String[] fields = null, prevFields = null;
boolean firstWrite = true;
for (BufferedReader inf : infs) {
try {
while (true) {
String statement = nextStatement(inf, jdbcUrl);
if (statement == null) break;
stcount++;
log.finer(statement);
try {
PreparedStatement ps = getPreparedStatement(statement, args, conn);
try {
boolean rt = ps.execute();
while (true) {
int uc = 0;
boolean writeOutput;
if (rt) {
writeOutput = true;
} else {
uc = ps.getUpdateCount();
if (uc == -1) break;
writeOutput = o.outputUc;
}
SqlCSVWriter csv = null;
prevOutput = output;
prevFields = fields;
boolean sameOutput = false, append = false;
if (writeOutput) {
if (outputIt.hasNext()) output = outputIt.next();
if (!strEquals(output, prevOutput)) {
sameOutput = false;
firstWrite = true;
actualOutput = output;
} else if (o.sameOutput) {
sameOutput = true;
append = true;
} else if (output != null) {
String dir, basename, sindex, ext;
int index = 0;
sameOutput = true;
File file = new File(actualOutput);
dir = file.getParent();
Matcher m = RE_NAME_EXT.matcher(file.getName());
if (m.matches()) {
basename = m.group(1);
sindex = m.group(2);
ext = m.group(3);
if (sindex != null) index = Integer.valueOf(sindex);
index++;
StringBuilder sb = new StringBuilder();
if (dir != null) {
sb.append(dir);
sb.append("/");
}
sb.append(basename);
sb.append(index);
if (ext != null) sb.append(ext);
actualOutput = sb.toString();
firstWrite = true;
sameOutput = false;
}
}
}
log.fine("stmt#" + stcount);
ResultSet rs = null;
if (rt) {
rs = ps.getResultSet();
fields = ResultSetHelper.getColumnNames(rs);
} else if (o.outputUc) {
fields = UC_FIELDS;
}
boolean sameFields = strEquals(fields, prevFields, true);
boolean writeHeaders = !o.noHeaders
&& !(sameFields && sameOutput && !o.forceHeaders);
if (writeOutput) {
csv = getCSVWriter(actualOutput, append | o.append);
if (sameOutput && !firstWrite
&& (!sameFields || o.forceHeaders)) {
csv.out.write("\n");
}
try {
if (rt) {
csv.writeAll(rs, writeHeaders);
} else {
if (writeHeaders) csv.writeNext(UC_FIELDS);
csv.writeNext(new String[] {String.valueOf(uc)});
}
csv.flush();
} finally {
close(csv, actualOutput);
close(rs);
}
}
firstWrite = false;
rt = ps.getMoreResults();
}
} finally {
close(ps);
}
} catch (SQLException e) {
if (o.ignoreAnyErrors) {
logIgnoredError(e);
} else {
rollback(conn);
throw e;
}
}
}
} catch (IOException e) {
if (o.ignoreIoErrors) {
logIgnoredError(e);
} else {
rollback(conn);
throw e;
}
}
}
if (!conn.getAutoCommit()) conn.commit();
}
static final Pattern RE_URL_PROP = Pattern.compile("(.+)\\.url$");
void run(String[] args) throws Exception {
if (args.length == 1 && strEquals(args[0], "--help")) {
println("USAGE:" //
+ "\n "
+ CLASS_NAME
+ " [query]"
+ "\n\nquery est la requête SQL à exécuter. Si query n'est pas spécifiée ou si elle"
+ "\n vaut '-', la requête SQL est lue sur l'entrée standard, ou depuis un"
+ "\n fichier si l'option -f est spécifiée."
+ "\n\nDEMARRAGE"
+ "\n\nAu démarrage, les répertoires de configuration (utilisateur ~/.sqlcsv et système"
+ "\n/etc/sqlcsv) sont analysés. Les fichiers *.jar situés dans ces répertoires sont"
+ "\najoutés au CLASSPATH. La présence de certains fichiers est testée pour activer"
+ "\néventuellement les logs détaillés."
+ "\n\nOPTIONS"
+ "\n -J<JARDIR>"
+ "\n +J<JARDIR>"
+ "\n Spécifier un répertoire de chargement des drivers JDBC."
+ "\n Avec l'option -J, le répertoire spécifié est ajouté aux répertoires de"
+ "\n configuration par défaut ~/.sqlcsv et /etc/sqlcsv. Avec la variante +J,"
+ "\n seul le répertoire spécifié est analysé."
+ "\n Cette option *doit* être spécifiée en premier et il ne doit pas y avoir"
+ "\n d'espace entre l'option et son argument."
+ "\n"
+ "\n -C, --config CONFIG"
+ "\n Prendre les informations de connexion depuis le fichier de propriété"
+ "\n spécifié. Pour l'identifiant CONN, la propriété 'CONN.url' doit exister"
+ "\n dans ce fichier avec la valeur de l'url jdbc de connexion. De plus, les"
+ "\n propriétés 'CONN.user' et 'CONN.password' contiennent respectivement si"
+ "\n nécessaire le nom et le mot de passe de connexion. La propriété"
+ "\n 'loglevel', si elle existe, est utilisée pour configurer le niveau"
+ "\n d'affichage des logs, comme avec l'option --loglevel"
+ "\n Si cette option n'est pas spécifiée, un fichier nommé sqlcsv.properties"
+ "\n est recherché dans l'ordre: dans le répertoire courant, dans le"
+ "\n répertoire de configuration utilisateur, puis dans le répertoire de"
+ "\n configuration système. Si le fichier est trouvé, il est chargé"
+ "\n automatiquement."
+ "\n -l, --conn CONN"
+ "\n Spécifier l'identifiant (ou l'url) de connexion. Cette information est"
+ "\n obligatoire. Si cette option n'est pas fournie, il faut spécifier un"
+ "\n fichier de configuration avec l'option -C dans lequel *une seule*"
+ "\n propriété 'CONN.url' est définie."
+ "\n Si -C n'est pas spécifié et que -l est spécifié, alors l'identifiant de"
+ "\n connexion est enregistré dans les préférences utilisateur. Si ni -C"
+ "\n ni -l ne sont spécifiés, alors le dernier identifiant est utilisé s'il"
+ "\n existe. L'option -z permet de démarrer comme si aucun identifiant"
+ "\n n'avait jamais été enregistré."
+ "\n -j, --nop"
+ "\n Ne rien faire. Utile par exemple pour enregistrer l'identifiant de"
+ "\n connexion par défaut avec l'option -l"
+ "\n -u, --user USER"
+ "\n -p, --password PASSWORD"
+ "\n Spécifier un nom de connexion et un mot de passe si l'url ne le fournit"
+ "\n pas. Ces valeurs ont la priorité sur les valeurs éventuellement déjà"
+ "\n présentes dans le fichier de propriété."
+ "\n -f, --input INPUT"
+ "\n Lire la requête depuis le fichier INPUT au lieu de la lire depuis la"
+ "\n ligne de commande ou l'entrée standard. Ne pas spécifier cette option ou"
+ "\n utiliser '-' pour lire depuis l'entrée standard. Cette option est"
+ "\n ignorée si la requête est fournie sur la ligne de commande."
+ "\n -o, --output OUTPUT"
+ "\n Ecrire le résultat dans le fichier OUTPUT. Utiliser '-' pour spécifier"
+ "\n la sortie standard (c'est la valeur par défaut). S'il y a plusieurs"
+ "\n requêtes et que le fichier de sortie n'est pas la sortie standard,"
+ "\n ajouter un numéro incrémental au nom du fichier en sortie pour chaque"
+ "\n requête. Sinon, il est possible de spécifier plusieurs fois cette option"
+ "\n pour nommer les fichiers correspondant à chaque requête."
+ "\n -t, --autocommit"
+ "\n Activer le mode autocommit. Par défaut, le mode autocommit n'est pas activé"
+ "\n -c, --ignore-io-error"
+ "\n Continuer le traitement même en cas d'erreur du système de fichiers."
+ "\n Cependant le traitement s'arrête et la transaction est annulée si une"
+ "\n autre erreur se produit."
+ "\n -y, --ignore-any-error"
+ "\n Continuer le traitement même en cas d'erreur quelconque."
+ "\n -n, --no-headers"
+ "\n Ne JAMAIS inclure les en-têtes dans la sortie, même avec l'option -h"
+ "\n -a, --append"
+ "\n Ajouter le résultat au fichier OUTPUT au lieu de l'écraser."
+ "\n -A, --auto-na"
+ "\n Activer les option -n -a si le fichier OUTPUT existe et qu'il est non"
+ "\n vide. Le test n'est effectué que pour le premier fichier spécifié."
+ "\n -s, --same-output"
+ "\n Utiliser le même fichier pour écrire le résultat de toutes les requêtes."
+ "\n Normalement, un numéro incrémental est ajouté au fichier en sortie si"
+ "\n plusieurs requêtes sont spécifiées. Si les en-têtes sont les mêmes,"
+ "\n ajouter le résultat au fichier directement à la suite. Sinon, sauter une"
+ "\n ligne blanche et afficher les nouveaux en-têtes."
+ "\n -h, --force-headers"
+ "\n En cas d'écriture du résultat de plusieurs requêtes dans un même"
+ "\n fichier, ne pas tenter de concaténer les résultats même si les en-têtes"
+ "\n sont les mêmes."
+ "\n --uc-output"
+ "\n Ajouter dans la sortie les résultat de toutes les requêtes, pas"
+ "\n seulement celles de type DQML"
+ "\n --loglevel LOGLEVEL"
+ "\n Spécifier le niveau de logs à afficher. Les valeurs valides sont à"
+ "\n choisir parmi ALL, FINEST, FINER, FINE, CONFIG, INFO, WARNING, ERROR"
+ "\n La présence de certains fichiers dans les répertoires de configuration"
+ "\n utilisateur ou système configure les logs avant que les options de la"
+ "\n ligne de commande ne soient analysés: un fichier DEBUG fait démarrer"
+ "\n l'application avec le niveau de log ALL ce qui permet de voir les logs"
+ "\n concernant le chargement des jar. Un fichier SQL_DEBUG permet d'activer"
+ "\n la trace de DriverManager. Exemple:"
+ "\n mkdir -p ~/.sqlcsv && touch ~/.sqlcsv/{DEBUG,SQL_DEBUG}"
+ "\n -v, --verbose"
+ "\n Equivalent à --loglevel FINER pour afficher le maximum de messages"
+ "\n -z, --reset-prefs"
+ "\n Effacer les préférences avant de faire le calcul de l'identifiant par"
+ "\n défaut");
return;
}
String config = null, connid = null, user = null, password = null;
Options o = new Options();
boolean nop = false, autocommit = false, autoNa = false, resetPrefs = false;
String loglevel = null;
ArrayList<String> inputs = new ArrayList<String>();
ArrayList<String> outputs = new ArrayList<String>();
ArrayList<String> remainArgs = new ArrayList<String>();
int i = 0, max = args.length;
while (i < max) {
String arg = args[i];
if (arg.length() >= 2 && (arg.substring(0, 2).equals("-J") || arg.substring(0, 2).equals("+J"))) {
die("L'option -J doit être spécifiée en premier", null);
} else if (arg.equals("-C") || arg.equals("--config")) {
config = getArg(args, ++i, "Vous devez spécifier le fichier de configuration");
} else if (arg.equals("-l") || arg.equals("--conn")) {
connid = getArg(args, ++i, "Vous devez spécifier l'identifiant de connexion");
} else if (arg.equals("-j") || arg.equals("--nop")) {
nop = true;
} else if (arg.equals("-u") || arg.equals("--user")) {
user = getArg(args, ++i, "Vous devez spécifier l'utilisateur de connexion");
} else if (arg.equals("-p") || arg.equals("--password")) {
password = getArg(args, ++i, "Vous devez spécifier l'utilisateur de connexion");
} else if (arg.equals("-f") || arg.equals("--input")) {
String input = getArg(args, ++i, "Vous devez spécifier le fichier en entrée");
if (strEquals(input, "-") || strEquals(input, "/dev/stdin")) input = null;
inputs.add(input);
} else if (arg.equals("-o") || arg.equals("--output")) {
String output = getArg(args, ++i, "Vous devez spécifier le fichier en sortie");
if (strEquals(output, "-") || strEquals(output, "/dev/stdout")) output = null;
outputs.add(output);
} else if (arg.equals("-t") || arg.equals("--autocommit")) {
autocommit = true;
} else if (arg.equals("-c") || arg.equals("--ignore-io-error")) {
o.ignoreIoErrors = true;
} else if (arg.equals("-y") || arg.equals("--ignore-any-error")) {
o.ignoreAnyErrors = true;
} else if (arg.equals("-n") || arg.equals("--no-headers")) {
o.noHeaders = true;
} else if (arg.equals("-a") || arg.equals("--append")) {
o.append = true;
} else if (arg.equals("-A") || arg.equals("--auto-na")) {
autoNa = true;
} else if (arg.equals("-s") || arg.equals("--same-output")) {
o.sameOutput = true;
} else if (arg.equals("-h") || arg.equals("--force-headers")) {
o.forceHeaders = true;
} else if (arg.equals("--uc-output")) {
o.outputUc = true;
} else if (arg.equals("--loglevel")) {
loglevel = getArg(args, ++i, "Vous devez spécifier le niveau de logs");
} else if (arg.equals("-v") || arg.equals("--verbose")) {
loglevel = "FINER";
} else if (arg.equals("-z") || arg.equals("--reset-prefs")) {
resetPrefs = true;
} else if (arg.equals("--")) {
i++;
break;
} else {
remainArgs.add(arg);
}
i++;
}
args = remainArgs.toArray(new String[0]);
if (loglevel != null) {
log.setLevel(Level.parse(loglevel.toUpperCase()));
}
Preferences prefs = null;
boolean usePrefs = config == null;
if (resetPrefs || usePrefs) {
prefs = Preferences.userNodeForPackage(sqlcsv.class);
if (resetPrefs) prefs.clear();
if (usePrefs && connid == null) {
connid = prefs.get("lastConnid", null);
if (connid != null) {
log.fine("Sélection de la valeur par défaut connid=" + connid);
}
}
}
// Charger les propriétés...
// essayer depuis le répertoire courant et les répertoires parents jusqu'à $HOME
if (config == null) {
String userHome = System.getProperty("user.home");
if (userHome != null && userHome.length() == 0) userHome = null;
File dir = getCanonical(new File("."));
File homedir = null;
if (userHome != null) homedir = getCanonical(new File(userHome));
while (true) {
File file = new File(dir, DEFAULT_CONFIG);
if (file.exists()) {
config = file.getPath();
break;
}
if ((homedir != null && dir.equals(homedir)) || isRoot(dir)) break;
dir = dir.getParentFile();
if (dir == null) break;
}
}
// puis dans le répertoire de configuration utilisateur
if (config == null && new File(USER_CONFIG).exists()) config = USER_CONFIG;
// puis dans le répertoire de configuration système
if (config == null && new File(SYSTEM_CONFIG).exists()) config = SYSTEM_CONFIG;
Properties props = null;
if (config != null) {
log.config("Chargement des propriétés de " + config);
props = new Properties();
FileInputStream inf = null;
try {
inf = new FileInputStream(config);
props.load(inf);
} catch (FileNotFoundException e) {
throw new Exit(config + ": Fichier introuvable");
} finally {
close(inf);
}
}
if (props != null) {
String loglevelKey = "loglevel";
if (props.containsKey(loglevelKey)) {
loglevel = props.getProperty(loglevelKey);
log.setLevel(Level.parse(loglevel.toUpperCase()));
}
}
String jdbcUrl = null;
if (connid != null && connid.startsWith("jdbc:")) {
jdbcUrl = connid;
connid = null;
}
if (jdbcUrl == null && connid == null && props != null) {
// Essayer de deviner connid en parcourant les propriétés de props
@SuppressWarnings("unchecked")
Enumeration<String> en = (Enumeration<String>)props.propertyNames();
int count = 0;
while (en.hasMoreElements()) {
String propertyName = en.nextElement();
Matcher m = RE_URL_PROP.matcher(propertyName);
if (m.matches()) {
connid = m.group(1);
count++;
}
}
if (count > 1) {
// Si plusieurs configurations sont trouvées, ne pas en sélectionner une par
// défaut
connid = null;
}
}
if (jdbcUrl == null && connid != null) {
if (props != null) {
String jdbcUrlKey = connid + ".url";
if (props.containsKey(jdbcUrlKey)) jdbcUrl = props.getProperty(jdbcUrlKey);
String userKey = connid + ".user";
if (props.containsKey(userKey)) user = props.getProperty(userKey);
String passwordKey = connid + ".password";
if (props.containsKey(passwordKey)) password = props.getProperty(passwordKey);
} else {
jdbcUrl = connid;
}
}
if (jdbcUrl == null) {
if (resetPrefs) throw new Exit();
else throw new Exit("Vous devez spécifier l'url de connexion");
}
if (usePrefs && connid != null) {
log.fine("Enregistrement de la valeur connid=" + connid);
prefs.put("lastConnid", connid);
}
if (nop) return;
// Ouvrir les fichiers en entrée
ArrayList<BufferedReader> infs = new ArrayList<BufferedReader>();
boolean parseInputs = true;
if (args.length > 0) {
String query = args[0];
if (!strEquals(query, "-")) {
infs.add(new BufferedReader(new StringReader(query)));
parseInputs = false;
}
// XXX analyser les arguments à transmettre à la requête
}
if (parseInputs) {
if (inputs.size() == 0) inputs.add(null);
BufferedReader inf;
for (String input : inputs) {
if (input == null) {
inf = new BufferedReader(new InputStreamReader(System.in, UTF8));
} else {
inf = new BufferedReader(
new InputStreamReader(new FileInputStream(input), UTF8));
}
infs.add(inf);
}
}
// Préparer la liste des fichiers en sortie
if (outputs.size() == 0) outputs.add(null);
String output = outputs.get(0);
if (autoNa && output != null) {
if (new File(output).exists()) {
o.noHeaders = true;
o.append = true;
}
}
// Ouvrir la connexion
log.config("Connexion à " + jdbcUrl);
Connection conn;
if (user == null && password == null) conn = DriverManager.getConnection(jdbcUrl);
else conn = DriverManager.getConnection(jdbcUrl, user, password);
conn.setAutoCommit(autocommit);
// Exécuter les requêtes
try {
executeQueries(conn, null, infs, outputs, o, jdbcUrl);
} finally {
close(conn);
for (BufferedReader inf : infs) {
close(inf);
}
}
}
static final FilenameFilter JAR_FILTER = new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith(".jar");
}
};
static final boolean findJars(File confdir, ArrayList<URL> urls) {
if (!confdir.isDirectory()) return false;
log.config("Analyse des jars de " + confdir);
boolean foundJar = false;
for (File file : confdir.listFiles(JAR_FILTER)) {
try {
log.config("Ajout de " + file);
urls.add(file.toURI().toURL());
foundJar = true;
} catch (MalformedURLException e) {
}
}
return foundJar;
}
public static void main(String[] args) throws Exception {
if (new File(USER_CONFDIR + "/DEBUG").exists()
|| new File(SYSTEM_CONFDIR + "/DEBUG").exists()) {
log.setLevel(Level.ALL);
}
if (new File(USER_CONFDIR + "/SQL_DEBUG").exists()
|| new File(SYSTEM_CONFDIR + "/SQL_DEBUG").exists()) {
DriverManager.setLogWriter(new PrintWriter(System.err));
}
boolean jardirOption = false;
String jardir = null;
boolean jardirOnly = false;
if (args.length > 0) {
String firstOption = args[0].substring(0, 2);
if (firstOption.equals("-J")) {
jardirOption = true;
jardir = args[0].substring(2);
jardirOnly = false;
} else if (firstOption.equals("+J")) {
jardirOption = true;
jardir = args[0].substring(2);
jardirOnly = true;
}
if (jardirOption) {
if (jardir.length() == 0) die("L'option -J doit avoir un argument", null);
String[] newArgs = new String[args.length - 1];
System.arraycopy(args, 1, newArgs, 0, newArgs.length);
args = newArgs;
}
}
boolean shouldUpdateClasspath = false;
ArrayList<URL> urls = new ArrayList<URL>();
if (jardirOption) {
shouldUpdateClasspath |= findJars(new File(jardir), urls);
}
if (!jardirOption || !jardirOnly) {
shouldUpdateClasspath |= findJars(new File(USER_CONFDIR), urls);
shouldUpdateClasspath |= findJars(new File(SYSTEM_CONFDIR), urls);
}
if (shouldUpdateClasspath) {
ClassLoader parentLoader = Thread.currentThread().getContextClassLoader();
ClassLoader loader = new URLClassLoader(urls.toArray(new URL[0]), parentLoader);
Thread.currentThread().setContextClassLoader(loader);
for (String driverName : SUPPORTED_DRIVERS) {
try {
@SuppressWarnings("unchecked")
Class<Driver> driverClass = (Class<Driver>)loader.loadClass(driverName);
DriverManager.registerDriver(new DelegateDriver(driverClass.newInstance()));
} catch (Exception e) {
}
}
}
try {
new sqlcsv().run(args);
System.exit(0);
} catch (Throwable t) {
if (t instanceof InvocationTargetException) t = t.getCause();
if (t instanceof Exit) ((Exit)t).exit();
die(null, t);
}
}
}