@Override public SQLSession getSession() { SQLSession session = new SQLSession(this, getDescriptor()); addSession(session); return session; }
acquireConnection(); whatColumns.add(table.getColumn(getPasswordField())); if (isMultiTenant()) { whatColumns.add(table.getColumn(TENANT_ID_FIELD)); select.setWhat(what); String whereClause = table.getPrimaryColumn().getQuotedName() + " = ?"; whereClause = addFilterWhereClause(whereClause); select.setWhere(whereClause); String sql = select.getStatement(); List<Serializable> values = new ArrayList<>(); values.add(id); addFilterValuesForLog(values); logger.logSQL(sql, values); setFieldValue(ps, 1, table.getPrimaryColumn(), id); addFilterValues(ps, 2); try (ResultSet rs = ps.executeQuery()) { if (!rs.next()) { return null; if (isMultiTenant()) { String tenantId = getCurrentTenantId(); if (!StringUtils.isBlank(tenantId)) { String entryTenantId = (String) getFieldValue(rs, table.getColumn(TENANT_ID_FIELD)); if (!StringUtils.isBlank(entryTenantId)) {
@Override public void deleteEntry(String id) { acquireConnection(); if (!canDeleteMultiTenantEntry(id)) { throw new OperationNotAllowedException("Operation not allowed in the current tenant context", "label.directory.error.multi.tenant.operationNotAllowed", null); } super.deleteEntry(id); }
protected void fillPreparedStatementFields(Map<String, Object> filterMap, List<Column> orderedColumns, PreparedStatement ps) { int index = 1; for (Column column : orderedColumns) { Object value = filterMap.get(column.getKey()); if (value instanceof SQLComplexFilter) { index = ((SQLComplexFilter) value).setFieldValue(ps, index, column); } else { setFieldValue(ps, index, column, value); index++; } } addFilterValues(ps, index); }
protected void checkIsNotLive() { try { if (!session.isLive()) { return; } if (initContext != null) { log.warn("Closing a sql directory session for you " + session, initContext); } else { log.warn("Closing a sql directory session for you " + session); } if (!TransactionHelper.isTransactionActiveOrMarkedRollback()) { log.warn("Closing sql directory session outside a transaction" + session); } session.close(); } catch (DirectoryException e) { log.error("Cannot state on sql directory session before commit " + SQLDirectory.this, e); } }
Field schemaIdField = schemaFieldMap.get(getIdField()); acquireConnection(); if (autoincrementId) { fieldMap.remove(idFieldName); if (isMultiTenant()) { String tenantId = getCurrentTenantId(); if (!StringUtils.isBlank(tenantId)) { fieldMap.put(TENANT_ID_FIELD, tenantId); if (computeMultiTenantId) { id = computeMultiTenantDirectoryId(tenantId, id); fieldMap.put(idFieldName, id); if (hasEntry(id)) { throw new DirectoryException(String.format("Entry with id %s already exists", id)); Object value = fieldMap.get(prefixField); Serializable v; if (HIDE_PASSWORD_IN_LOGS && column.getKey().equals(getPasswordField())) { v = "********"; // hide password in logs } else { v = fieldValueForWrite(value, column); try (PreparedStatement ps = prepareStatementWithAutoKeys(sql)) { String prefixField = schemaFieldMap.get(column.getKey()).getName().getPrefixedName(); Object value = fieldMap.get(prefixField); setFieldValue(ps, index, column, value);
@Override public DocumentModelList query(Map<String, Serializable> filter, Set<String> fulltext, Map<String, String> orderBy, boolean fetchReferences, int limit, int offset) { if (!hasPermission(SecurityConstants.READ)) { return new DocumentModelListImpl(); acquireConnection(); Map<String, Object> filterMap = new LinkedHashMap<>(filter); filterMap.remove(getPasswordField()); // cannot filter on password if (isMultiTenant()) { String tenantId = getCurrentTenantId(); if (!StringUtils.isBlank(tenantId)) { filterMap.put(TENANT_ID_FIELD, tenantId); if (getDirectory().isReference(columnName)) { log.warn(columnName + " is a reference and will be ignored" + " as a query criterion"); continue; int queryLimitSize = getDirectory().getDescriptor().getQuerySizeLimit(); boolean trucatedResults = false; if (queryLimitSize != 0 && (limit <= 0 || limit > queryLimitSize)) { where = addFilterWhereClause(where); select.setWhere(where); addFilterValuesForLog(values); logger.logSQL(countQuery, values);
@Override public DocumentModel getEntryFromSource(String id, boolean fetchReferences) { acquireConnection(); select.setWhat(getReadColumnsSQL()); whereClause = addFilterWhereClause(whereClause); List<Serializable> values = new ArrayList<>(); values.add(id); addFilterValuesForLog(values); logger.logSQL(sql, values); setFieldValue(ps, 1, table.getPrimaryColumn(), id); addFilterValues(ps, 2); for (Column column : getReadColumns()) { Object value = getFieldValue(rs, column); fieldMap.put(column.getKey(), value); logger.logResultSet(rs, getReadColumns()); if (isMultiTenant()) { String tenantId = getCurrentTenantId(); if (!StringUtils.isBlank(tenantId)) { String entryTenantId = (String) fieldMap.get(TENANT_ID_FIELD); DocumentModel entry = fieldMapToDocumentModel(fieldMap);
@Override public DocumentModelList query(QueryBuilder queryBuilder, boolean fetchReferences) { if (!hasPermission(SecurityConstants.READ)) { return new DocumentModelListImpl(); if (FieldDetector.hasField(queryBuilder.predicate(), getPasswordField())) { throw new DirectoryException("Cannot filter on password"); queryBuilder = addTenantId(queryBuilder); SQLQueryBuilder builder = new SQLQueryBuilder(getDirectory()); builder.visitMultiExpression(queryBuilder.predicate()); addFilterWhereClause(builder.clause, builder.params); acquireConnection(); select.setWhat(getReadColumnsSQL()); select.setFrom(table.getQuotedName()); select.setWhere(whereClause); int i = 1; for (ColumnAndValue columnAndValue : builder.params) { setFieldValue(ps, i++, columnAndValue.column, columnAndValue.value); for (Column column : getReadColumns()) { Object o = getFieldValue(rs, column); map.put(column.getKey(), o); DocumentModel docModel = fieldMapToDocumentModel(map);
@Override protected List<String> updateEntryWithoutReferences(DocumentModel docModel) { acquireConnection(); List<Column> storedColumnList = new LinkedList<>(); List<String> referenceFieldList = new LinkedList<>(); if (isMultiTenant()) { String tenantId = getCurrentTenantId(); if (!StringUtils.isBlank(tenantId)) { String entryTenantId = (String) docModel.getProperty(schemaName, TENANT_ID_FIELD); if (fieldName.equals(getIdField())) { continue; if (fieldName.equals(getPasswordField()) && StringUtils.isEmpty((String) prop.getValue())) { if (getDirectory().isReference(fieldName)) { referenceFieldList.add(fieldName); } else { for (Column column : storedColumnList) { Object value = docModel.getProperty(schemaName, column.getKey()); if (HIDE_PASSWORD_IN_LOGS && column.getKey().equals(getPasswordField())) { value = "********"; // hide password in logs setFieldValue(ps, index, column, value); index++; setFieldValue(ps, index, table.getPrimaryColumn(), docModel.getId());
@Override public List<String> queryIds(QueryBuilder queryBuilder) { if (!hasPermission(SecurityConstants.READ)) { return Collections.emptyList(); if (FieldDetector.hasField(queryBuilder.predicate(), getPasswordField())) { throw new DirectoryException("Cannot filter on password"); queryBuilder = addTenantId(queryBuilder); SQLQueryBuilder builder = new SQLQueryBuilder(getDirectory()); builder.visitMultiExpression(queryBuilder.predicate()); addFilterWhereClause(builder.clause, builder.params); acquireConnection(); Column idColumn = getIdColumn(); Select select = new Select(table); select.setWhat(idColumn.getQuotedName()); int i = 1; for (ColumnAndValue columnAndValue : builder.params) { setFieldValue(ps, i++, columnAndValue.column, columnAndValue.value);
@Override public void deleteEntry(String id, Map<String, String> map) { checkPermission(SecurityConstants.WRITE); acquireConnection(); if (!canDeleteMultiTenantEntry(id)) { throw new DirectoryException("Operation not allowed in the current tenant context"); for (int i = 0; i < values.size(); i++) { if (i == 0) { setFieldValue(ps, 1, table.getPrimaryColumn(), values.get(i)); } else { ps.setString(1 + i, (String) values.get(i)); checkConcurrentUpdate(e); throw new DirectoryException("deleteEntry failed", e); getDirectory().invalidateCaches();
@Override public void deleteEntryWithoutReferences(String id) { // second step: clean stored fields Delete delete = new Delete(table); String whereString = table.getPrimaryColumn().getQuotedName() + " = ?"; delete.setWhere(whereString); String sql = delete.getStatement(); if (logger.isLogEnabled()) { logger.logSQL(sql, Collections.singleton(id)); } try (PreparedStatement ps = sqlConnection.prepareStatement(sql)) { setFieldValue(ps, 1, table.getPrimaryColumn(), id); ps.execute(); } catch (SQLException e) { checkConcurrentUpdate(e); throw new DirectoryException("deleteEntry failed", e); } }
@Override public boolean hasEntry(String id) { acquireConnection(); Select select = new Select(table); select.setFrom(table.getQuotedName()); select.setWhat("1"); select.setWhere(table.getPrimaryColumn().getQuotedName() + " = ?"); String sql = select.getStatement(); if (logger.isLogEnabled()) { logger.logSQL(sql, Collections.singleton(id)); } try (PreparedStatement ps = sqlConnection.prepareStatement(sql)) { setFieldValue(ps, 1, table.getPrimaryColumn(), id); try (ResultSet rs = ps.executeQuery()) { boolean has = rs.next(); if (logger.isLogEnabled()) { logger.logCount(has ? 1 : 0); } return has; } } catch (SQLException e) { throw new DirectoryException("hasEntry failed", e); } }
public SQLSession(SQLDirectory directory, SQLDirectoryDescriptor config) { super(directory, TableReference.class); table = directory.getTable(); dialect = directory.getDialect(); sid = String.valueOf(SIDGenerator.next()); staticFilters = config.getStaticFilters(); acquireConnection(); }