public static Tuple<String, String> split(String strColumn, String pattern, String valueName) { String name = "split_" + random(); if (valueName == null) { return new Tuple(name, "def " + name + " = doc['" + strColumn + "'].value.split('" + pattern + "')" ); } else { return new Tuple(name, strColumn + "; def " + name + " = " + valueName + ".split('" + pattern + "')"); } }
private static Set<String> getChildItems(String parent, final Set<String> fields) { Set<String> children = Sets.newHashSet(); for (String field : fields) { if (field.startsWith(parent + ".")) { children.add(field.substring((parent + ".").length())); } else if (field.startsWith(parent)) { children.add(field); } } return children; }
private <T> Map getDefaultSettings(ElasticsearchPersistentEntity<T> persistentEntity) { if (persistentEntity.isUseServerConfiguration()) return new HashMap(); return new MapBuilder<String, String>().put("index.number_of_shards", String.valueOf(persistentEntity.getShards())) .put("index.number_of_replicas", String.valueOf(persistentEntity.getReplicas())) .put("index.refresh_interval", persistentEntity.getRefreshInterval()) .put("index.store.type", persistentEntity.getIndexStoreType()).map(); }
private void verifyFakeIndex() { ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetaData>> mappings = mappings(); MappingMetaData mapping = mappings.get("fakes").get("fake"); assertThat(mapping.type()).isEqualTo("fake"); assertThat(mapping.getSourceAsMap()).isNotEmpty(); assertThat(countMappingFields(mapping)).isEqualTo(2); assertThat(field(mapping, "updatedAt").get("type")).isEqualTo("date"); }
@Override public Settings getConfiguration(String configurationType) { Settings result = typeToConfig.get(configurationType); if (result != null) { return result; } Map<String, Tuple<Long, Settings>> loaded = loadConfigurations(Collections.singleton(configurationType), false); result = loaded.get(configurationType).v2(); return putSettingsToCache(configurationType, result); }
private BasicDBObject getFilterForInitialImport(BasicDBObject filter, String id) { Preconditions.checkNotNull(filter); if (id == null) { return filter; } BasicDBObject idFilter = new BasicDBObject(MongoDBRiver.MONGODB_ID_FIELD, new BasicBSONObject(QueryOperators.GT, id)); if (filter.equals(new BasicDBObject())) { return idFilter; } return new BasicDBObject(QueryOperators.AND, ImmutableList.of(filter, idFilter)); }
private Iterator<String> loadExistingIndices() { return es.client().nativeClient().admin().indices().prepareGetMappings().get().mappings().keysIt(); }
private static boolean clusterHas5xIndices(ClusterState state) { final Iterator<IndexMetaData> indices = state.metaData().indices().valuesIt(); for(;indices.hasNext();) { final IndexMetaData indexMetaData = indices.next(); if(indexMetaData.getCreationVersion().before(Version.V_6_0_0_alpha1)) { return true; } } return false; } }
private void updateIndexRefresh(String name, Object value) { esClient.admin().indices().prepareUpdateSettings(name).setSettings(ImmutableMap.of("index.refresh_interval", value)).get(); }
private static Tuple<String, String> mathSingleValueTemplate(String methodName, String fieldName, String strColumn, String valueName) { String name = fieldName + "_" + random(); if (valueName == null) { return new Tuple<>(name, "def " + name + " = " + methodName + "(doc['" + strColumn + "'].value)"); } else { return new Tuple<>(name, strColumn + ";def " + name + " = " + methodName + "(" + valueName + ")"); } }
public static Tuple<String, String> strSingleValueTemplate(String methodName, String strColumn, String valueName) { String name = methodName + "_" + random(); if (valueName == null) { return new Tuple(name, "def " + name + " = doc['" + strColumn + "'].value." + methodName + "()" ); } else { return new Tuple(name, strColumn + "; def " + name + " = " + valueName + "." + methodName + "()"); } }
public static Tuple<String, String> substring(String strColumn, int pos, int len, String valueName) { String name = "substring_" + random(); if (valueName == null) { return new Tuple(name, "def " + name + " = doc['" + strColumn + "'].value.substring(" + pos + "," + len + ")"); } else { return new Tuple(name, strColumn + ";def " + name + " = " + valueName + ".substring(" + pos + "," + len + ")"); } }
private static Tuple<String, String> date_format(String strColumn, String pattern, String zoneId, String valueName) { String name = "date_format_" + random(); if (valueName == null) { return new Tuple<>(name, "def " + name + " = DateTimeFormatter.ofPattern('" + pattern + "').withZone(" + (zoneId != null ? "ZoneId.of('" + zoneId + "')" : "ZoneId.systemDefault()") + ").format(Instant.ofEpochMilli(doc['" + strColumn + "'].value.getMillis()))"); } else { return new Tuple<>(name, strColumn + "; def " + name + " = new SimpleDateFormat('" + pattern + "').format(new Date(" + valueName + " - 8*1000*60*60))"); } }
private static Tuple<String, String> mathDoubleValueTemplate(String methodName, String fieldName, String val1, String val2, String valueName) { String name = fieldName + "_" + random(); if (valueName == null) { return new Tuple(name, "def "+name+" = "+methodName+"(doc['"+val1+"'].value, "+val2+")"); } else { return new Tuple(name, val1 + ";def "+name+" = "+methodName+"("+valueName+", "+val2+")"); } }
public static Tuple<String, String> split(String strColumn, String pattern, int index, String valueName) { String name = "split_" + random(); String script = ""; if (valueName == null) { script = "def " + name + " = doc['" + strColumn + "'].value.split('" + pattern + "')[" + index + "]"; } else { script = "; def " + name + " = " + valueName + ".split('" + pattern + "')[" + index + "]"; } return new Tuple<>(name, script); }
public static Tuple<String, String> field(String a) { String name = "field_" + random(); return new Tuple<>(name, "def " + name + " = " + "doc['" + a + "'].value"); }
private static Tuple<String, String> mathRoundTemplate(String methodName, String fieldName, String strColumn, String valueName, int decimalPrecision) { StringBuilder sb = new StringBuilder("1"); for (int i = 0; i < decimalPrecision; i++) { sb.append("0"); } double num = Double.parseDouble(sb.toString()); String name = fieldName + "_" + random(); if (valueName == null) { return new Tuple<>(name, "def " + name + " = " + methodName + "((doc['" + strColumn + "'].value) * " + num + ")/" + num); } else { return new Tuple<>(name, strColumn + ";def " + name + " = " + methodName + "((" + valueName + ") * " + num + ")/" + num); } }
private static Tuple<String, String> concat_ws(String split, List<SQLExpr> columns, String valueName) { String name = "concat_ws_" + random(); List<String> result = Lists.newArrayList(); for (SQLExpr column : columns) { String strColumn = Util.expr2Object(column).toString(); if (strColumn.startsWith("def ")) { result.add(strColumn); } else if (isProperty(column)) { result.add("doc['" + strColumn + "'].value"); } else { result.add("'" + strColumn + "'"); } } return new Tuple<>(name, "def " + name + " =" + Joiner.on("+ " + split + " +").join(result)); }
public static Tuple<String, String> log(SQLExpr base, SQLExpr strColumn, String valueName) { String name = "log_" + random(); String result; if (valueName == null) { if (isProperty(strColumn)) { result = "def " + name + " = Math.log(doc['" + Util.expr2Object(strColumn).toString() + "'].value)/Math.log("+Util.expr2Object(base).toString()+")"; } else { result = "def " + name + " = Math.log(" + Util.expr2Object(strColumn).toString() + ")/Math.log("+Util.expr2Object(base).toString()+")"; } } else { result = Util.expr2Object(strColumn).toString()+";def "+name+" = Math.log("+valueName+")/Math.log("+Util.expr2Object(base).toString()+")"; } return new Tuple(name, result); }
private static Tuple<String, String> binaryOpertator(String methodName, String operator, SQLExpr a, SQLExpr b) { String name = methodName + "_" + random(); return new Tuple<>(name, scriptDeclare(a) + scriptDeclare(b) + convertType(a) + convertType(b) + " def " + name + " = " + extractName(a) + " " + operator + " " + extractName(b) ) ; }