Esempio n. 1
0
 public int[] findEntityIds(Map<String, String> publicMetadata, String[] wildcardFields)
     throws RemoteException {
   int[] ids =
       ListUtils.toIntArray(getDataConfig().searchPublicMetadata(publicMetadata, wildcardFields));
   Arrays.sort(ids);
   return ids;
 }
Esempio n. 2
0
  public WeaveRecordList getRows(String keyType, String[] keysArray) throws RemoteException {
    DataConfig dataConfig = getDataConfig();

    DataEntityMetadata params = new DataEntityMetadata();
    params.setPublicValues(
        PublicMetadata.ENTITYTYPE, EntityType.COLUMN, PublicMetadata.KEYTYPE, keyType);
    List<Integer> columnIds =
        new ArrayList<Integer>(dataConfig.searchPublicMetadata(params.publicMetadata, null));

    if (columnIds.size() > MAX_COLUMN_REQUEST_COUNT)
      columnIds = columnIds.subList(0, MAX_COLUMN_REQUEST_COUNT);
    return DataService.getFilteredRows(ListUtils.toIntArray(columnIds), null, keysArray);
  }
Esempio n. 3
0
  @SuppressWarnings({"rawtypes", "unchecked"})
  private Object[] getParamsFromMap(String methodName, Map params) {
    ExposedMethod exposedMethod = methodMap.get(methodName);
    String[] argNames = exposedMethod.paramNames;
    Class[] argTypes = exposedMethod.method.getParameterTypes();
    Object[] argValues = new Object[argTypes.length];

    Map extraParameters = null; // parameters that weren't mapped directly to method arguments

    // For each method parameter, get the corresponding url parameter value.
    if (argNames != null && params != null) {
      // TODO: check why params is null
      for (Object parameterName : params.keySet()) {
        Object parameterValue = params.get(parameterName);
        int index = ListUtils.findString((String) parameterName, argNames);
        if (index >= 0) {
          argValues[index] = parameterValue;
        } else if (!parameterName.equals(METHOD)) {
          if (extraParameters == null) extraParameters = new HashMap();
          extraParameters.put(parameterName, parameterValue);
        }
      }
    }

    // support for a function having a single Map<String,String> parameter
    // see if we can find a Map arg.  If so, set it to extraParameters
    if (argTypes != null) {
      for (int i = 0; i < argTypes.length; i++) {
        if (argTypes[i] == Map.class && argValues[i] == null) {
          // avoid passing a null Map to the function
          if (extraParameters == null) extraParameters = new HashMap<String, String>();
          argValues[i] = extraParameters;
          extraParameters = null;
          break;
        }
      }
    }
    if (extraParameters != null) {
      System.out.println("Received servlet request: " + methodToString(methodName, argValues));
      System.out.println("Unused parameters: " + extraParameters.entrySet());
    }

    return argValues;
  }
Esempio n. 4
0
 /**
  * Use getEntities() instead. This function is provided for backwards compatibility only.
  *
  * @deprecated
  */
 @Deprecated
 public int[] getEntityChildIds(int parentId) throws RemoteException {
   return ListUtils.toIntArray(getDataConfig().getChildIds(parentId));
 }
Esempio n. 5
0
  /**
   * @param metadata The metadata query.
   * @return The id of the matching column.
   * @throws RemoteException Thrown if the metadata query does not match exactly one column.
   */
  @Deprecated
  public AttributeColumnData getColumnFromMetadata(Map<String, String> metadata)
      throws RemoteException {
    if (metadata == null || metadata.size() == 0)
      throw new RemoteException("No metadata query parameters specified.");

    metadata.put(PublicMetadata.ENTITYTYPE, EntityType.COLUMN);

    final String DATATABLE = "dataTable";
    final String NAME = "name";

    // exclude these parameters from the query
    if (metadata.containsKey(NAME)) metadata.remove(PublicMetadata.TITLE);
    String minStr = metadata.remove(PublicMetadata.MIN);
    String maxStr = metadata.remove(PublicMetadata.MAX);
    String paramsStr = metadata.remove(PrivateMetadata.SQLPARAMS);

    DataConfig dataConfig = getDataConfig();

    Collection<Integer> ids = dataConfig.searchPublicMetadata(metadata, null);

    // attempt recovery for backwards compatibility
    if (ids.size() == 0) {
      if (metadata.containsKey(DATATABLE) && metadata.containsKey(NAME)) {
        // try to find columns sqlTable==dataTable and sqlColumn=name
        Map<String, String> privateMetadata = new HashMap<String, String>();
        String sqlTable = metadata.get(DATATABLE);
        String sqlColumn = metadata.get(NAME);
        for (int i = 0; i < 2; i++) {
          if (i == 1) sqlTable = sqlTable.toLowerCase();
          privateMetadata.put(PrivateMetadata.SQLTABLE, sqlTable);
          privateMetadata.put(PrivateMetadata.SQLCOLUMN, sqlColumn);
          ids = dataConfig.searchPrivateMetadata(privateMetadata, null);
          if (ids.size() > 0) break;
        }
      } else if (metadata.containsKey(NAME)
          && Strings.equal(metadata.get(PublicMetadata.DATATYPE), DataType.GEOMETRY)) {
        metadata.put(PublicMetadata.TITLE, metadata.remove(NAME));
        ids = dataConfig.searchPublicMetadata(metadata, null);
      }
      if (ids.size() == 0)
        throw new RemoteException("No column matches metadata query: " + metadata);
    }

    // warning if more than one column
    if (ids.size() > 1) {
      String message =
          String.format(
              "WARNING: Multiple columns (%s) match metadata query: %s", ids.size(), metadata);
      System.err.println(message);
      // throw new RemoteException(message);
    }

    // return first column
    int id = ListUtils.getFirstSortedItem(ids, DataConfig.NULL);
    double min = Double.NaN, max = Double.NaN;
    try {
      min = (Double) cast(minStr, double.class);
    } catch (Throwable t) {
    }
    try {
      max = (Double) cast(maxStr, double.class);
    } catch (Throwable t) {
    }
    String[] sqlParams = CSVParser.defaultParser.parseCSVRow(paramsStr, true);
    return getColumn(id, min, max, sqlParams);
  }
Esempio n. 6
0
 /**
  * Use getEntities() instead. This function is provided for backwards compatibility only.
  *
  * @deprecated
  */
 @Deprecated
 public int[] getParents(int childId) throws RemoteException {
   int[] ids = ListUtils.toIntArray(getDataConfig().getParentIds(childId));
   Arrays.sort(ids);
   return ids;
 }
Esempio n. 7
0
  /**
   * Tries to convert value to the given type
   *
   * @param value
   * @param type
   * @return value which may have been cast as the new type
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  protected Object cast(Object value, Class<?> type) {
    if (value == null) {
      if (type == double.class || type == Double.class) value = Double.NaN;
      else if (type == float.class || type == Float.class) value = Float.NaN;
    } else if (value instanceof String) {
      try {
        if (type == int.class || type == Integer.class) {
          value = Integer.parseInt((String) value);
        } else if (type == float.class || type == Float.class) {
          value = Float.parseFloat((String) value);
        } else if (type == double.class || type == Double.class) {
          value = Double.parseDouble((String) value);
        } else if (type == boolean.class || type == Boolean.class) {
          // value = Boolean.parseBoolean((String)value);
          value = ((String) (value)).equalsIgnoreCase("true");
        } else if (type.isArray() || type == List.class) {
          String[][] table = CSVParser.defaultParser.parseCSV((String) value, true);
          if (table.length == 0) value = new String[0]; // empty
          else value = table[0]; // first row

          if (type == List.class) value = Arrays.asList((String[]) value);
          else value = cast(value, type);
        } else if (type == InputStream.class) {
          try {
            String temp = (String) value;
            value = (InputStream) new ByteArrayInputStream(temp.getBytes("UTF-8"));
          } catch (Exception e) {
            return null;
          }
        }
      } catch (NumberFormatException e) {
        // if number parsing fails, leave the original value untouched
      }
    } else if (value instanceof Boolean && type == boolean.class) {
      value = (boolean) (Boolean) value;
    } else if (value.getClass() == ArrayList.class) {
      value = cast(((ArrayList) value).toArray(), type);
    } else if (value.getClass().isArray()) {
      Object[] valueArray = (Object[]) value;
      if (type == List.class) {
        value = ListUtils.copyArrayToList(valueArray, new Vector());
      } else if (type == Object[][].class) {
        Object[][] valueMatrix = new Object[valueArray.length][];
        for (int i = 0; i < valueArray.length; i++) {
          valueMatrix[i] = (Object[]) valueArray[i];
        }
        value = valueMatrix;
      } else if (type == String[][].class) {
        String[][] valueMatrix = new String[valueArray.length][];
        for (int i = 0; i < valueArray.length; i++) {
          // cast Objects to Strings
          Object[] objectArray = (Object[]) valueArray[i];
          valueMatrix[i] = ListUtils.copyStringArray(objectArray, new String[objectArray.length]);
        }
        value = valueMatrix;
      } else if (type == String[].class) {
        value = ListUtils.copyStringArray(valueArray, new String[valueArray.length]);
      } else if (type == double[][].class) {
        double[][] valueMatrix = new double[valueArray.length][];
        for (int i = 0; i < valueArray.length; i++) {
          // cast Objects to doubles
          Object[] objectArray = (Object[]) valueArray[i];
          valueMatrix[i] = ListUtils.copyDoubleArray(objectArray, new double[objectArray.length]);
        }
        value = valueMatrix;
      } else if (type == double[].class) {
        value = ListUtils.copyDoubleArray(valueArray, new double[valueArray.length]);
      } else if (type == int[][].class) {
        int[][] valueMatrix = new int[valueArray.length][];
        for (int i = 0; i < valueArray.length; i++) {
          // cast Objects to doubles
          Object[] objectArray = (Object[]) valueArray[i];
          valueMatrix[i] = ListUtils.copyIntegerArray(objectArray, new int[objectArray.length]);
        }
        value = valueMatrix;
      } else if (type == int[].class) {
        value = ListUtils.copyIntegerArray(valueArray, new int[valueArray.length]);
      }
    } else if (value instanceof Number) {
      if (type == int.class || type == Integer.class) {
        value = ((Number) value).intValue();
      } else if (type == double.class || type == Double.class) {
        value = ((Number) value).doubleValue();
      } else if (type == float.class || type == Float.class) {
        value = ((Number) value).floatValue();
      }
    }
    return value;
  }