com.nimbusds.infinispan.persistence.sql.JOOQFixes Maven / Gradle / Ivy

Go to download
package com.nimbusds.infinispan.persistence.sql;


import com.google.common.base.Splitter;
import net.jcip.annotations.ThreadSafe;
import org.jooq.Field;
import org.jooq.SQLDialect;

import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * Fixes incorrect SQL statements generated by jOOQ.
 */
@ThreadSafe
class JOOQFixes {


	/**
	 * Flag if an Oracle CLOB literal fix is required.
	 */
	private final boolean oracleClobFixRequired;
	
	
	/**
	 * The cutoff length of Oracle string literals. The Oracle
	 * {@code MAX_STRING_SIZE = STANDARD = 4000 bytes}, halve to allow for
	 * a mix UTF multibyte chars.
	 *
	 * See https://docs.oracle.com/database/121/SQLRF/sql_elements001.htm#SQLRF55623
	 */
	static final int ORACLE_STRING_LITERAL_CUTOFF_LENGTH = 2000;
	
	
	/**
	 * Creates a new instance for applying fixes to jOOQ generated SQL
	 * statements.
	 *
	 * @param sqlDialect The configured SQL dialect. Must not be
	 *                   {@code null}.
	 */
	public JOOQFixes(final SQLDialect sqlDialect) {
		
		oracleClobFixRequired = SQLDialect.ORACLE.equals(sqlDialect);
	}
	
	
	/**
	 * Parses the primary key constraint name from the specified create
	 * table SQL statement.
	 *
	 * @param createTableStatement The create table SQL statement.
	 *
	 * @return The primary key constraint name, {@code null} if missing or
	 *         not found.
	 */
	static String parsePrimaryKeyConstraintName(final String createTableStatement) {
		
		Pattern p = Pattern.compile(".*CONSTRAINT\\s+(\\w*)\\s+PRIMARY", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
		
		Matcher m = p.matcher(createTableStatement);
		
		if (! m.find()) {
			return null;
		}
		
		return m.group(1);
	}
	
	
	/**
	 * Prepares an optional Oracle database write with CLOBs.
	 *
	 * @param sqlRecord The SQL record.
	 * @param chunksMap The chunks map to set for later use by
	 *                  {@link #completeOracleWriteClob}.
	 *
	 * @return The potentially modified SQL record.
	 */
	SQLRecord prepareOracleWriteCLOB(final SQLRecord sqlRecord, final AtomicReference>> chunksMap) {
		
		if (! oracleClobFixRequired) {
			return sqlRecord;
		}
		
		chunksMap.set(new HashMap<>());
		
		Map,Object> fields = new LinkedHashMap<>();
		
		sqlRecord.getFields().entrySet().forEach((Consumer, ?>>) en -> {
			
			if (en.getValue() instanceof String && ((String)en.getValue()).length() > ORACLE_STRING_LITERAL_CUTOFF_LENGTH) {
			
				List chunks = splitChunksForOracleWriteClob((String) en.getValue());
				
				// Replace value with random code and map it to the chunks list
				String codeToReplace = UUID.randomUUID().toString();
				chunksMap.get().put(codeToReplace, chunks);
				
				fields.put(en.getKey(), codeToReplace);
			} else {
				fields.put(en.getKey(), en.getValue());
			}
		});
		
		return new ImmutableSQLRecord(sqlRecord.getKeyColumns(), fields);
	}
	
	
	/**
	 * Completes an optional Oracle database write with CLOBs.
	 *
	 * @param sqlStatement The SQL statement.
	 * @param chunksMap    The chunks map to use.
	 *
	 * @return The potentially modified SQL record.
	 */
	String completeOracleWriteClob(final String sqlStatement, final Map> chunksMap) {
		
		if (! oracleClobFixRequired) {
			return sqlStatement;
		}
		
		String out = sqlStatement;
		
		for (Map.Entry> en: chunksMap.entrySet()) {
			out = out.replace("'" + en.getKey() + "'", concatChunksForOracleWriteClob(en.getValue()));
		}
		
		return out;
	}
	
	
	/**
	 * Creates an Oracle TO_CLOB concatenation.
	 *
	 * @param chunks The string chunks, empty list if none.
	 *
	 * @return The Oracle TO_CLOB concatenation, empty string if none.
	 */
	static String concatChunksForOracleWriteClob(final List chunks) {
		
		var sb = new StringBuilder();
		
		for (int i=0; i 0) {
				sb.append("||");
			}
			
			sb.append("TO_CLOB('");
			sb.append(chunks.get(i).replace("'", "''")); // Quotes must be escaped
			sb.append("')");
		}
		
		return sb.toString();
	}
	
	
	/**
	 * Splits the specified string for Oracle TO_CLOB concatenation.
	 *
	 * @param s The string to split.
	 *
	 * @return The string list.
	 */
	static List splitChunksForOracleWriteClob(final String s) {
		
		List out = new LinkedList<>();
		
		Splitter.fixedLength(ORACLE_STRING_LITERAL_CUTOFF_LENGTH).split(s).forEach(
			out::add
		);
		return out;
	}
}