protected List<String> insertColumns(SqlObjectDefinition<?> definition, Map<String, Object> m) { List<String> equalsKeys = new ArrayList<String>(); for (Entry<String, Object> e : m.entrySet()) { Optional<String> sqlName = definition.parameterNameToSql(e.getKey()); check.state(sqlName.isPresent(), "Property: {} not found in object.", e.getKey()); equalsKeys.add(sqlName.get()); } return equalsKeys; }
if (m.matches() && (tag = m.group(1)) != null && ! (tag = tag.trim()).isEmpty()) { if (tag != null && tag.startsWith("#")) { check.state(state != PSTATE.HASH, PE + "Cannot hash within hash at line: {}.", path, lineIndex); state = PSTATE.HASH; hashContent = ImmutableList.builder(); check.state(state != PSTATE.REFERENCE, PE + "Cannot reference within reference at line: {}.", path, lineIndex); previousState = state; state = PSTATE.REFERENCE; check.state(! currentReference.isEmpty(), PE + "No reference defined", path); referenceStartIndex = lineIndex; referenceContent.add(line); check.state(state == PSTATE.REFERENCE, PE + "Invalid close of reference line: {}", path, lineIndex); state = previousState; int length = lineIndex - referenceStartIndex + 1; referenceContent.add(line); check.state(length > -1, "length should be greater than -1"); check.state(length >= 0, PE + "Hash Line index incorrect. Index: {}, Reference start: {}", path, lineIndex, referenceStartIndex); ReferenceSql rsql = new ReferenceSql(currentReference, path, referenceContent.build(), referenceStartIndex, length, currentReferenceParameters); check.state(state == PSTATE.HASH, PE + "Hash not started or reference not finished line: {}", path, lineIndex); String t = tag.substring(1).trim(); check.state(! t.isEmpty(), PE + "No close hash is defined at line: {}", path, lineIndex); check.state(t.equals(currentHash), PE + "Should be current hash tag: {} at line: {}", path, currentHash, lineIndex); state = PSTATE.OTHER; int length = lineIndex - hashStartIndex + 1;
@Override public String lookup(String key) { Optional<String> p = parameterPathToSql(definition,key); check.state(p.isPresent(), "Invalid object path: {}", key); return p.get(); } };
check.state(this.getOriginalSql().contains("?"), "Expecting already included JDBC placeholders: {} in sql:", parameters, this); return parameters.getParameters(); NamePlaceHolder np = ph.asName(); String name = np.getName(); check.state(parameters.getNameParameters().containsKey(name), "ParsedSql wants parameter '{}' but name parameters do not have it: {}", name, parameters); Object o = parameters.getNameParameters().get(name);
@Override public String lookup(String key) { Optional<String> sqlName = definition.parameterNameToSql(key); check.state(sqlName.isPresent(), "Property: {} not found in object.", key); return sqlName.get(); } };
@Override public String load(String path) { try { String p = check.notNull(path, "path is null"); check.state(p.startsWith("/"), "path should start with '/' but was: {}", path); p = p.substring(1); return Resources.toString(Resources.getResource(p), Charsets.UTF_8); } catch (IOException e) { throw new RuntimeException(e); } } };
@Override public String load(String path) { try { String p = check.notNull(path, "path is null"); check.state(p.startsWith("/"), "path should start with '/' but was: {}", path); p = p.substring(1); return ResourceUtils.getClasspathResourceAsString(p); } catch (IOException e) { throw new RuntimeException(e); } } }
public List<SqlParameterDefinition> resolveParameterPath(String parameterDotPath) { Iterator<String> it = dotSplitter.split(parameterDotPath).iterator(); List<SqlParameterDefinition> r = Lists.newArrayList(); SqlObjectDefinition<?> currentObject = this; while(it.hasNext()) { String pathPart = it.next(); Optional<SqlParameterDefinition> p = currentObject.resolveParameter(pathPart); if ( ! p.isPresent() ) return emptyList(); check.state( ! ( it.hasNext() && ! p.get().isComplex()), "Bad path parts references a simple parameter: {}", parameterDotPath); r.add(p.get()); if (it.hasNext()) currentObject = p.get().getObjectDefinition().get().getObjectDefintion(); } return r; }
protected SqlParameterDefinition idParameter() { check.state(definition.idParameter().isPresent(), "No id parameter for : {}", definition.getObjectType()); return this.definition.idParameter().get(); }
public T reload(T t) { LinkedHashMap<String, Object> m = toLinkedHashMap(t, false); Optional<SqlParameterDefinition> id = definition.idParameter(); check.state(id.isPresent(), "No id definition"); Optional<Object> o = id.get().valueFrom(m); return findById(o.get()); }
final String query; if (parts.length > 1) { check.state( ! t.contains("?"), "Cannot mix space and '?' style"); URI u = URI.create(parts[0]); path = u.getPath();
@Override public T mapRow(Map<String, Object> m, int rowNum) { for (String simpleParameter : objectDefinition.getSimpleParameters().keySet()) { check.state(m.containsKey(simpleParameter), "For type: {} simpleParameter: {} was not in resultset", objectDefinition.getObjectType(), simpleParameter); } return objectConverter.convertSqlMapToObject(m, objectDefinition.getObjectType()); }
public void insertMaps(Iterator<Map<String,Object>> values, int batchSize) { if (! values.hasNext() ) return; PeekingIterator<Map<String,Object>> vs = peekingIterator(values); Map<String,Object> first = vs.peek(); final String sql = writerStrategy.insertStatement(new StringBuilder(), definition, first).toString(); ImmutableList<String> keys = ImmutableList.copyOf(vs.peek().keySet()); Iterator<List<Map<String,Object>>> it = partition(vs, batchSize); while (it.hasNext()) { List<Map<String,Object>> batch = it.next(); final List<Object[]> batchValues = Lists.newArrayListWithExpectedSize(batch.size()); for (Map<String,Object> b : batch) { ImmutableList<String> actualKeys = ImmutableList.copyOf(b.keySet()); check.state(actualKeys.equals(keys), "Keys don't match up to {} for {}", keys, actualKeys); batchValues.add(writerStrategy.fillValues(definition, b).toArray()); } /* * TODO this will keep making a prepared statementS. * Hopefully the JDBC driver has some caching for this. */ sqlExecutor.batchUpdate(sql, batchValues); } }
String leftHand = m.group(1); int start = m.start(1); check.state(start == 0, "start should be 0"); int[] ind = parseForReplacement(leftHand); check.state(ind != null, "Problem parsing {}", line); String before = leftHand.substring(0, ind[0]); String after = leftHand.substring(ind[1], leftHand.length());
protected ExpandedSql _expand(String path, Set<String> seenPaths) { check.state(! seenPaths.contains(path), "Cycle detected for path: {}, paths involved: {}", path, seenPaths); if (seenPaths.contains(path)) {
check.state(m.containsKey(pd.getParameterName()), "Missing parameter for bulk insert: {}", pd.getParameterName()); Object o = m.get(pd.getParameterName());
check.state(validate, "Reference '> {}' in {} at line: {}" + " does" +
public Path fromRelative(Path p) { check.state(p.isRelative(), "path should be relative"); final Path r; if (p.isJustHash()) { r = Path.create(this.getPathWithOutHash() + p.getFullPath()); } else { r = Path.create(this.parent().getPathWithOutHash() + "/" + p.getFullPath()); } return r; } @Override