コード例 #1
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Builds a sequence of elements from a query's result set.
  *
  * @param rs result set
  * @return sequence of elements <tuple/> each of which represents a row from the result set
  * @throws QueryException query exception
  */
 private NodeCache buildResult(final ResultSet rs) throws QueryException {
   try {
     final ResultSetMetaData metadata = rs.getMetaData();
     final int columnCount = metadata.getColumnCount();
     final NodeCache rows = new NodeCache();
     while (rs.next()) {
       final NodeCache columns = new NodeCache();
       for (int k = 1; k <= columnCount; k++) {
         // For each row add column values as children
         final String label = metadata.getColumnLabel(k);
         final Object value = rs.getObject(label);
         // Null values are ignored
         if (value != null) {
           // Column name
           final FAttr columnName = new FAttr(Q_NAME, token(label));
           final NodeCache attr = new NodeCache();
           attr.add(columnName);
           // Column value
           final FTxt columnValue = new FTxt(token(value.toString()));
           final NodeCache ch = new NodeCache();
           ch.add(columnValue);
           // Element <sql:column name='...'>...</sql:column>
           columns.add(new FElem(Q_COLUMN, ch, attr, NS_SQL, null));
         }
       }
       rows.add(new FElem(Q_ROW, columns, null, NS_SQL, null));
     }
     return rows;
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   }
 }
コード例 #2
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Establishes a connection to a relational database.
  *
  * @param ctx query context
  * @return connection id
  * @throws QueryException query exception
  */
 private Itr connect(final QueryContext ctx) throws QueryException {
   // URL to relational database
   final String url = string(checkStr(expr[0], ctx));
   try {
     if (expr.length > 2) {
       // Credentials
       final String user = string(checkStr(expr[1], ctx));
       final String pass = string(checkStr(expr[2], ctx));
       if (expr.length == 4) {
         // Connection options
         final TokenObjMap<Object> options = options(3, E_OPS, ctx);
         boolean autoCommit = true;
         final Object commit = options.get(AUTO_COMM);
         if (commit != null) {
           // Extract auto-commit mode from options
           autoCommit = Boolean.parseBoolean(commit.toString());
           options.delete(AUTO_COMM);
         }
         // Connection properties
         final Properties props = connProps(options(3, E_OPS, ctx));
         props.setProperty(USER, user);
         props.setProperty(PASS, pass);
         // Open connection
         final Connection conn = getConnection(url, props);
         // Set auto/commit mode
         conn.setAutoCommit(autoCommit);
         return Itr.get(ctx.jdbc.add(conn));
       }
       return Itr.get(ctx.jdbc.add(getConnection(url, user, pass)));
     }
     return Itr.get(ctx.jdbc.add(getConnection(url)));
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   }
 }
コード例 #3
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Rollbacks all changes made during last transaction.
  *
  * @param ctx query context
  * @return {@code null}
  * @throws QueryException query exception
  */
 private Item rollback(final QueryContext ctx) throws QueryException {
   try {
     connection(ctx, false).rollback();
     return null;
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   }
 }
コード例 #4
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Closes a connection to a relational database.
  *
  * @param ctx query context
  * @return {@code null}
  * @throws QueryException query exception
  */
 private Item close(final QueryContext ctx) throws QueryException {
   try {
     connection(ctx, true).close();
     return null;
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   }
 }
コード例 #5
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Sets the parameter with the given index in a prepared statement.
  *
  * @param index parameter index
  * @param stmt prepared statement
  * @param paramType parameter type
  * @param value parameter value
  * @param isNull indicator if the parameter is null or not
  * @throws QueryException query exception
  */
 private void setParam(
     final int index,
     final PreparedStatement stmt,
     final byte[] paramType,
     final String value,
     final boolean isNull)
     throws QueryException {
   try {
     if (eq(BOOL, paramType)) {
       if (isNull) stmt.setNull(index, Types.BOOLEAN);
       else stmt.setBoolean(index, Boolean.parseBoolean(value));
     } else if (eq(DATE, paramType)) {
       if (isNull) stmt.setNull(index, Types.DATE);
       else stmt.setDate(index, Date.valueOf(value));
     } else if (eq(DOUBLE, paramType)) {
       if (isNull) stmt.setNull(index, Types.DOUBLE);
       else stmt.setDouble(index, Double.parseDouble(value));
     } else if (eq(FLOAT, paramType)) {
       if (isNull) stmt.setNull(index, Types.FLOAT);
       else stmt.setFloat(index, Float.parseFloat(value));
     } else if (eq(INT, paramType)) {
       if (isNull) stmt.setNull(index, Types.INTEGER);
       else stmt.setInt(index, Integer.parseInt(value));
     } else if (eq(SHORT, paramType)) {
       if (isNull) stmt.setNull(index, Types.SMALLINT);
       else stmt.setShort(index, Short.parseShort(value));
     } else if (eq(STRING, paramType)) {
       if (isNull) stmt.setNull(index, Types.VARCHAR);
       else stmt.setString(index, value);
     } else if (eq(TIME, paramType)) {
       if (isNull) stmt.setNull(index, Types.TIME);
       else stmt.setTime(index, Time.valueOf(value));
     } else if (eq(TIMESTAMP, paramType)) {
       if (isNull) stmt.setNull(index, Types.TIMESTAMP);
       else stmt.setTimestamp(index, Timestamp.valueOf(value));
     } else {
       throw SQLEXC.thrw(input, "unsupported type: " + string(paramType));
     }
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   } catch (final IllegalArgumentException ex) {
     throw ILLFORMAT.thrw(input, string(paramType));
   }
 }
コード例 #6
0
ファイル: FNSql.java プロジェクト: yzzo/basex
  /**
   * Executes a query or an update statement on a relational database.
   *
   * @param conn connection
   * @param ctx query context
   * @return result
   * @throws QueryException query exception
   */
  private NodeCache executeQuery(final Connection conn, final QueryContext ctx)
      throws QueryException {

    final String query = string(checkStr(ctx.iter(expr[1]).next(), ctx));
    try {
      final Statement stmt = conn.createStatement();
      final boolean result = stmt.execute(query);
      return result ? buildResult(stmt.getResultSet()) : new NodeCache();
    } catch (final SQLException ex) {
      throw SQLEXC.thrw(input, ex.getMessage());
    }
  }
コード例 #7
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Prepares a statement and returns its id.
  *
  * @param ctx query context
  * @return prepared statement id
  * @throws QueryException query exception
  */
 private Itr prepare(final QueryContext ctx) throws QueryException {
   final Connection conn = connection(ctx, false);
   // Prepared statement
   final byte[] prepStmt = checkStr(expr[1], ctx);
   try {
     // Keep prepared statement
     final PreparedStatement prep = conn.prepareStatement(string(prepStmt));
     return Itr.get(ctx.jdbc.add(prep));
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   }
 }
コード例 #8
0
ファイル: FNSql.java プロジェクト: yzzo/basex
 /**
  * Executes a prepared statement.
  *
  * @param stmt prepared statement
  * @param ctx query context
  * @return result
  * @throws QueryException query exception
  */
 private NodeCache executePrepStmt(final PreparedStatement stmt, final QueryContext ctx)
     throws QueryException {
   // Get parameters for prepared statement
   final ANode params = (ANode) checkType(expr[1].item(ctx, input), NodeType.ELM);
   if (!params.qname().eq(E_PARAMS)) PARWHICH.thrw(input, params.qname());
   try {
     final int placeCount = stmt.getParameterMetaData().getParameterCount();
     // Check if number of parameters equals number of place holders
     if (placeCount != countParams(params)) PARAMS.thrw(input);
     else setParameters(params.children(), stmt);
     final boolean result = stmt.execute();
     return result ? buildResult(stmt.getResultSet()) : new NodeCache();
   } catch (final SQLException ex) {
     throw SQLEXC.thrw(input, ex.getMessage());
   }
 }