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")
234 Option.builder(
"nprg")
235 .desc(
"Do not assign Render Groups to Polygons (faster import, but not renderable)")
236 .longOpt(
"noPolyRenderGroups")
241 option.setRequired(
true);
245 public CommandLine
parse(String[]
args)
throws ParseException {
246 CommandLineParser clp =
new DefaultParser() {
247 public CommandLine
parse(Options
options, String[] strings)
throws ParseException {
248 Options helpOptions =
new Options();
249 helpOptions.addOption(
250 Option.builder(
"h").desc(
"help message").longOpt(
"help").build());
252 CommandLine cmd = super.parse(helpOptions, strings);
253 }
catch (UnrecognizedOptionException uE) {
255 if (cmd.hasOption(
"help")) {
259 if (cmd.hasOption(
"version")) {
263 cmd = super.parse(
options, strings);
264 if (!cmd.hasOption(
"user") && !cmd.hasOption(
"client-cert")) {
265 throw new MissingArgumentException(
266 "Must supply either an HEAVYAI db user or a user certificate");
269 if (cmd.hasOption(
"user") || cmd.hasOption(
"passwd")) {
279 if (cmd.hasOption(
"client-cert") || cmd.hasOption(
"client-key")) {
285 if (options.getOption(
"user").isRequired()
286 && options.getOption(
"client-key").isRequired()) {
288 MutuallyExlusiveOptionsException.create(
289 "user/password can not be use with client-cert/client-key",
294 if (cmd.hasOption(
"http")
295 || cmd.hasOption(
"binary")
296 && (cmd.hasOption(
"client-cert")
297 || cmd.hasOption(
"client-key"))) {
299 "http|binary can not be use with ca-cert|client-cert|client-key",
304 if (cmd.hasOption(
"insecure") && !cmd.hasOption(
"https")) {
306 "insecure can only be use with https", strings);
313 public CommandLine
parse(Options options, String[] strings,
boolean b)
314 throws ParseException {
325 private CommandLine
cmd = null;
326 final static Logger
LOGGER = LoggerFactory.getLogger(SQLImporter.class);
328 return milliseconds / 1000;
345 }
catch (ParseException ex) {
346 LOGGER.error(ex.getLocalizedMessage());
347 s_args.printHelpMessage();
354 Connection conn = null;
355 Statement stmt = null;
361 LOGGER.info(
"Connecting to database url :" + cmd.getOptionValue(
"jdbcConnect"));
362 conn = DriverManager.getConnection(cmd.getOptionValue(
"jdbcConnect"),
363 cmd.getOptionValue(
"sourceUser"),
364 cmd.getOptionValue(
"sourcePasswd"));
365 vendor_types = Db_vendor_types.Db_vendor_factory(cmd.getOptionValue(
"jdbcConnect"));
366 long startTime = System.currentTimeMillis();
369 if (
cmd.hasOption(
"initializeFile")) {
375 conn.setAutoCommit(
false);
377 }
catch (SQLException se) {
379 "SQLException when attempting to setAutoCommit to false, jdbc driver probably doesnt support it. Error is "
384 stmt = conn.createStatement();
386 int bufferSize = Integer.valueOf(cmd.getOptionValue(
"bufferSize",
"10000"));
389 stmt.setFetchSize(bufferSize);
392 ResultSet rs = stmt.executeQuery(cmd.getOptionValue(
"sqlStmt"));
396 ResultSetMetaData md = rs.getMetaData();
399 timer = System.currentTimeMillis();
401 long resultCount = 0;
405 List<TColumn> cols =
new ArrayList(md.getColumnCount());
406 for (
int i = 1; i <= md.getColumnCount(); i++) {
411 boolean assignRenderGroups = !cmd.hasOption(
"noPolyRenderGroups");
415 for (
int i = 1; i <= md.getColumnCount(); i++) {
421 md.getColumnTypeName(i));
425 if (bufferCount == bufferSize) {
428 if (assignRenderGroups) {
429 client.load_table_binary_columnar_polys(
430 session, cmd.getOptionValue(
"targetTable"), cols, null,
true);
432 client.load_table_binary_columnar(
433 session, cmd.getOptionValue(
"targetTable"), cols, null);
436 for (
int i = 1; i <= md.getColumnCount(); i++) {
440 if (resultCount % 100000 == 0) {
441 LOGGER.info(
"Imported " + resultCount +
" records");
445 if (bufferCount > 0) {
447 if (assignRenderGroups) {
448 client.load_table_binary_columnar_polys(
449 session, cmd.getOptionValue(
"targetTable"), cols, null,
true);
451 client.load_table_binary_columnar(
452 session, cmd.getOptionValue(
"targetTable"), cols, null);
458 if (assignRenderGroups) {
459 client.load_table_binary_columnar_polys(
460 session, cmd.getOptionValue(
"targetTable"), null, null,
false);
463 LOGGER.info(
"result set count is " + resultCount +
" read time is "
464 + (System.currentTimeMillis() - timer) +
"ms");
471 totalTime = System.currentTimeMillis() - startTime;
472 }
catch (SQLException se) {
473 LOGGER.error(
"SQLException - " + se.toString());
474 se.printStackTrace();
475 }
catch (TDBException ex) {
476 LOGGER.error(
"TDBException - " + ex.getError_msg());
477 ex.printStackTrace();
478 }
catch (TException ex) {
479 LOGGER.error(
"TException failed - " + ex.toString());
480 ex.printStackTrace();
487 }
catch (SQLException se2) {
493 }
catch (SQLException se) {
494 LOGGER.error(
"SQlException in close - " + se.toString());
495 se.printStackTrace();
501 }
catch (TDBException ex) {
502 LOGGER.error(
"TDBException - in finalization " + ex.getError_msg());
503 ex.printStackTrace();
504 }
catch (TException ex) {
505 LOGGER.error(
"TException - in finalization" + ex.toString());
506 ex.printStackTrace();
515 BufferedReader reader =
516 new BufferedReader(
new FileReader(
cmd.getOptionValue(
"initializeFile")));
517 Statement stmt = conn.createStatement();
518 while ((line = reader.readLine()) != null) {
519 if (line.isEmpty()) {
522 LOGGER.info(
"Running : " +
line);
527 }
catch (IOException e) {
528 LOGGER.error(
"Exception occurred trying to read initialize file: "
529 + cmd.getOptionValue(
"initFile"));
531 }
catch (SQLException e) {
533 "Exception occurred trying to execute initialize file entry : " +
line);
538 private void help(Options options) {
540 HelpFormatter formatter =
new HelpFormatter();
541 formatter.setOptionComparator(null);
542 formatter.printHelp(
"SQLImporter", options);
545 private void checkDBTable(Connection otherdb_conn, ResultSetMetaData md)
546 throws SQLException {
548 String tName = cmd.getOptionValue(
"targetTable");
552 if (
cmd.hasOption(
"truncate")) {
565 List<TColumnType> dstColumns,
566 ResultSetMetaData srcColumns)
throws SQLException {
567 if (srcColumns.getColumnCount() != dstColumns.size()) {
568 LOGGER.error(
"Table sizes do not match: Destination " + dstColumns.size()
569 +
" versus Source " + srcColumns.getColumnCount());
572 for (
int i = 1; i <= dstColumns.size(); ++i) {
573 if (!dstColumns.get(i - 1).getCol_name().equalsIgnoreCase(
574 srcColumns.getColumnName(i))) {
576 "Destination table does not have matching column in same order for column number "
577 + i +
" destination column name is " + dstColumns.get(i - 1).col_name
578 +
" versus target column " + srcColumns.getColumnName(i));
581 TDatumType dstType = dstColumns.get(i - 1).getCol_type().getType();
582 int dstPrecision = dstColumns.get(i - 1).getCol_type().getPrecision();
583 int dstScale = dstColumns.get(i - 1).getCol_type().getScale();
584 int srcType = srcColumns.getColumnType(i);
585 int srcPrecision = srcColumns.getPrecision(i);
586 int srcScale = srcColumns.getScale(i);
588 boolean match =
false;
590 case java.sql.Types.TINYINT:
591 match |= dstType == TDatumType.TINYINT;
595 case java.sql.Types.SMALLINT:
596 match |= dstType == TDatumType.SMALLINT;
597 case java.sql.Types.INTEGER:
598 match |= dstType == TDatumType.INT;
599 case java.sql.Types.BIGINT:
600 match |= dstType == TDatumType.BIGINT;
601 if (
cmd.hasOption(
"AllowIntegerNarrowing")) {
602 match |= dstType == TDatumType.TINYINT || dstType == TDatumType.SMALLINT
603 || dstType == TDatumType.INT;
606 case java.sql.Types.DECIMAL:
607 case java.sql.Types.NUMERIC:
608 match = dstType == TDatumType.DECIMAL && dstPrecision == srcPrecision
609 && dstScale == srcScale;
611 case java.sql.Types.FLOAT:
612 case java.sql.Types.REAL:
613 match |= dstType == TDatumType.FLOAT;
615 case java.sql.Types.DOUBLE:
616 match |= dstType == TDatumType.DOUBLE;
617 if (
cmd.hasOption(
"AllowDoubleToFloat")) {
618 match |= dstType == TDatumType.FLOAT;
621 case java.sql.Types.TIME:
622 match = dstType == TDatumType.TIME;
624 case java.sql.Types.TIMESTAMP:
625 match = dstType == TDatumType.TIMESTAMP;
627 case java.sql.Types.DATE:
628 match = dstType == TDatumType.DATE;
630 case java.sql.Types.BOOLEAN:
633 match = dstType == TDatumType.BOOL;
635 case java.sql.Types.NVARCHAR:
636 case java.sql.Types.VARCHAR:
637 case java.sql.Types.NCHAR:
638 case java.sql.Types.CHAR:
639 case java.sql.Types.LONGVARCHAR:
640 case java.sql.Types.LONGNVARCHAR:
641 match = (dstType == TDatumType.STR || dstType == TDatumType.POINT
642 || dstType == TDatumType.POLYGON || dstType == TDatumType.MULTIPOLYGON
643 || dstType == TDatumType.LINESTRING
644 || dstType == TDatumType.MULTILINESTRING
645 || dstType == TDatumType.MULTIPOINT);
647 case java.sql.Types.OTHER:
650 Db_vendor_types.GisType gisType =
651 vendor_types.find_gis_type(otherdb_conn, srcColumns, i);
652 if (gisType.srid != dstScale) {
658 match = gisType.type.equalsIgnoreCase(
"POINT");
661 match = gisType.type.equalsIgnoreCase(
"MULTIPOINT");
664 match = gisType.type.equalsIgnoreCase(
"LINESTRING");
666 case MULTILINESTRING:
667 match = gisType.type.equalsIgnoreCase(
"MULTILINESTRING");
670 match = gisType.type.equalsIgnoreCase(
"POLYGON");
673 match = gisType.type.equalsIgnoreCase(
"MULTIPOLYGON");
676 LOGGER.error(
"Column type " + JDBCType.valueOf(srcType).getName()
682 LOGGER.error(
"Column type " + JDBCType.valueOf(srcType).getName()
687 LOGGER.error(
"Source and destination types for column "
688 + srcColumns.getColumnName(i)
689 +
" do not match. Please make sure that type, precision and scale are exactly the same");
695 private void createDBTable(Connection otherdb_conn, ResultSetMetaData metaData) {
696 StringBuilder sb =
new StringBuilder();
697 sb.append(
"Create table ").
append(
cmd.getOptionValue(
"targetTable")).
append(
"(");
701 for (
int i = 1; i <= metaData.getColumnCount(); i++) {
705 LOGGER.debug(
"Column name is " + metaData.getColumnName(i));
706 LOGGER.debug(
"Column type is " + metaData.getColumnTypeName(i));
707 LOGGER.debug(
"Column type is " + metaData.getColumnType(i));
709 sb.append(metaData.getColumnName(i)).append(
" ");
710 int col_type = metaData.getColumnType(i);
711 if (col_type == java.sql.Types.OTHER) {
712 Db_vendor_types.GisType
type =
713 vendor_types.find_gis_type(otherdb_conn, metaData, i);
714 sb.append(Db_vendor_types.gis_type_to_str(
type));
716 sb.append(
getColType(metaData.getColumnType(i),
717 metaData.getPrecision(i),
718 metaData.getScale(i)));
723 if (
Integer.valueOf(
cmd.getOptionValue(
"fragmentSize",
"0")) > 0) {
724 sb.append(
" with (fragment_size = ");
725 sb.append(cmd.getOptionValue(
"fragmentSize",
"0"));
729 }
catch (SQLException ex) {
730 LOGGER.error(
"Error processing the metadata - " + ex.toString());
738 TTransport transport = null;
739 TProtocol protocol =
new TBinaryProtocol(transport);
740 int port = Integer.valueOf(cmd.getOptionValue(
"port",
"6274"));
741 String server = cmd.getOptionValue(
"server",
"localhost");
744 boolean load_trust_store = cmd.hasOption(
"https");
746 if (
cmd.hasOption(
"https")) {
747 skT = SockTransportProperties.getEncryptedClientDefaultTrustStore(
748 !cmd.hasOption(
"insecure"));
749 transport = skT.openHttpsClientTransport(server, port);
751 protocol =
new TJSONProtocol(transport);
752 }
else if (
cmd.hasOption(
"http")) {
753 skT = SockTransportProperties.getUnencryptedClient();
754 transport = skT.openHttpClientTransport(server, port);
755 protocol =
new TJSONProtocol(transport);
757 skT = SockTransportProperties.getUnencryptedClient();
758 transport = skT.openClientTransport(server, port);
760 protocol =
new TBinaryProtocol(transport);
763 client =
new Heavy.Client(protocol);
765 if (
cmd.hasOption(
"user")) {
766 session = client.connect(cmd.getOptionValue(
"user",
"admin"),
767 cmd.getOptionValue(
"passwd",
"HyperInteractive"),
768 cmd.getOptionValue(
"database",
"omnisci"));
770 LOGGER.debug(
"Connected session is " +
session);
772 }
catch (TTransportException ex) {
773 LOGGER.error(
"Connection failed - " + ex.toString());
775 }
catch (TDBException ex) {
776 LOGGER.error(
"Connection failed - " + ex.getError_msg());
778 }
catch (TException ex) {
779 LOGGER.error(
"Connection failed - " + ex.toString());
781 }
catch (Exception ex) {
782 LOGGER.error(
"General exception - " + ex.toString());
788 LOGGER.debug(
"Getting columns for " + tName);
789 List<TColumnType> row_descriptor = null;
791 TTableDetails table_details = client.get_table_details(
session, tName);
792 row_descriptor = table_details.row_desc;
793 }
catch (TDBException ex) {
794 LOGGER.error(
"column check failed - " + ex.getError_msg());
796 }
catch (TException ex) {
797 LOGGER.error(
"column check failed - " + ex.toString());
800 return row_descriptor;
804 LOGGER.debug(
"Check for table " + tName);
806 List<String> recv_get_tables = client.get_tables(
session);
807 for (String s : recv_get_tables) {
808 if (s.equals(tName)) {
812 }
catch (TDBException ex) {
813 LOGGER.error(
"Table check failed - " + ex.getError_msg());
815 }
catch (TException ex) {
816 LOGGER.error(
"Table check failed - " + ex.toString());
823 LOGGER.info(
"Run Command - " + sql);
826 TQueryResult sqlResult = client.sql_execute(
session, sql +
";",
true, null, -1, -1);
827 }
catch (TDBException ex) {
828 LOGGER.error(
"SQL Execute failed - " + ex.getError_msg());
830 }
catch (TException ex) {
831 LOGGER.error(
"SQL Execute failed - " + ex.toString());
836 private String
getColType(
int cType,
int precision,
int scale) {
839 if (precision > 19) {
846 case java.sql.Types.TINYINT:
848 case java.sql.Types.SMALLINT:
850 case java.sql.Types.INTEGER:
852 case java.sql.Types.BIGINT:
854 case java.sql.Types.FLOAT:
856 case java.sql.Types.DECIMAL:
857 return (
"DECIMAL(" + precision +
"," + scale +
")");
858 case java.sql.Types.DOUBLE:
860 case java.sql.Types.REAL:
862 case java.sql.Types.NUMERIC:
863 return (
"NUMERIC(" + precision +
"," + scale +
")");
864 case java.sql.Types.TIME:
866 case java.sql.Types.TIMESTAMP:
867 return (
"TIMESTAMP");
868 case java.sql.Types.DATE:
870 case java.sql.Types.BOOLEAN:
874 case java.sql.Types.NVARCHAR:
875 case java.sql.Types.VARCHAR:
876 case java.sql.Types.NCHAR:
877 case java.sql.Types.CHAR:
878 case java.sql.Types.LONGVARCHAR:
879 case java.sql.Types.LONGNVARCHAR:
880 return (
"TEXT ENCODING DICT");
882 throw new AssertionError(
"Column type " + cType +
" not Supported");
887 throws SQLException {
888 TColumn col =
new TColumn();
890 col.nulls =
new ArrayList<Boolean>(bufferSize);
892 col.data =
new TColumnData();
894 switch (md.getColumnType(i)) {
895 case java.sql.Types.TINYINT:
896 case java.sql.Types.SMALLINT:
897 case java.sql.Types.INTEGER:
898 case java.sql.Types.BIGINT:
899 case java.sql.Types.TIME:
900 case java.sql.Types.TIMESTAMP:
903 case java.sql.Types.BOOLEAN:
904 case java.sql.Types.DATE:
905 case java.sql.Types.DECIMAL:
906 case java.sql.Types.NUMERIC:
907 col.data.int_col =
new ArrayList<Long>(bufferSize);
910 case java.sql.Types.FLOAT:
911 case java.sql.Types.DOUBLE:
912 case java.sql.Types.REAL:
913 col.data.real_col =
new ArrayList<Double>(bufferSize);
916 case java.sql.Types.NVARCHAR:
917 case java.sql.Types.VARCHAR:
918 case java.sql.Types.NCHAR:
919 case java.sql.Types.CHAR:
920 case java.sql.Types.LONGVARCHAR:
921 case java.sql.Types.LONGNVARCHAR:
922 case java.sql.Types.OTHER:
923 col.data.str_col =
new ArrayList<String>(bufferSize);
927 throw new AssertionError(
"Column type " + md.getColumnType(i) +
" not Supported");
937 String colTypeName)
throws SQLException {
938 switch (columnType) {
941 case java.sql.Types.BOOLEAN:
942 Boolean b = rs.getBoolean(colNum);
944 col.nulls.add(Boolean.TRUE);
945 col.data.int_col.add(0L);
947 col.nulls.add(Boolean.FALSE);
948 col.data.int_col.add(b ? 1L : 0L);
952 case java.sql.Types.DECIMAL:
953 case java.sql.Types.NUMERIC:
954 BigDecimal bd = rs.getBigDecimal(colNum);
956 col.nulls.add(Boolean.TRUE);
957 col.data.int_col.add(0L);
959 col.nulls.add(Boolean.FALSE);
960 col.data.int_col.add(bd.multiply(
new BigDecimal(pow(10L, scale))).longValue());
964 case java.sql.Types.TINYINT:
965 case java.sql.Types.SMALLINT:
966 case java.sql.Types.INTEGER:
967 case java.sql.Types.BIGINT:
968 Long l = rs.getLong(colNum);
970 col.nulls.add(Boolean.TRUE);
971 col.data.int_col.add(
new Long(0));
973 col.nulls.add(Boolean.FALSE);
974 col.data.int_col.add(l);
978 case java.sql.Types.TIME:
979 Time t = rs.getTime(colNum);
981 col.nulls.add(Boolean.TRUE);
982 col.data.int_col.add(0L);
985 col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(t.getTime()));
986 col.nulls.add(Boolean.FALSE);
990 case java.sql.Types.TIMESTAMP:
991 Timestamp ts = rs.getTimestamp(colNum);
993 col.nulls.add(Boolean.TRUE);
994 col.data.int_col.add(0L);
997 col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(ts.getTime()));
998 col.nulls.add(Boolean.FALSE);
1002 case java.sql.Types.DATE:
1003 Date d = rs.getDate(colNum);
1005 col.nulls.add(Boolean.TRUE);
1006 col.data.int_col.add(0L);
1009 col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(d.getTime()));
1010 col.nulls.add(Boolean.FALSE);
1013 case java.sql.Types.FLOAT:
1014 case java.sql.Types.DOUBLE:
1015 case java.sql.Types.REAL:
1016 Double db = rs.getDouble(colNum);
1018 col.nulls.add(Boolean.TRUE);
1019 col.data.real_col.add(
new Double(0));
1022 col.nulls.add(Boolean.FALSE);
1023 col.data.real_col.add(db);
1027 case java.sql.Types.NVARCHAR:
1028 case java.sql.Types.VARCHAR:
1029 case java.sql.Types.NCHAR:
1030 case java.sql.Types.CHAR:
1031 case java.sql.Types.LONGVARCHAR:
1032 case java.sql.Types.LONGNVARCHAR:
1033 String strVal = rs.getString(colNum);
1035 col.nulls.add(Boolean.TRUE);
1036 col.data.str_col.add(
"");
1039 col.data.str_col.add(strVal);
1040 col.nulls.add(Boolean.FALSE);
1043 case java.sql.Types.OTHER:
1044 Object objVal = rs.getObject(colNum);
1046 col.nulls.add(Boolean.TRUE);
1047 col.data.str_col.add(
"");
1049 col.data.str_col.add(vendor_types.get_wkt(rs, colNum, colTypeName));
1050 col.nulls.add(Boolean.FALSE);
1054 throw new AssertionError(
"Column type " + columnType +
" not Supported");
1059 throws SQLException {
1062 switch (md.getColumnType(i)) {
1063 case java.sql.Types.TINYINT:
1064 case java.sql.Types.SMALLINT:
1065 case java.sql.Types.INTEGER:
1066 case java.sql.Types.BIGINT:
1067 case java.sql.Types.TIME:
1068 case java.sql.Types.TIMESTAMP:
1071 case java.sql.Types.BOOLEAN:
1072 case java.sql.Types.DATE:
1073 case java.sql.Types.DECIMAL:
1074 case java.sql.Types.NUMERIC:
1075 col.data.int_col.clear();
1078 case java.sql.Types.FLOAT:
1079 case java.sql.Types.DOUBLE:
1080 case java.sql.Types.REAL:
1081 col.data.real_col.clear();
1084 case java.sql.Types.NVARCHAR:
1085 case java.sql.Types.VARCHAR:
1086 case java.sql.Types.NCHAR:
1087 case java.sql.Types.CHAR:
1088 case java.sql.Types.LONGVARCHAR:
1089 case java.sql.Types.LONGNVARCHAR:
1090 case java.sql.Types.OTHER:
1091 col.data.str_col.clear();
1094 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)