OmniSciDB  29e35f4d58
com.mapd.utility.SQLImporter Class Reference
+ Collaboration diagram for com.mapd.utility.SQLImporter:

Static Public Member Functions

static void main (String[] args)
 

Protected Attributes

String session = null
 
MapD.Client client = null
 

Package Functions

void doWork (String[] args)
 
void executeQuery ()
 

Package Attributes

Db_vendor_types vendor_types = null
 

Static Package Attributes

static final Logger LOGGER = LoggerFactory.getLogger(SQLImporter.class)
 

Private Member Functions

void run_init (Connection conn)
 
void help (Options options)
 
void checkMapDTable (Connection otherdb_conn, ResultSetMetaData md) throws SQLException
 
void createMapDTable (Connection otherdb_conn, ResultSetMetaData metaData)
 
void createMapDConnection ()
 
List< TColumnType > getColumnInfo (String tName)
 
boolean tableExists (String tName)
 
void executeMapDCommand (String sql)
 
String getColType (int cType, int precision, int scale)
 
TColumn setupBinaryColumn (int i, ResultSetMetaData md, int bufferSize) throws SQLException
 
void setColValue (ResultSet rs, TColumn col, int columnType, int colNum, int scale, String colTypeName) throws SQLException
 
void resetBinaryColumn (int i, ResultSetMetaData md, int bufferSize, TColumn col) throws SQLException
 

Private Attributes

CommandLine cmd = null
 
DateTimeUtils dateTimeUtils
 

Detailed Description

Definition at line 306 of file SQLImporter.java.

Member Function Documentation

◆ checkMapDTable()

void com.mapd.utility.SQLImporter.checkMapDTable ( Connection  otherdb_conn,
ResultSetMetaData  md 
) throws SQLException
inlineprivate

Definition at line 498 of file SQLImporter.java.

References Experimental.String.

499  {
501  String tName = cmd.getOptionValue("targetTable");
502 
503  if (tableExists(tName)) {
504  // check if we want to truncate
505  if (cmd.hasOption("truncate")) {
506  executeMapDCommand("Drop table " + tName);
507  createMapDTable(otherdb_conn, md);
508  } else {
509  List<TColumnType> columnInfo = getColumnInfo(tName);
510  // table exists lets check it has same number of columns
511 
512  if (md.getColumnCount() != columnInfo.size()) {
513  LOGGER.error("Table sizes do not match - OmniSci " + columnInfo.size()
514  + " versus Select " + md.getColumnCount());
515  exit(1);
516  }
517  // table exists lets check it is same layout - check names will do for now
518  // Note weird start from 1 and reduce index by one is due to sql metatdata
519  // beinging with 1 not 0
520  for (int colNum = 1; colNum <= columnInfo.size(); colNum++) {
521  if (!columnInfo.get(colNum - 1)
522  .col_name.equalsIgnoreCase(md.getColumnName(colNum))) {
523  LOGGER.error(
524  "OmniSci Table does not have matching column in same order for column number"
525  + colNum + " OmniSci column name is "
526  + columnInfo.get(colNum - 1).col_name + " versus Select "
527  + md.getColumnName(colNum));
528  exit(1);
529  }
530  }
531  }
532  } else {
533  createMapDTable(otherdb_conn, md);
534  }
535  }
List< TColumnType > getColumnInfo(String tName)
void createMapDTable(Connection otherdb_conn, ResultSetMetaData metaData)
static final Logger LOGGER
boolean tableExists(String tName)
void executeMapDCommand(String sql)

◆ createMapDConnection()

void com.mapd.utility.SQLImporter.createMapDConnection ( )
inlineprivate

Definition at line 577 of file SQLImporter.java.

References com.mapd.common.SockTransportProperties.getEncryptedClientDefaultTrustStore(), com.mapd.common.SockTransportProperties.getUnencryptedClient(), Integer, com.mapd.common.SockTransportProperties.openClientTransport(), com.mapd.common.SockTransportProperties.openHttpClientTransport(), com.mapd.common.SockTransportProperties.openHttpsClientTransport(), and Experimental.String.

577  {
578  TTransport transport = null;
579  TProtocol protocol = new TBinaryProtocol(transport);
580  int port = Integer.valueOf(cmd.getOptionValue("port", "6274"));
581  String server = cmd.getOptionValue("server", "localhost");
582  try {
583  // Uses default certificate stores.
584  boolean load_trust_store = cmd.hasOption("https");
585  SockTransportProperties skT = null;
586  if (cmd.hasOption("https")) {
587  skT = SockTransportProperties.getEncryptedClientDefaultTrustStore(
588  !cmd.hasOption("insecure"));
589  transport = skT.openHttpsClientTransport(server, port);
590  transport.open();
591  protocol = new TJSONProtocol(transport);
592  } else if (cmd.hasOption("http")) {
593  skT = SockTransportProperties.getUnencryptedClient();
594  transport = skT.openHttpClientTransport(server, port);
595  protocol = new TJSONProtocol(transport);
596  } else {
597  skT = SockTransportProperties.getUnencryptedClient();
598  transport = skT.openClientTransport(server, port);
599  transport.open();
600  protocol = new TBinaryProtocol(transport);
601  }
602 
603  client = new MapD.Client(protocol);
604  // This if will be useless until PKI signon
605  if (cmd.hasOption("user")) {
606  session = client.connect(cmd.getOptionValue("user", "admin"),
607  cmd.getOptionValue("passwd", "HyperInteractive"),
608  cmd.getOptionValue("database", "omnisci"));
609  }
610  LOGGER.debug("Connected session is " + session);
611 
612  } catch (TTransportException ex) {
613  LOGGER.error("Connection failed - " + ex.toString());
614  exit(1);
615  } catch (TMapDException ex) {
616  LOGGER.error("Connection failed - " + ex.toString());
617  exit(2);
618  } catch (TException ex) {
619  LOGGER.error("Connection failed - " + ex.toString());
620  exit(3);
621  } catch (Exception ex) {
622  LOGGER.error("General exception - " + ex.toString());
623  exit(4);
624  }
625  }
static final Logger LOGGER
+ Here is the call graph for this function:

◆ createMapDTable()

void com.mapd.utility.SQLImporter.createMapDTable ( Connection  otherdb_conn,
ResultSetMetaData  metaData 
)
inlineprivate

Definition at line 537 of file SQLImporter.java.

References File_Namespace.append(), com.mapd.utility.db_vendors.Db_vendor_types.find_gis_type(), and Integer.

537  {
538  StringBuilder sb = new StringBuilder();
539  sb.append("Create table ").append(cmd.getOptionValue("targetTable")).append("(");
540 
541  // Now iterate the metadata
542  try {
543  for (int i = 1; i <= metaData.getColumnCount(); i++) {
544  if (i > 1) {
545  sb.append(",");
546  }
547  LOGGER.debug("Column name is " + metaData.getColumnName(i));
548  LOGGER.debug("Column type is " + metaData.getColumnTypeName(i));
549  LOGGER.debug("Column type is " + metaData.getColumnType(i));
550 
551  sb.append(metaData.getColumnName(i)).append(" ");
552  int col_type = metaData.getColumnType(i);
553  if (col_type == java.sql.Types.OTHER) {
554  sb.append(vendor_types.find_gis_type(otherdb_conn, metaData, i));
555  } else {
556  sb.append(getColType(metaData.getColumnType(i),
557  metaData.getPrecision(i),
558  metaData.getScale(i)));
559  }
560  }
561  sb.append(")");
562 
563  if (Integer.valueOf(cmd.getOptionValue("fragmentSize", "0")) > 0) {
564  sb.append(" with (fragment_size = ");
565  sb.append(cmd.getOptionValue("fragmentSize", "0"));
566  sb.append(")");
567  }
568 
569  } catch (SQLException ex) {
570  LOGGER.error("Error processing the metadata - " + ex.toString());
571  exit(1);
572  }
573 
574  executeMapDCommand(sb.toString());
575  }
String getColType(int cType, int precision, int scale)
size_t append(FILE *f, const size_t size, int8_t *buf)
Appends the specified number of bytes to the end of the file f from buf.
Definition: File.cpp:135
abstract String find_gis_type(Connection conn, ResultSetMetaData metadata, int column_number)
static final Logger LOGGER
void executeMapDCommand(String sql)
+ Here is the call graph for this function:

◆ doWork()

void com.mapd.utility.SQLImporter.doWork ( String []  args)
inlinepackage

Definition at line 322 of file SQLImporter.java.

References com.mapd.utility.SQLImporter_args.parse(), and com.mapd.utility.SQLImporter_args.printHelpMessage().

Referenced by com.mapd.utility.SQLImporter.main().

322  {
323  // create Options object
324 
325  SQLImporter_args s_args = new SQLImporter_args();
326 
327  try {
328  cmd = s_args.parse(args);
329  } catch (ParseException ex) {
330  LOGGER.error(ex.getLocalizedMessage());
331  s_args.printHelpMessage();
332  exit(0);
333  }
334  executeQuery();
335  }
static final Logger LOGGER
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ executeMapDCommand()

void com.mapd.utility.SQLImporter.executeMapDCommand ( String  sql)
inlineprivate

Definition at line 662 of file SQLImporter.java.

662  {
663  LOGGER.info(" run comamnd :" + sql);
664 
665  try {
666  TQueryResult sqlResult = client.sql_execute(session, sql + ";", true, null, -1, -1);
667  } catch (TMapDException ex) {
668  LOGGER.error("SQL Execute failed - " + ex.toString());
669  exit(1);
670  } catch (TException ex) {
671  LOGGER.error("SQL Execute failed - " + ex.toString());
672  exit(1);
673  }
674  }
static final Logger LOGGER

◆ executeQuery()

void com.mapd.utility.SQLImporter.executeQuery ( )
inlinepackage

Definition at line 337 of file SQLImporter.java.

References com.mapd.utility.db_vendors.Db_vendor_types.Db_vendor_factory(), and Integer.

337  {
338  Connection conn = null;
339  Statement stmt = null;
340 
341  long totalTime = 0;
342 
343  try {
344  // Open a connection
345  LOGGER.info("Connecting to database url :" + cmd.getOptionValue("jdbcConnect"));
346  conn = DriverManager.getConnection(cmd.getOptionValue("jdbcConnect"),
347  cmd.getOptionValue("sourceUser"),
348  cmd.getOptionValue("sourcePasswd"));
349  vendor_types = Db_vendor_types.Db_vendor_factory(cmd.getOptionValue("jdbcConnect"));
350  long startTime = System.currentTimeMillis();
351 
352  // run init file script on targe DB if present
353  if (cmd.hasOption("initializeFile")) {
354  run_init(conn);
355  }
356 
357  // set autocommit off to allow postgress to not load all results
358  try {
359  conn.setAutoCommit(false);
360  } catch (SQLException se) {
361  LOGGER.warn(
362  "SQLException when attempting to setAutoCommit to false, jdbc driver probably doesnt support it. Error is "
363  + se.toString());
364  }
365 
366  // Execute a query
367  stmt = conn.createStatement();
368 
369  int bufferSize = Integer.valueOf(cmd.getOptionValue("bufferSize", "10000"));
370  // set the jdbc fetch buffer size to reduce the amount of records being moved to
371  // java from postgress
372  stmt.setFetchSize(bufferSize);
373  long timer;
374 
375  ResultSet rs = stmt.executeQuery(cmd.getOptionValue("sqlStmt"));
376 
377  // check if table already exists and is compatible in OmniSci with the query
378  // metadata
379  ResultSetMetaData md = rs.getMetaData();
380  checkMapDTable(conn, md);
381 
382  timer = System.currentTimeMillis();
383 
384  long resultCount = 0;
385  int bufferCount = 0;
386  long total = 0;
387 
388  List<TColumn> cols = new ArrayList(md.getColumnCount());
389  for (int i = 1; i <= md.getColumnCount(); i++) {
390  TColumn col = setupBinaryColumn(i, md, bufferSize);
391  cols.add(col);
392  }
393 
394  // read data from old DB
395  while (rs.next()) {
396  for (int i = 1; i <= md.getColumnCount(); i++) {
397  setColValue(rs,
398  cols.get(i - 1),
399  md.getColumnType(i),
400  i,
401  md.getScale(i),
402  md.getColumnTypeName(i));
403  }
404  resultCount++;
405  bufferCount++;
406  if (bufferCount == bufferSize) {
407  bufferCount = 0;
408  // send the buffer to mapD
409  client.load_table_binary_columnar(
410  session, cmd.getOptionValue("targetTable"), cols); // old
411  // recreate columnar store for use
412  for (int i = 1; i <= md.getColumnCount(); i++) {
413  resetBinaryColumn(i, md, bufferSize, cols.get(i - 1));
414  }
415 
416  if (resultCount % 100000 == 0) {
417  LOGGER.info("Imported " + resultCount + " records");
418  }
419  }
420  }
421  if (bufferCount > 0) {
422  // send the LAST buffer to mapD
423  client.load_table_binary_columnar(
424  session, cmd.getOptionValue("targetTable"), cols);
425  bufferCount = 0;
426  }
427  LOGGER.info("result set count is " + resultCount + " read time is "
428  + (System.currentTimeMillis() - timer) + "ms");
429 
430  // Clean-up environment
431  rs.close();
432  stmt.close();
433 
434  totalTime = System.currentTimeMillis() - startTime;
435  conn.close();
436  } catch (SQLException se) {
437  LOGGER.error("SQLException - " + se.toString());
438  se.printStackTrace();
439  } catch (TMapDException ex) {
440  LOGGER.error("TMapDException - " + ex.toString());
441  ex.printStackTrace();
442  } catch (TException ex) {
443  LOGGER.error("TException failed - " + ex.toString());
444  ex.printStackTrace();
445  } finally {
446  // finally block used to close resources
447  try {
448  if (stmt != null) {
449  stmt.close();
450  }
451  } catch (SQLException se2) {
452  } // nothing we can do
453  try {
454  if (conn != null) {
455  conn.close();
456  }
457  } catch (SQLException se) {
458  LOGGER.error("SQlException in close - " + se.toString());
459  se.printStackTrace();
460  } // end finally try
461  } // end try
462  }
static com.mapd.utility.db_vendors.Db_vendor_types Db_vendor_factory(String connection_str)
void resetBinaryColumn(int i, ResultSetMetaData md, int bufferSize, TColumn col)
void checkMapDTable(Connection otherdb_conn, ResultSetMetaData md)
void setColValue(ResultSet rs, TColumn col, int columnType, int colNum, int scale, String colTypeName)
static final Logger LOGGER
TColumn setupBinaryColumn(int i, ResultSetMetaData md, int bufferSize)
void run_init(Connection conn)
+ Here is the call graph for this function:

◆ getColType()

String com.mapd.utility.SQLImporter.getColType ( int  cType,
int  precision,
int  scale 
)
inlineprivate

Definition at line 676 of file SQLImporter.java.

676  {
677  // Note - if cType is OTHER a earlier call will have been made
678  // to try and work out the db vendors specific type.
679  if (precision > 19) {
680  precision = 19;
681  }
682  if (scale > 19) {
683  scale = 18;
684  }
685  switch (cType) {
686  case java.sql.Types.TINYINT:
687  return ("TINYINT");
688  case java.sql.Types.SMALLINT:
689  return ("SMALLINT");
690  case java.sql.Types.INTEGER:
691  return ("INTEGER");
692  case java.sql.Types.BIGINT:
693  return ("BIGINT");
694  case java.sql.Types.FLOAT:
695  return ("FLOAT");
696  case java.sql.Types.DECIMAL:
697  return ("DECIMAL(" + precision + "," + scale + ")");
698  case java.sql.Types.DOUBLE:
699  return ("DOUBLE");
700  case java.sql.Types.REAL:
701  return ("REAL");
702  case java.sql.Types.NUMERIC:
703  return ("NUMERIC(" + precision + "," + scale + ")");
704  case java.sql.Types.TIME:
705  return ("TIME");
706  case java.sql.Types.TIMESTAMP:
707  return ("TIMESTAMP");
708  case java.sql.Types.DATE:
709  return ("DATE");
710  case java.sql.Types.BOOLEAN:
711  case java.sql.Types
712  .BIT: // deal with postgress treating boolean as bit... this will bite me
713  return ("BOOLEAN");
714  case java.sql.Types.NVARCHAR:
715  case java.sql.Types.VARCHAR:
716  case java.sql.Types.NCHAR:
717  case java.sql.Types.CHAR:
718  case java.sql.Types.LONGVARCHAR:
719  case java.sql.Types.LONGNVARCHAR:
720  return ("TEXT ENCODING DICT");
721  default:
722  throw new AssertionError("Column type " + cType + " not Supported");
723  }
724  }

◆ getColumnInfo()

List<TColumnType> com.mapd.utility.SQLImporter.getColumnInfo ( String  tName)
inlineprivate

Definition at line 627 of file SQLImporter.java.

627  {
628  LOGGER.debug("Getting columns for " + tName);
629  List<TColumnType> row_descriptor = null;
630  try {
631  TTableDetails table_details = client.get_table_details(session, tName);
632  row_descriptor = table_details.row_desc;
633  } catch (TMapDException ex) {
634  LOGGER.error("column check failed - " + ex.toString());
635  exit(3);
636  } catch (TException ex) {
637  LOGGER.error("column check failed - " + ex.toString());
638  exit(3);
639  }
640  return row_descriptor;
641  }
static final Logger LOGGER

◆ help()

void com.mapd.utility.SQLImporter.help ( Options  options)
inlineprivate

Definition at line 491 of file SQLImporter.java.

491  {
492  // automatically generate the help statement
493  HelpFormatter formatter = new HelpFormatter();
494  formatter.setOptionComparator(null); // get options in the order they are created
495  formatter.printHelp("SQLImporter", options);
496  }

◆ main()

static void com.mapd.utility.SQLImporter.main ( String []  args)
inlinestatic

Definition at line 317 of file SQLImporter.java.

References com.mapd.utility.SQLImporter.doWork().

317  {
318  SQLImporter sq = new SQLImporter();
319  sq.doWork(args);
320  }
+ Here is the call graph for this function:

◆ resetBinaryColumn()

void com.mapd.utility.SQLImporter.resetBinaryColumn ( int  i,
ResultSetMetaData  md,
int  bufferSize,
TColumn  col 
) throws SQLException
inlineprivate

Definition at line 897 of file SQLImporter.java.

898  {
899  col.nulls.clear();
900 
901  switch (md.getColumnType(i)) {
902  case java.sql.Types.TINYINT:
903  case java.sql.Types.SMALLINT:
904  case java.sql.Types.INTEGER:
905  case java.sql.Types.BIGINT:
906  case java.sql.Types.TIME:
907  case java.sql.Types.TIMESTAMP:
908  case java.sql.Types
909  .BIT: // deal with postgress treating boolean as bit... this will bite me
910  case java.sql.Types.BOOLEAN:
911  case java.sql.Types.DATE:
912  case java.sql.Types.DECIMAL:
913  case java.sql.Types.NUMERIC:
914  col.data.int_col.clear();
915  break;
916 
917  case java.sql.Types.FLOAT:
918  case java.sql.Types.DOUBLE:
919  case java.sql.Types.REAL:
920  col.data.real_col.clear();
921  break;
922 
923  case java.sql.Types.NVARCHAR:
924  case java.sql.Types.VARCHAR:
925  case java.sql.Types.NCHAR:
926  case java.sql.Types.CHAR:
927  case java.sql.Types.LONGVARCHAR:
928  case java.sql.Types.LONGNVARCHAR:
929  col.data.str_col.clear();
930  break;
931 
932  // Handle WKT for geo columns
933  case java.sql.Types.OTHER:
934  col.data.str_col.clear();
935  break;
936 
937  default:
938  throw new AssertionError("Column type " + md.getColumnType(i) + " not Supported");
939  }
940  }

◆ run_init()

void com.mapd.utility.SQLImporter.run_init ( Connection  conn)
inlineprivate

Definition at line 464 of file SQLImporter.java.

References Experimental.String.

464  {
465  // attempt to open file
466  String line = "";
467  try {
468  BufferedReader reader =
469  new BufferedReader(new FileReader(cmd.getOptionValue("initializeFile")));
470  Statement stmt = conn.createStatement();
471  while ((line = reader.readLine()) != null) {
472  if (line.isEmpty()) {
473  continue;
474  }
475  LOGGER.info("Running : " + line);
476  stmt.execute(line);
477  }
478  stmt.close();
479  reader.close();
480  } catch (IOException e) {
481  LOGGER.error("Exception occurred trying to read initialize file: "
482  + cmd.getOptionValue("initFile"));
483  exit(1);
484  } catch (SQLException e) {
485  LOGGER.error(
486  "Exception occurred trying to execute initialize file entry : " + line);
487  exit(1);
488  }
489  }
static final Logger LOGGER

◆ setColValue()

void com.mapd.utility.SQLImporter.setColValue ( ResultSet  rs,
TColumn  col,
int  columnType,
int  colNum,
int  scale,
String  colTypeName 
) throws SQLException
inlineprivate

Definition at line 772 of file SQLImporter.java.

References Double, com.mapd.utility.db_vendors.Db_vendor_types.get_wkt(), com.mapd.utility.DateTimeUtils.getSecondsFromMilliseconds(), and Experimental.String.

777  {
778  switch (columnType) {
779  case java.sql.Types
780  .BIT: // deal with postgress treating boolean as bit... this will bite me
781  case java.sql.Types.BOOLEAN:
782  Boolean b = rs.getBoolean(colNum);
783  if (rs.wasNull()) {
784  col.nulls.add(Boolean.TRUE);
785  col.data.int_col.add(0L);
786  } else {
787  col.nulls.add(Boolean.FALSE);
788  col.data.int_col.add(b ? 1L : 0L);
789  }
790  break;
791 
792  case java.sql.Types.DECIMAL:
793  case java.sql.Types.NUMERIC:
794  BigDecimal bd = rs.getBigDecimal(colNum);
795  if (rs.wasNull()) {
796  col.nulls.add(Boolean.TRUE);
797  col.data.int_col.add(0L);
798  } else {
799  col.nulls.add(Boolean.FALSE);
800  col.data.int_col.add(bd.multiply(new BigDecimal(pow(10L, scale))).longValue());
801  }
802  break;
803 
804  case java.sql.Types.TINYINT:
805  case java.sql.Types.SMALLINT:
806  case java.sql.Types.INTEGER:
807  case java.sql.Types.BIGINT:
808  Long l = rs.getLong(colNum);
809  if (rs.wasNull()) {
810  col.nulls.add(Boolean.TRUE);
811  col.data.int_col.add(new Long(0));
812  } else {
813  col.nulls.add(Boolean.FALSE);
814  col.data.int_col.add(l);
815  }
816  break;
817 
818  case java.sql.Types.TIME:
819  Time t = rs.getTime(colNum);
820  if (rs.wasNull()) {
821  col.nulls.add(Boolean.TRUE);
822  col.data.int_col.add(0L);
823 
824  } else {
825  col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(t.getTime()));
826  col.nulls.add(Boolean.FALSE);
827  }
828 
829  break;
830  case java.sql.Types.TIMESTAMP:
831  Timestamp ts = rs.getTimestamp(colNum);
832  if (rs.wasNull()) {
833  col.nulls.add(Boolean.TRUE);
834  col.data.int_col.add(0L);
835 
836  } else {
837  col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(ts.getTime()));
838  col.nulls.add(Boolean.FALSE);
839  }
840 
841  break;
842  case java.sql.Types.DATE:
843  Date d = rs.getDate(colNum);
844  if (rs.wasNull()) {
845  col.nulls.add(Boolean.TRUE);
846  col.data.int_col.add(0L);
847 
848  } else {
849  col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(d.getTime()));
850  col.nulls.add(Boolean.FALSE);
851  }
852  break;
853  case java.sql.Types.FLOAT:
854  case java.sql.Types.DOUBLE:
855  case java.sql.Types.REAL:
856  Double db = rs.getDouble(colNum);
857  if (rs.wasNull()) {
858  col.nulls.add(Boolean.TRUE);
859  col.data.real_col.add(new Double(0));
860 
861  } else {
862  col.nulls.add(Boolean.FALSE);
863  col.data.real_col.add(db);
864  }
865  break;
866 
867  case java.sql.Types.NVARCHAR:
868  case java.sql.Types.VARCHAR:
869  case java.sql.Types.NCHAR:
870  case java.sql.Types.CHAR:
871  case java.sql.Types.LONGVARCHAR:
872  case java.sql.Types.LONGNVARCHAR:
873  String strVal = rs.getString(colNum);
874  if (rs.wasNull()) {
875  col.nulls.add(Boolean.TRUE);
876  col.data.str_col.add("");
877 
878  } else {
879  col.data.str_col.add(strVal);
880  col.nulls.add(Boolean.FALSE);
881  }
882  break;
883  case java.sql.Types.OTHER:
884  if (rs.wasNull()) {
885  col.nulls.add(Boolean.TRUE);
886  col.data.str_col.add("");
887  } else {
888  col.data.str_col.add(vendor_types.get_wkt(rs, colNum, colTypeName));
889  col.nulls.add(Boolean.FALSE);
890  }
891  break;
892  default:
893  throw new AssertionError("Column type " + columnType + " not Supported");
894  }
895  }
abstract String get_wkt(ResultSet rs, int column_number, String gis_type_name)
long getSecondsFromMilliseconds(long milliseconds)
+ Here is the call graph for this function:

◆ setupBinaryColumn()

TColumn com.mapd.utility.SQLImporter.setupBinaryColumn ( int  i,
ResultSetMetaData  md,
int  bufferSize 
) throws SQLException
inlineprivate

Definition at line 726 of file SQLImporter.java.

727  {
728  TColumn col = new TColumn();
729 
730  col.nulls = new ArrayList<Boolean>(bufferSize);
731 
732  col.data = new TColumnData();
733 
734  switch (md.getColumnType(i)) {
735  case java.sql.Types.TINYINT:
736  case java.sql.Types.SMALLINT:
737  case java.sql.Types.INTEGER:
738  case java.sql.Types.BIGINT:
739  case java.sql.Types.TIME:
740  case java.sql.Types.TIMESTAMP:
741  case java.sql.Types
742  .BIT: // deal with postgress treating boolean as bit... this will bite me
743  case java.sql.Types.BOOLEAN:
744  case java.sql.Types.DATE:
745  case java.sql.Types.DECIMAL:
746  case java.sql.Types.NUMERIC:
747  col.data.int_col = new ArrayList<Long>(bufferSize);
748  break;
749 
750  case java.sql.Types.FLOAT:
751  case java.sql.Types.DOUBLE:
752  case java.sql.Types.REAL:
753  col.data.real_col = new ArrayList<Double>(bufferSize);
754  break;
755 
756  case java.sql.Types.NVARCHAR:
757  case java.sql.Types.VARCHAR:
758  case java.sql.Types.NCHAR:
759  case java.sql.Types.CHAR:
760  case java.sql.Types.LONGVARCHAR:
761  case java.sql.Types.LONGNVARCHAR:
762  case java.sql.Types.OTHER:
763  col.data.str_col = new ArrayList<String>(bufferSize);
764  break;
765 
766  default:
767  throw new AssertionError("Column type " + md.getColumnType(i) + " not Supported");
768  }
769  return col;
770  }

◆ tableExists()

boolean com.mapd.utility.SQLImporter.tableExists ( String  tName)
inlineprivate

Definition at line 643 of file SQLImporter.java.

References Experimental.String.

643  {
644  LOGGER.debug("Check for table " + tName);
645  try {
646  List<String> recv_get_tables = client.get_tables(session);
647  for (String s : recv_get_tables) {
648  if (s.equals(tName)) {
649  return true;
650  }
651  }
652  } catch (TMapDException ex) {
653  LOGGER.error("Table check failed - " + ex.toString());
654  exit(3);
655  } catch (TException ex) {
656  LOGGER.error("Table check failed - " + ex.toString());
657  exit(3);
658  }
659  return false;
660  }
static final Logger LOGGER

Member Data Documentation

◆ client

MapD.Client com.mapd.utility.SQLImporter.client = null
protected

Definition at line 308 of file SQLImporter.java.

◆ cmd

CommandLine com.mapd.utility.SQLImporter.cmd = null
private

Definition at line 309 of file SQLImporter.java.

◆ dateTimeUtils

DateTimeUtils com.mapd.utility.SQLImporter.dateTimeUtils
private
Initial value:
= (milliseconds) -> {
return milliseconds / 1000;
}

Definition at line 311 of file SQLImporter.java.

◆ LOGGER

final Logger com.mapd.utility.SQLImporter.LOGGER = LoggerFactory.getLogger(SQLImporter.class)
staticpackage

Definition at line 310 of file SQLImporter.java.

◆ session

String com.mapd.utility.SQLImporter.session = null
protected

Definition at line 307 of file SQLImporter.java.

◆ vendor_types

Db_vendor_types com.mapd.utility.SQLImporter.vendor_types = null
package

Definition at line 315 of file SQLImporter.java.


The documentation for this class was generated from the following file: