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.

                              {
    createMapDConnection();
    String tName = cmd.getOptionValue("targetTable");

    if (tableExists(tName)) {
      // check if we want to truncate
      if (cmd.hasOption("truncate")) {
        executeMapDCommand("Drop table " + tName);
        createMapDTable(otherdb_conn, md);
      } else {
        List<TColumnType> columnInfo = getColumnInfo(tName);
        // table exists lets check it has same number of columns

        if (md.getColumnCount() != columnInfo.size()) {
          LOGGER.error("Table sizes do not match - OmniSci " + columnInfo.size()
                  + " versus Select " + md.getColumnCount());
          exit(1);
        }
        // table exists lets check it is same layout - check names will do for now
        // Note weird start from 1 and reduce index by one is due to sql metatdata
        // beinging with 1 not 0
        for (int colNum = 1; colNum <= columnInfo.size(); colNum++) {
          if (!columnInfo.get(colNum - 1)
                          .col_name.equalsIgnoreCase(md.getColumnName(colNum))) {
            LOGGER.error(
                    "OmniSci Table does not have matching column in same order for column number"
                    + colNum + " OmniSci column name is "
                    + columnInfo.get(colNum - 1).col_name + " versus Select "
                    + md.getColumnName(colNum));
            exit(1);
          }
        }
      }
    } else {
      createMapDTable(otherdb_conn, md);
    }
  }

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.

                                      {
    TTransport transport = null;
    TProtocol protocol = new TBinaryProtocol(transport);
    int port = Integer.valueOf(cmd.getOptionValue("port", "6274"));
    String server = cmd.getOptionValue("server", "localhost");
    try {
      // Uses default certificate stores.
      boolean load_trust_store = cmd.hasOption("https");
      SockTransportProperties skT = null;
      if (cmd.hasOption("https")) {
        skT = SockTransportProperties.getEncryptedClientDefaultTrustStore(
                !cmd.hasOption("insecure"));
        transport = skT.openHttpsClientTransport(server, port);
        transport.open();
        protocol = new TJSONProtocol(transport);
      } else if (cmd.hasOption("http")) {
        skT = SockTransportProperties.getUnencryptedClient();
        transport = skT.openHttpClientTransport(server, port);
        protocol = new TJSONProtocol(transport);
      } else {
        skT = SockTransportProperties.getUnencryptedClient();
        transport = skT.openClientTransport(server, port);
        transport.open();
        protocol = new TBinaryProtocol(transport);
      }

      client = new MapD.Client(protocol);
      // This if will be useless until PKI signon
      if (cmd.hasOption("user")) {
        session = client.connect(cmd.getOptionValue("user", "admin"),
                cmd.getOptionValue("passwd", "HyperInteractive"),
                cmd.getOptionValue("database", "omnisci"));
      }
      LOGGER.debug("Connected session is " + session);

    } catch (TTransportException ex) {
      LOGGER.error("Connection failed - " + ex.toString());
      exit(1);
    } catch (TMapDException ex) {
      LOGGER.error("Connection failed - " + ex.toString());
      exit(2);
    } catch (TException ex) {
      LOGGER.error("Connection failed - " + ex.toString());
      exit(3);
    } catch (Exception ex) {
      LOGGER.error("General exception - " + ex.toString());
      exit(4);
    }
  }

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.

                                                                                    {
    StringBuilder sb = new StringBuilder();
    sb.append("Create table ").append(cmd.getOptionValue("targetTable")).append("(");

    // Now iterate the metadata
    try {
      for (int i = 1; i <= metaData.getColumnCount(); i++) {
        if (i > 1) {
          sb.append(",");
        }
        LOGGER.debug("Column name is " + metaData.getColumnName(i));
        LOGGER.debug("Column type is " + metaData.getColumnTypeName(i));
        LOGGER.debug("Column type is " + metaData.getColumnType(i));

        sb.append(metaData.getColumnName(i)).append(" ");
        int col_type = metaData.getColumnType(i);
        if (col_type == java.sql.Types.OTHER) {
          sb.append(vendor_types.find_gis_type(otherdb_conn, metaData, i));
        } else {
          sb.append(getColType(metaData.getColumnType(i),
                  metaData.getPrecision(i),
                  metaData.getScale(i)));
        }
      }
      sb.append(")");

      if (Integer.valueOf(cmd.getOptionValue("fragmentSize", "0")) > 0) {
        sb.append(" with (fragment_size = ");
        sb.append(cmd.getOptionValue("fragmentSize", "0"));
        sb.append(")");
      }

    } catch (SQLException ex) {
      LOGGER.error("Error processing the metadata - " + ex.toString());
      exit(1);
    }

    executeMapDCommand(sb.toString());
  }

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().

                             {
    // create Options object

    SQLImporter_args s_args = new SQLImporter_args();

    try {
      cmd = s_args.parse(args);
    } catch (ParseException ex) {
      LOGGER.error(ex.getLocalizedMessage());
      s_args.printHelpMessage();
      exit(0);
    }
    executeQuery();
  }

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.

                                              {
    LOGGER.info(" run comamnd :" + sql);

    try {
      TQueryResult sqlResult = client.sql_execute(session, sql + ";", true, null, -1, -1);
    } catch (TMapDException ex) {
      LOGGER.error("SQL Execute failed - " + ex.toString());
      exit(1);
    } catch (TException ex) {
      LOGGER.error("SQL Execute failed - " + ex.toString());
      exit(1);
    }
  }

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.

                      {
    Connection conn = null;
    Statement stmt = null;

    long totalTime = 0;

    try {
      // Open a connection
      LOGGER.info("Connecting to database url :" + cmd.getOptionValue("jdbcConnect"));
      conn = DriverManager.getConnection(cmd.getOptionValue("jdbcConnect"),
              cmd.getOptionValue("sourceUser"),
              cmd.getOptionValue("sourcePasswd"));
      vendor_types = Db_vendor_types.Db_vendor_factory(cmd.getOptionValue("jdbcConnect"));
      long startTime = System.currentTimeMillis();

      // run init file script on targe DB if present
      if (cmd.hasOption("initializeFile")) {
        run_init(conn);
      }

      // set autocommit off to allow postgress to not load all results
      try {
        conn.setAutoCommit(false);
      } catch (SQLException se) {
        LOGGER.warn(
                "SQLException when attempting to setAutoCommit to false, jdbc driver probably doesnt support it.  Error is "
                + se.toString());
      }

      // Execute a query
      stmt = conn.createStatement();

      int bufferSize = Integer.valueOf(cmd.getOptionValue("bufferSize", "10000"));
      // set the jdbc fetch buffer size to reduce the amount of records being moved to
      // java from postgress
      stmt.setFetchSize(bufferSize);
      long timer;

      ResultSet rs = stmt.executeQuery(cmd.getOptionValue("sqlStmt"));

      // check if table already exists and is compatible in OmniSci with the query
      // metadata
      ResultSetMetaData md = rs.getMetaData();
      checkMapDTable(conn, md);

      timer = System.currentTimeMillis();

      long resultCount = 0;
      int bufferCount = 0;
      long total = 0;

      List<TColumn> cols = new ArrayList(md.getColumnCount());
      for (int i = 1; i <= md.getColumnCount(); i++) {
        TColumn col = setupBinaryColumn(i, md, bufferSize);
        cols.add(col);
      }

      // read data from old DB
      while (rs.next()) {
        for (int i = 1; i <= md.getColumnCount(); i++) {
          setColValue(rs,
                  cols.get(i - 1),
                  md.getColumnType(i),
                  i,
                  md.getScale(i),
                  md.getColumnTypeName(i));
        }
        resultCount++;
        bufferCount++;
        if (bufferCount == bufferSize) {
          bufferCount = 0;
          // send the buffer to mapD
          client.load_table_binary_columnar(
                  session, cmd.getOptionValue("targetTable"), cols); // old
          // recreate columnar store for use
          for (int i = 1; i <= md.getColumnCount(); i++) {
            resetBinaryColumn(i, md, bufferSize, cols.get(i - 1));
          }

          if (resultCount % 100000 == 0) {
            LOGGER.info("Imported " + resultCount + " records");
          }
        }
      }
      if (bufferCount > 0) {
        // send the LAST buffer to mapD
        client.load_table_binary_columnar(
                session, cmd.getOptionValue("targetTable"), cols);
        bufferCount = 0;
      }
      LOGGER.info("result set count is " + resultCount + " read time is "
              + (System.currentTimeMillis() - timer) + "ms");

      // Clean-up environment
      rs.close();
      stmt.close();

      totalTime = System.currentTimeMillis() - startTime;
      conn.close();
    } catch (SQLException se) {
      LOGGER.error("SQLException - " + se.toString());
      se.printStackTrace();
    } catch (TMapDException ex) {
      LOGGER.error("TMapDException - " + ex.toString());
      ex.printStackTrace();
    } catch (TException ex) {
      LOGGER.error("TException failed - " + ex.toString());
      ex.printStackTrace();
    } finally {
      // finally block used to close resources
      try {
        if (stmt != null) {
          stmt.close();
        }
      } catch (SQLException se2) {
      } // nothing we can do
      try {
        if (conn != null) {
          conn.close();
        }
      } catch (SQLException se) {
        LOGGER.error("SQlException in close - " + se.toString());
        se.printStackTrace();
      } // end finally try
    } // end try
  }

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.

                                                                 {
    // Note - if cType is OTHER a earlier call will have been made
    // to try and work out the db vendors specific type.
    if (precision > 19) {
      precision = 19;
    }
    if (scale > 19) {
      scale = 18;
    }
    switch (cType) {
      case java.sql.Types.TINYINT:
        return ("TINYINT");
      case java.sql.Types.SMALLINT:
        return ("SMALLINT");
      case java.sql.Types.INTEGER:
        return ("INTEGER");
      case java.sql.Types.BIGINT:
        return ("BIGINT");
      case java.sql.Types.FLOAT:
        return ("FLOAT");
      case java.sql.Types.DECIMAL:
        return ("DECIMAL(" + precision + "," + scale + ")");
      case java.sql.Types.DOUBLE:
        return ("DOUBLE");
      case java.sql.Types.REAL:
        return ("REAL");
      case java.sql.Types.NUMERIC:
        return ("NUMERIC(" + precision + "," + scale + ")");
      case java.sql.Types.TIME:
        return ("TIME");
      case java.sql.Types.TIMESTAMP:
        return ("TIMESTAMP");
      case java.sql.Types.DATE:
        return ("DATE");
      case java.sql.Types.BOOLEAN:
      case java.sql.Types
              .BIT: // deal with postgress treating boolean as bit... this will bite me
        return ("BOOLEAN");
      case java.sql.Types.NVARCHAR:
      case java.sql.Types.VARCHAR:
      case java.sql.Types.NCHAR:
      case java.sql.Types.CHAR:
      case java.sql.Types.LONGVARCHAR:
      case java.sql.Types.LONGNVARCHAR:
        return ("TEXT ENCODING DICT");
      default:
        throw new AssertionError("Column type " + cType + " not Supported");
    }
  }

getColumnInfo()

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

inlineprivate

Definition at line 627 of file SQLImporter.java.

                                                        {
    LOGGER.debug("Getting columns for  " + tName);
    List<TColumnType> row_descriptor = null;
    try {
      TTableDetails table_details = client.get_table_details(session, tName);
      row_descriptor = table_details.row_desc;
    } catch (TMapDException ex) {
      LOGGER.error("column check failed - " + ex.toString());
      exit(3);
    } catch (TException ex) {
      LOGGER.error("column check failed - " + ex.toString());
      exit(3);
    }
    return row_descriptor;
  }

help()

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

inlineprivate

Definition at line 491 of file SQLImporter.java.

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

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().

                                         {
    SQLImporter sq = new SQLImporter();
    sq.doWork(args);
  }

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.

                              {
    col.nulls.clear();

    switch (md.getColumnType(i)) {
      case java.sql.Types.TINYINT:
      case java.sql.Types.SMALLINT:
      case java.sql.Types.INTEGER:
      case java.sql.Types.BIGINT:
      case java.sql.Types.TIME:
      case java.sql.Types.TIMESTAMP:
      case java.sql.Types
              .BIT: // deal with postgress treating boolean as bit... this will bite me
      case java.sql.Types.BOOLEAN:
      case java.sql.Types.DATE:
      case java.sql.Types.DECIMAL:
      case java.sql.Types.NUMERIC:
        col.data.int_col.clear();
        break;

      case java.sql.Types.FLOAT:
      case java.sql.Types.DOUBLE:
      case java.sql.Types.REAL:
        col.data.real_col.clear();
        break;

      case java.sql.Types.NVARCHAR:
      case java.sql.Types.VARCHAR:
      case java.sql.Types.NCHAR:
      case java.sql.Types.CHAR:
      case java.sql.Types.LONGVARCHAR:
      case java.sql.Types.LONGNVARCHAR:
        col.data.str_col.clear();
        break;

      // Handle WKT for geo columns
      case java.sql.Types.OTHER:
        col.data.str_col.clear();
        break;

      default:
        throw new AssertionError("Column type " + md.getColumnType(i) + " not Supported");
    }
  }

run_init()

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

inlineprivate

Definition at line 464 of file SQLImporter.java.

References Experimental.String.

                                         {
    // attempt to open file
    String line = "";
    try {
      BufferedReader reader =
              new BufferedReader(new FileReader(cmd.getOptionValue("initializeFile")));
      Statement stmt = conn.createStatement();
      while ((line = reader.readLine()) != null) {
        if (line.isEmpty()) {
          continue;
        }
        LOGGER.info("Running : " + line);
        stmt.execute(line);
      }
      stmt.close();
      reader.close();
    } catch (IOException e) {
      LOGGER.error("Exception occurred trying to read initialize file: "
              + cmd.getOptionValue("initFile"));
      exit(1);
    } catch (SQLException e) {
      LOGGER.error(
              "Exception occurred trying to execute initialize file entry : " + line);
      exit(1);
    }
  }

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.

                                                  {
    switch (columnType) {
      case java.sql.Types
              .BIT: // deal with postgress treating boolean as bit... this will bite me
      case java.sql.Types.BOOLEAN:
        Boolean b = rs.getBoolean(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.int_col.add(0L);
        } else {
          col.nulls.add(Boolean.FALSE);
          col.data.int_col.add(b ? 1L : 0L);
        }
        break;

      case java.sql.Types.DECIMAL:
      case java.sql.Types.NUMERIC:
        BigDecimal bd = rs.getBigDecimal(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.int_col.add(0L);
        } else {
          col.nulls.add(Boolean.FALSE);
          col.data.int_col.add(bd.multiply(new BigDecimal(pow(10L, scale))).longValue());
        }
        break;

      case java.sql.Types.TINYINT:
      case java.sql.Types.SMALLINT:
      case java.sql.Types.INTEGER:
      case java.sql.Types.BIGINT:
        Long l = rs.getLong(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.int_col.add(new Long(0));
        } else {
          col.nulls.add(Boolean.FALSE);
          col.data.int_col.add(l);
        }
        break;

      case java.sql.Types.TIME:
        Time t = rs.getTime(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.int_col.add(0L);

        } else {
          col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(t.getTime()));
          col.nulls.add(Boolean.FALSE);
        }

        break;
      case java.sql.Types.TIMESTAMP:
        Timestamp ts = rs.getTimestamp(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.int_col.add(0L);

        } else {
          col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(ts.getTime()));
          col.nulls.add(Boolean.FALSE);
        }

        break;
      case java.sql.Types.DATE:
        Date d = rs.getDate(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.int_col.add(0L);

        } else {
          col.data.int_col.add(dateTimeUtils.getSecondsFromMilliseconds(d.getTime()));
          col.nulls.add(Boolean.FALSE);
        }
        break;
      case java.sql.Types.FLOAT:
      case java.sql.Types.DOUBLE:
      case java.sql.Types.REAL:
        Double db = rs.getDouble(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.real_col.add(new Double(0));

        } else {
          col.nulls.add(Boolean.FALSE);
          col.data.real_col.add(db);
        }
        break;

      case java.sql.Types.NVARCHAR:
      case java.sql.Types.VARCHAR:
      case java.sql.Types.NCHAR:
      case java.sql.Types.CHAR:
      case java.sql.Types.LONGVARCHAR:
      case java.sql.Types.LONGNVARCHAR:
        String strVal = rs.getString(colNum);
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.str_col.add("");

        } else {
          col.data.str_col.add(strVal);
          col.nulls.add(Boolean.FALSE);
        }
        break;
      case java.sql.Types.OTHER:
        if (rs.wasNull()) {
          col.nulls.add(Boolean.TRUE);
          col.data.str_col.add("");
        } else {
          col.data.str_col.add(vendor_types.get_wkt(rs, colNum, colTypeName));
          col.nulls.add(Boolean.FALSE);
        }
        break;
      default:
        throw new AssertionError("Column type " + columnType + " not Supported");
    }
  }

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.

                              {
    TColumn col = new TColumn();

    col.nulls = new ArrayList<Boolean>(bufferSize);

    col.data = new TColumnData();

    switch (md.getColumnType(i)) {
      case java.sql.Types.TINYINT:
      case java.sql.Types.SMALLINT:
      case java.sql.Types.INTEGER:
      case java.sql.Types.BIGINT:
      case java.sql.Types.TIME:
      case java.sql.Types.TIMESTAMP:
      case java.sql.Types
              .BIT: // deal with postgress treating boolean as bit... this will bite me
      case java.sql.Types.BOOLEAN:
      case java.sql.Types.DATE:
      case java.sql.Types.DECIMAL:
      case java.sql.Types.NUMERIC:
        col.data.int_col = new ArrayList<Long>(bufferSize);
        break;

      case java.sql.Types.FLOAT:
      case java.sql.Types.DOUBLE:
      case java.sql.Types.REAL:
        col.data.real_col = new ArrayList<Double>(bufferSize);
        break;

      case java.sql.Types.NVARCHAR:
      case java.sql.Types.VARCHAR:
      case java.sql.Types.NCHAR:
      case java.sql.Types.CHAR:
      case java.sql.Types.LONGVARCHAR:
      case java.sql.Types.LONGNVARCHAR:
      case java.sql.Types.OTHER:
        col.data.str_col = new ArrayList<String>(bufferSize);
        break;

      default:
        throw new AssertionError("Column type " + md.getColumnType(i) + " not Supported");
    }
    return col;
  }

tableExists()

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

inlineprivate

Definition at line 643 of file SQLImporter.java.

References Experimental.String.

                                            {
    LOGGER.debug("Check for table " + tName);
    try {
      List<String> recv_get_tables = client.get_tables(session);
      for (String s : recv_get_tables) {
        if (s.equals(tName)) {
          return true;
        }
      }
    } catch (TMapDException ex) {
      LOGGER.error("Table check failed - " + ex.toString());
      exit(3);
    } catch (TException ex) {
      LOGGER.error("Table check failed - " + ex.toString());
      exit(3);
    }
    return false;
  }

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:

• /home/jenkins-slave/workspace/core-os-doxygen/java/utility/src/main/java/com/mapd/utility/SQLImporter.java