16 package com.mapd.utility;
18 import static java.lang.Math.pow;
19 import static java.lang.System.exit;
24 import org.apache.commons.cli.*;
25 import org.apache.thrift.TException;
26 import org.apache.thrift.protocol.TBinaryProtocol;
27 import org.apache.thrift.protocol.TJSONProtocol;
28 import org.apache.thrift.protocol.TProtocol;
29 import org.apache.thrift.transport.TSocket;
30 import org.apache.thrift.transport.TTransport;
31 import org.apache.thrift.transport.TTransportException;
32 import org.slf4j.Logger;
33 import org.slf4j.LoggerFactory;
35 import java.io.BufferedReader;
36 import java.io.FileReader;
37 import java.io.IOException;
38 import java.math.BigDecimal;
39 import java.security.KeyStore;
42 import java.util.ArrayList;
43 import java.util.List;
45 import ai.heavy.thrift.server.*;
57 StringBuffer sb =
new StringBuffer(
58 "Mutually exclusive options used. " + errMsg +
". Options provided [");
59 for (String s : strings) {
63 sb.setCharAt(sb.length() - 1,
']');
72 System.out.println(
"SQLImporter Version 4.6.0");
76 StringBuffer sb =
new StringBuffer(
"\nSQLImporter ");
79 sb.append(
"-u <userid> -p <password> [(--binary|--http|--https [--insecure])]\n");
80 sb.append(
"-s <omnisci server host> -db <omnisci db> --port <omnisci server port>\n");
85 "[-d <other database JDBC drive class>] -c <other database JDBC connection string>\n");
87 "-su <other database user> -sp <other database user password> -ss <other database sql statement>\n");
89 "-t <HEAVYAI target table> -b <transfer buffer size> -f <table fragment size>\n");
90 sb.append(
"[-tr] [-adtf] [-nprg] -i <init commands file>\n");
91 sb.append(
"\nSQLImporter -h | --help\n\n");
93 HelpFormatter formatter =
new HelpFormatter();
96 formatter.setOptionComparator(null);
98 formatter.printHelp(help_width, sb.toString(),
"",
options,
"");
102 options.addOption(
"r",
true,
"Row Load Limit");
105 options.addOption(Option.builder(
"h").desc(
"help message").longOpt(
"help").build());
107 Option.builder(
"u").hasArg().desc(
"HEAVYAI User").longOpt(
"user").build());
108 options.addOption(Option.builder(
"p")
110 .desc(
"HEAVYAI Password")
114 OptionGroup transport_grp =
new OptionGroup();
115 transport_grp.addOption(Option.builder()
116 .desc(
"use binary transport to connect to HEAVYAI ")
119 transport_grp.addOption(Option.builder()
120 .desc(
"use http transport to connect to HEAVYAI ")
123 transport_grp.addOption(Option.builder()
124 .desc(
"use https transport to connect to HEAVYAI ")
127 options.addOptionGroup(transport_grp);
130 options.addOption(Option.builder(
"s")
132 .desc(
"HEAVYAI Server")
135 options.addOption(Option.builder(
"db")
137 .desc(
"HEAVYAI Database")
141 Option.builder().hasArg().desc(
"HEAVYAI Port").longOpt(
"port").build());
144 options.addOption(Option.builder()
146 .desc(
"CA certificate trust store")
147 .longOpt(
"ca-trust-store")
149 options.addOption(Option.builder()
151 .desc(
"CA certificate trust store password")
152 .longOpt(
"ca-trust-store-passwd")
156 .desc(
"Insecure TLS - do not validate server HEAVYAI server credentials")
161 options.addOption(Option.builder(
"d")
163 .desc(
"JDBC driver class")
166 options.addOption(Option.builder(
"c")
168 .desc(
"JDBC Connection string")
169 .longOpt(
"jdbcConnect")
172 options.addOption(Option.builder(
"su")
175 .longOpt(
"sourceUser")
178 options.addOption(Option.builder(
"sp")
180 .desc(
"Source Password")
181 .longOpt(
"sourcePasswd")
184 options.addOption(Option.builder(
"ss")
186 .desc(
"SQL Select statement")
191 options.addOption(Option.builder(
"t")
193 .desc(
"HEAVYAI Target Table")
194 .longOpt(
"targetTable")
198 options.addOption(Option.builder(
"b")
200 .desc(
"transfer buffer size")
201 .longOpt(
"bufferSize")
203 options.addOption(Option.builder(
"f")
205 .desc(
"table fragment size")
206 .longOpt(
"fragmentSize")
209 options.addOption(Option.builder(
"tr")
210 .desc(
"Truncate table if it exists")
214 options.addOption(Option.builder(
"i")
216 .desc(
"File containing init command for DB")
217 .longOpt(
"initializeFile")
221 Option.builder(
"adtf")
222 .desc(
"Allow double to float conversion, note precision will be reduced")
223 .longOpt(
"AllowDoubleToFloat")
227 Option.builder(
"ain")
228 .desc(
"Allow conversion from bigger integer types to smaller. Overflow might occur, "
229 +
"use it only when casting is impossible")
230 .longOpt(
"AllowIntegerNarrowing")
235 option.setRequired(
true);
239 public CommandLine
parse(String[]
args)
throws ParseException {
240 CommandLineParser clp =
new DefaultParser() {
241 public CommandLine
parse(Options
options, String[] strings)
throws ParseException {
242 Options helpOptions =
new Options();
243 helpOptions.addOption(
244 Option.builder(
"h").desc(
"help message").longOpt(
"help").build());
246 CommandLine cmd = super.parse(helpOptions, strings);
247 }
catch (UnrecognizedOptionException uE) {
249 if (cmd.hasOption(
"help")) {
253 if (cmd.hasOption(
"version")) {
257 cmd = super.parse(
options, strings);
258 if (!cmd.hasOption(
"user") && !cmd.hasOption(
"client-cert")) {
259 throw new MissingArgumentException(
260 "Must supply either an HEAVYAI db user or a user certificate");
263 if (cmd.hasOption(
"user") || cmd.hasOption(
"passwd")) {
273 if (cmd.hasOption(
"client-cert") || cmd.hasOption(
"client-key")) {
279 if (options.getOption(
"user").isRequired()
280 && options.getOption(
"client-key").isRequired()) {
282 MutuallyExlusiveOptionsException.create(
283 "user/password can not be use with client-cert/client-key",
288 if (cmd.hasOption(
"http")
289 || cmd.hasOption(
"binary")
290 && (cmd.hasOption(
"client-cert")
291 || cmd.hasOption(
"client-key"))) {
293 "http|binary can not be use with ca-cert|client-cert|client-key",
298 if (cmd.hasOption(
"insecure") && !cmd.hasOption(
"https")) {
300 "insecure can only be use with https", strings);
307 public CommandLine
parse(Options options, String[] strings,
boolean b)
308 throws ParseException {
319 private CommandLine
cmd = null;
320 final static Logger
LOGGER = LoggerFactory.getLogger(SQLImporter.class);
322 return milliseconds / 1000;
339 }
catch (ParseException ex) {
340 LOGGER.error(ex.getLocalizedMessage());
341 s_args.printHelpMessage();
348 Connection
conn = null;
349 Statement stmt = null;
355 LOGGER.info(
"Connecting to database url :" + cmd.getOptionValue(
"jdbcConnect"));
356 conn = DriverManager.getConnection(cmd.getOptionValue(
"jdbcConnect"),
357 cmd.getOptionValue(
"sourceUser"),
358 cmd.getOptionValue(
"sourcePasswd"));
359 vendor_types = Db_vendor_types.Db_vendor_factory(cmd.getOptionValue(
"jdbcConnect"));
360 long startTime = System.currentTimeMillis();
363 if (
cmd.hasOption(
"initializeFile")) {
369 conn.setAutoCommit(
false);
371 }
catch (SQLException se) {
373 "SQLException when attempting to setAutoCommit to false, jdbc driver probably doesnt support it. Error is "
378 stmt = conn.createStatement();
380 int bufferSize = Integer.valueOf(cmd.getOptionValue(
"bufferSize",
"10000"));
383 stmt.setFetchSize(bufferSize);
386 ResultSet rs = stmt.executeQuery(cmd.getOptionValue(
"sqlStmt"));
390 ResultSetMetaData md = rs.getMetaData();
393 timer = System.currentTimeMillis();
395 long resultCount = 0;
399 List<TColumn> cols =
new ArrayList(md.getColumnCount());
400 for (
int i = 1; i <= md.getColumnCount(); i++) {
407 for (
int i = 1; i <= md.getColumnCount(); i++) {
413 md.getColumnTypeName(i));
417 if (bufferCount == bufferSize) {
420 client.load_table_binary_columnar(
421 session, cmd.getOptionValue(
"targetTable"), cols, null);
423 for (
int i = 1; i <= md.getColumnCount(); i++) {
427 if (resultCount % 100000 == 0) {
428 LOGGER.info(
"Imported " + resultCount +
" records");
432 if (bufferCount > 0) {
434 client.load_table_binary_columnar(
435 session, cmd.getOptionValue(
"targetTable"), cols, null);
439 LOGGER.info(
"result set count is " + resultCount +
" read time is "
440 + (System.currentTimeMillis() - timer) +
"ms");
447 totalTime = System.currentTimeMillis() - startTime;
448 }
catch (SQLException se) {
449 LOGGER.error(
"SQLException - " + se.toString());
450 se.printStackTrace();
451 }
catch (TDBException ex) {
452 LOGGER.error(
"TDBException - " + ex.getError_msg());
453 ex.printStackTrace();
454 }
catch (TException ex) {
455 LOGGER.error(
"TException failed - " + ex.toString());
456 ex.printStackTrace();
463 }
catch (SQLException se2) {
469 }
catch (SQLException se) {
470 LOGGER.error(
"SQlException in close - " + se.toString());
471 se.printStackTrace();
477 }
catch (TDBException ex) {
478 LOGGER.error(
"TDBException - in finalization " + ex.getError_msg());
479 ex.printStackTrace();
480 }
catch (TException ex) {
481 LOGGER.error(
"TException - in finalization" + ex.toString());
482 ex.printStackTrace();
491 BufferedReader reader =
492 new BufferedReader(
new FileReader(
cmd.getOptionValue(
"initializeFile")));
493 Statement stmt = conn.createStatement();
494 while ((line = reader.readLine()) != null) {
495 if (line.isEmpty()) {
498 LOGGER.info(
"Running : " +
line);
503 }
catch (IOException e) {
504 LOGGER.error(
"Exception occurred trying to read initialize file: "
505 + cmd.getOptionValue(
"initFile"));
507 }
catch (SQLException e) {
509 "Exception occurred trying to execute initialize file entry : " +
line);
514 private void help(Options options) {
516 HelpFormatter formatter =
new HelpFormatter();
517 formatter.setOptionComparator(null);
518 formatter.printHelp(
"SQLImporter", options);
521 private void checkDBTable(Connection otherdb_conn, ResultSetMetaData md)
522 throws SQLException {
524 String tName = cmd.getOptionValue(
"targetTable");
528 if (
cmd.hasOption(
"truncate")) {
541 List<TColumnType> dstColumns,
542 ResultSetMetaData srcColumns)
throws SQLException {
543 if (srcColumns.getColumnCount() != dstColumns.size()) {
544 LOGGER.error(
"Table sizes do not match: Destination " + dstColumns.size()
545 +
" versus Source " + srcColumns.getColumnCount());
548 for (
int i = 1; i <= dstColumns.size(); ++i) {
549 if (!dstColumns.get(i - 1).getCol_name().equalsIgnoreCase(
550 srcColumns.getColumnName(i))) {
552 "Destination table does not have matching column in same order for column number "
553 + i +
" destination column name is " + dstColumns.get(i - 1).col_name
554 +
" versus target column " + srcColumns.getColumnName(i));
557 TDatumType dstType = dstColumns.get(i - 1).getCol_type().getType();
558 int dstPrecision = dstColumns.get(i - 1).getCol_type().getPrecision();
559 int dstScale = dstColumns.get(i - 1).getCol_type().getScale();
560 int srcType = srcColumns.getColumnType(i);
561 int srcPrecision = srcColumns.getPrecision(i);
562 int srcScale = srcColumns.getScale(i);
564 boolean match =
false;
566 case java.sql.Types.TINYINT:
567 match |= dstType == TDatumType.TINYINT;
571 case java.sql.Types.SMALLINT:
572 match |= dstType == TDatumType.SMALLINT;
573 case java.sql.Types.INTEGER:
574 match |= dstType == TDatumType.INT;
575 case java.sql.Types.BIGINT:
576 match |= dstType == TDatumType.BIGINT;
577 if (
cmd.hasOption(
"AllowIntegerNarrowing")) {
578 match |= dstType == TDatumType.TINYINT || dstType == TDatumType.SMALLINT
579 || dstType == TDatumType.INT;
582 case java.sql.Types.DECIMAL:
583 case java.sql.Types.NUMERIC:
584 match = dstType == TDatumType.DECIMAL && dstPrecision == srcPrecision
585 && dstScale == srcScale;
587 case java.sql.Types.FLOAT:
588 case java.sql.Types.REAL:
589 match |= dstType == TDatumType.FLOAT;
591 case java.sql.Types.DOUBLE:
592 match |= dstType == TDatumType.DOUBLE;
593 if (
cmd.hasOption(
"AllowDoubleToFloat")) {
594 match |= dstType == TDatumType.FLOAT;
597 case java.sql.Types.TIME:
598 match = dstType == TDatumType.TIME;
600 case java.sql.Types.TIMESTAMP:
601 match = dstType == TDatumType.TIMESTAMP;
603 case java.sql.Types.DATE:
604 match = dstType == TDatumType.DATE;
606 case java.sql.Types.BOOLEAN:
609 match = dstType == TDatumType.BOOL;
611 case java.sql.Types.NVARCHAR:
612 case java.sql.Types.VARCHAR:
613 case java.sql.Types.NCHAR:
614 case java.sql.Types.CHAR:
615 case java.sql.Types.LONGVARCHAR:
616 case java.sql.Types.LONGNVARCHAR:
617 match = (dstType == TDatumType.STR || dstType == TDatumType.POINT
618 || dstType == TDatumType.POLYGON || dstType == TDatumType.MULTIPOLYGON
619 || dstType == TDatumType.LINESTRING
620 || dstType == TDatumType.MULTILINESTRING
621 || dstType == TDatumType.MULTIPOINT);
623 case java.sql.Types.OTHER:
626 Db_vendor_types.GisType gisType =
627 vendor_types.find_gis_type(otherdb_conn, srcColumns, i);
628 if (gisType.srid != dstScale) {
634 match = gisType.type.equalsIgnoreCase(
"POINT");
637 match = gisType.type.equalsIgnoreCase(
"MULTIPOINT");
640 match = gisType.type.equalsIgnoreCase(
"LINESTRING");
642 case MULTILINESTRING:
643 match = gisType.type.equalsIgnoreCase(
"MULTILINESTRING");
646 match = gisType.type.equalsIgnoreCase(
"POLYGON");
649 match = gisType.type.equalsIgnoreCase(
"MULTIPOLYGON");
652 LOGGER.error(
"Column type " + JDBCType.valueOf(srcType).getName()
658 LOGGER.error(
"Column type " + JDBCType.valueOf(srcType).getName()
663 LOGGER.error(
"Source and destination types for column "
664 + srcColumns.getColumnName(i)
665 +
" do not match. Please make sure that type, precision and scale are exactly the same");
671 private void createDBTable(Connection otherdb_conn, ResultSetMetaData metaData) {
672 StringBuilder sb =
new StringBuilder();
673 sb.append(
"Create table ").
append(
cmd.getOptionValue(
"targetTable")).
append(
"(");
677 for (
int i = 1; i <= metaData.getColumnCount(); i++) {
681 LOGGER.debug(
"Column name is " + metaData.getColumnName(i));
682 LOGGER.debug(
"Column type is " + metaData.getColumnTypeName(i));
683 LOGGER.debug(
"Column type is " + metaData.getColumnType(i));
685 sb.append(metaData.getColumnName(i)).append(
" ");
686 int col_type = metaData.getColumnType(i);
687 if (col_type == java.sql.Types.OTHER) {
688 Db_vendor_types.GisType
type =
689 vendor_types.find_gis_type(otherdb_conn, metaData, i);
690 sb.append(Db_vendor_types.gis_type_to_str(
type));
692 sb.append(
getColType(metaData.getColumnType(i),
693 metaData.getPrecision(i),
694 metaData.getScale(i)));
699 if (
Integer.valueOf(
cmd.getOptionValue(
"fragmentSize",
"0")) > 0) {
700 sb.append(
" with (fragment_size = ");
701 sb.append(cmd.getOptionValue(
"fragmentSize",
"0"));
705 }
catch (SQLException ex) {
706 LOGGER.error(
"Error processing the metadata - " + ex.toString());
714 TTransport transport = null;
715 TProtocol protocol =
new TBinaryProtocol(transport);
716 int port = Integer.valueOf(cmd.getOptionValue(
"port",
"6274"));
717 String server = cmd.getOptionValue(
"server",
"localhost");
720 boolean load_trust_store = cmd.hasOption(
"https");
722 if (
cmd.hasOption(
"https")) {
723 skT = SockTransportProperties.getEncryptedClientDefaultTrustStore(
724 !cmd.hasOption(
"insecure"));
725 transport = skT.openHttpsClientTransport(server, port);
727 protocol =
new TJSONProtocol(transport);
728 }
else if (
cmd.hasOption(
"http")) {
729 skT = SockTransportProperties.getUnencryptedClient();
730 transport = skT.openHttpClientTransport(server, port);
731 protocol =
new TJSONProtocol(transport);
733 skT = SockTransportProperties.getUnencryptedClient();
734 transport = skT.openClientTransport(server, port);
736 protocol =
new TBinaryProtocol(transport);
739 client =
new Heavy.Client(protocol);
741 if (
cmd.hasOption(
"user")) {
742 session = client.connect(cmd.getOptionValue(
"user",
"admin"),
743 cmd.getOptionValue(
"passwd",
"HyperInteractive"),
744 cmd.getOptionValue(
"database",
"omnisci"));
746 LOGGER.debug(
"Connected session is " +
session);
748 }
catch (TTransportException ex) {
749 LOGGER.error(
"Connection failed - " + ex.toString());
751 }
catch (TDBException ex) {
752 LOGGER.error(
"Connection failed - " + ex.getError_msg());
754 }
catch (TException ex) {
755 LOGGER.error(
"Connection failed - " + ex.toString());
757 }
catch (Exception ex) {
758 LOGGER.error(
"General exception - " + ex.toString());
764 LOGGER.debug(
"Getting columns for " + tName);
765 List<TColumnType> row_descriptor = null;
767 TTableDetails table_details = client.get_table_details(
session, tName);
768 row_descriptor = table_details.row_desc;
769 }
catch (TDBException ex) {
770 LOGGER.error(
"column check failed - " + ex.getError_msg());
772 }
catch (TException ex) {
773 LOGGER.error(
"column check failed - " + ex.toString());
776 return row_descriptor;
780 LOGGER.debug(
"Check for table " + tName);
782 List<String> recv_get_tables = client.get_tables(
session);
783 for (String s : recv_get_tables) {
784 if (s.equals(tName)) {
788 }
catch (TDBException ex) {
789 LOGGER.error(
"Table check failed - " + ex.getError_msg());
791 }
catch (TException ex) {
792 LOGGER.error(
"Table check failed - " + ex.toString());
799 LOGGER.info(
"Run Command - " + sql);
802 TQueryResult sqlResult = client.sql_execute(
session, sql +
";",
true, null, -1, -1);
803 }
catch (TDBException ex) {
804 LOGGER.error(
"SQL Execute failed - " + ex.getError_msg());
806 }
catch (TException ex) {
807 LOGGER.error(
"SQL Execute failed - " + ex.toString());
812 private String
getColType(
int cType,
int precision,
int scale) {
815 if (precision > 19) {
822 case java.sql.Types.TINYINT:
824 case java.sql.Types.SMALLINT:
826 case java.sql.Types.INTEGER:
828 case java.sql.Types.BIGINT:
830 case java.sql.Types.FLOAT:
832 case java.sql.Types.DECIMAL:
833 return (
"DECIMAL(" + precision +
"," + scale +
")");
834 case java.sql.Types.DOUBLE:
836 case java.sql.Types.REAL:
838 case java.sql.Types.NUMERIC:
839 return (
"NUMERIC(" + precision +
"," + scale +
")");
840 case java.sql.Types.TIME:
842 case java.sql.Types.TIMESTAMP:
843 return (
"TIMESTAMP");
844 case java.sql.Types.DATE:
846 case java.sql.Types.BOOLEAN:
850 case java.sql.Types.NVARCHAR:
851 case java.sql.Types.VARCHAR:
852 case java.sql.Types.NCHAR:
853 case java.sql.Types.CHAR:
854 case java.sql.Types.LONGVARCHAR:
855 case java.sql.Types.LONGNVARCHAR:
856 return (
"TEXT ENCODING DICT");
858 throw new AssertionError(
"Column type " + cType +
" not Supported");
863 throws SQLException {
864 TColumn col =
new TColumn();
866 col.nulls =
new ArrayList<Boolean>(bufferSize);
868 col.data =
new TColumnData();
870 switch (md.getColumnType(i)) {
871 case java.sql.Types.TINYINT:
872 case java.sql.Types.SMALLINT:
873 case java.sql.Types.INTEGER:
874 case java.sql.Types.BIGINT:
875 case java.sql.Types.TIME:
876 case java.sql.Types.TIMESTAMP:
879 case java.sql.Types.BOOLEAN:
880 case java.sql.Types.DATE:
881 case java.sql.Types.DECIMAL:
882 case java.sql.Types.NUMERIC:
883 col.data.int_col =
new ArrayList<Long>(bufferSize);
886 case java.sql.Types.FLOAT:
887 case java.sql.Types.DOUBLE:
888 case java.sql.Types.REAL:
889 col.data.real_col =
new ArrayList<Double>(bufferSize);
892 case java.sql.Types.NVARCHAR:
893 case java.sql.Types.VARCHAR:
894 case java.sql.Types.NCHAR:
895 case java.sql.Types.CHAR:
896 case java.sql.Types.LONGVARCHAR:
897 case java.sql.Types.LONGNVARCHAR:
898 case java.sql.Types.OTHER:
899 col.data.str_col =
new ArrayList<String>(bufferSize);
903 throw new AssertionError(
"Column type " + md.getColumnType(i) +
" not Supported");
913 String colTypeName)
throws SQLException {
914 switch (columnType) {
917 case java.sql.Types.BOOLEAN:
918 Boolean b = rs.getBoolean(colNum);
920 col.nulls.add(Boolean.TRUE);
921 col.data.int_col.add(0L);
923 col.nulls.add(Boolean.FALSE);
924 col.data.int_col.add(b ? 1L : 0L);
928 case java.sql.Types.DECIMAL:
929 case java.sql.Types.NUMERIC:
930 BigDecimal bd = rs.getBigDecimal(colNum);
932 col.nulls.add(Boolean.TRUE);
933 col.data.int_col.add(0L);
935 col.nulls.add(Boolean.FALSE);
936 col.data.int_col.add(bd.multiply(
new BigDecimal(pow(10L, scale))).longValue());
940 case java.sql.Types.TINYINT:
941 case java.sql.Types.SMALLINT:
942 case java.sql.Types.INTEGER:
943 case java.sql.Types.BIGINT:
944 Long l = rs.getLong(colNum);
946 col.nulls.add(Boolean.TRUE);
947 col.data.int_col.add(
new Long(0));
949 col.nulls.add(Boolean.FALSE);
950 col.data.int_col.add(l);
954 case java.sql.Types.TIME:
955 Time t = rs.getTime(colNum);
957 col.nulls.add(Boolean.TRUE);
958 col.data.int_col.add(0L);
961 col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(t.getTime()));
962 col.nulls.add(Boolean.FALSE);
966 case java.sql.Types.TIMESTAMP:
967 Timestamp ts = rs.getTimestamp(colNum);
969 col.nulls.add(Boolean.TRUE);
970 col.data.int_col.add(0L);
973 col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(ts.getTime()));
974 col.nulls.add(Boolean.FALSE);
978 case java.sql.Types.DATE:
979 Date d = rs.getDate(colNum);
981 col.nulls.add(Boolean.TRUE);
982 col.data.int_col.add(0L);
985 col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(d.getTime()));
986 col.nulls.add(Boolean.FALSE);
989 case java.sql.Types.FLOAT:
990 case java.sql.Types.DOUBLE:
991 case java.sql.Types.REAL:
992 Double db = rs.getDouble(colNum);
994 col.nulls.add(Boolean.TRUE);
995 col.data.real_col.add(
new Double(0));
998 col.nulls.add(Boolean.FALSE);
999 col.data.real_col.add(db);
1003 case java.sql.Types.NVARCHAR:
1004 case java.sql.Types.VARCHAR:
1005 case java.sql.Types.NCHAR:
1006 case java.sql.Types.CHAR:
1007 case java.sql.Types.LONGVARCHAR:
1008 case java.sql.Types.LONGNVARCHAR:
1009 String strVal = rs.getString(colNum);
1011 col.nulls.add(Boolean.TRUE);
1012 col.data.str_col.add(
"");
1015 col.data.str_col.add(strVal);
1016 col.nulls.add(Boolean.FALSE);
1019 case java.sql.Types.OTHER:
1020 Object objVal = rs.getObject(colNum);
1022 col.nulls.add(Boolean.TRUE);
1023 col.data.str_col.add(
"");
1025 col.data.str_col.add(vendor_types.get_wkt(rs, colNum, colTypeName));
1026 col.nulls.add(Boolean.FALSE);
1030 throw new AssertionError(
"Column type " + columnType +
" not Supported");
1035 throws SQLException {
1038 switch (md.getColumnType(i)) {
1039 case java.sql.Types.TINYINT:
1040 case java.sql.Types.SMALLINT:
1041 case java.sql.Types.INTEGER:
1042 case java.sql.Types.BIGINT:
1043 case java.sql.Types.TIME:
1044 case java.sql.Types.TIMESTAMP:
1047 case java.sql.Types.BOOLEAN:
1048 case java.sql.Types.DATE:
1049 case java.sql.Types.DECIMAL:
1050 case java.sql.Types.NUMERIC:
1051 col.data.int_col.clear();
1054 case java.sql.Types.FLOAT:
1055 case java.sql.Types.DOUBLE:
1056 case java.sql.Types.REAL:
1057 col.data.real_col.clear();
1060 case java.sql.Types.NVARCHAR:
1061 case java.sql.Types.VARCHAR:
1062 case java.sql.Types.NCHAR:
1063 case java.sql.Types.CHAR:
1064 case java.sql.Types.LONGVARCHAR:
1065 case java.sql.Types.LONGNVARCHAR:
1066 case java.sql.Types.OTHER:
1067 col.data.str_col.clear();
1070 throw new AssertionError(
"Column type " + md.getColumnType(i) +
" not Supported");
void createDBTable(Connection otherdb_conn, ResultSetMetaData metaData)
void resetBinaryColumn(int i, ResultSetMetaData md, int bufferSize, TColumn col)
Option setOptionRequired(Option option)
size_t append(FILE *f, const size_t size, const int8_t *buf)
Appends the specified number of bytes to the end of the file f from buf.
String getColType(int cType, int precision, int scale)
void executeDBCommand(String sql)
abstract boolean isAutoCommitDisabledRequired()
void help(Options options)
static void main(String[] args)
void createDBConnection()
void doWork(String[] args)
void setColValue(ResultSet rs, TColumn col, int columnType, int colNum, int scale, String colTypeName)
List< TColumnType > getColumnInfo(String tName)
CommandLine parse(String[] args)
void checkDBTable(Connection otherdb_conn, ResultSetMetaData md)
void verifyColumnSignaturesMatch(Connection otherdb_conn, List< TColumnType > dstColumns, ResultSetMetaData srcColumns)
static final Logger LOGGER
boolean tableExists(String tName)
long getSecondsFromMilliseconds(long milliseconds)
DateTimeUtils dateTimeUtils
MutuallyExlusiveOptionsException(String message)
TColumn setupBinaryColumn(int i, ResultSetMetaData md, int bufferSize)
static MutuallyExlusiveOptionsException create(String errMsg, String[] strings)
Db_vendor_types vendor_types
void run_init(Connection conn)