pgLab/pglablib/SqlFormattingUtils.cpp

#include "SqlFormattingUtils.h"
#include <QStringBuilder>

#include <cassert>
#include "PgKeywordList.h"

#include "PgConstraint.h"
#include "PgAttributeContainer.h"
#include "PgClass.h"
#include "PgClassContainer.h"
#include "PgIndex.h"
#include "PgNamespace.h"
#include "PgNamespaceContainer.h"
#include "PgDatabaseCatalog.h"

namespace {

	QString escapeInternal(const QString &input, bool as_ident)
	{
		int			num_quotes = 0; /* single or double, depending on as_ident */
		int			num_backslashes = 0;
		QChar		quote_char = as_ident ? '"' : '\'';
		// Doorloop input
		// tel quotes
		// tel backslashes
		const int len = input.length();
		for (int idx = 0; idx < len; ++idx) {
			QChar c = input[idx];
			if (c == quote_char)
				++num_quotes;
			else if (c == '\\')
				++num_backslashes;
		}

		int output_size = len + num_quotes + 2; // + 2 for the quotes
		if (!as_ident && num_backslashes > 0)
			output_size += num_backslashes + 2; // +2 so whe can add the " E"
		QString output;
		output.reserve(output_size);
		if (!as_ident && num_backslashes > 0)
			output += " E";

		output += quote_char;
		if (num_quotes == 0 && (num_backslashes == 0 || as_ident)) {
			output += input;
		}
		else {
			for (int idx = 0; idx < len; ++idx) {
				QChar c = input[idx];
				output += c;
				if (c == quote_char || (!as_ident && c == '\\'))
					output += c;
			}
		}
		output += quote_char;
		return output;
	}

}

QString escapeIdent(const QString &input)
{
	return escapeInternal(input, true);
}

QString escapeLiteral(const QString &input)
{
	return escapeInternal(input, false);
}

//char *
//PQescapeInternal(PGconn *conn, const char *str, size_t len, bool as_ident)
//{
//	const char *s;
//	char	   *result;
//	char	   *rp;
//	int			num_quotes = 0; /* single or double, depending on as_ident */
//	int			num_backslashes = 0;
//	int			input_len;
//	int			result_size;
//	char		quote_char = as_ident ? '"' : '\'';

////	/* We must have a connection, else fail immediately. */
////	if (!conn)
////		return NULL;

//	/* Scan the string for characters that must be escaped. */
//	for (s = str; (s - str) < len && *s != '\0'; ++s)
//	{
//		if (*s == quote_char)
//			++num_quotes;
//		else if (*s == '\\')
//			++num_backslashes;
//		else if (IS_HIGHBIT_SET(*s))
//		{
//			int			charlen;

//			/* Slow path for possible multibyte characters */
//			charlen = pg_encoding_mblen(conn->client_encoding, s);

//			/* Multibyte character overruns allowable length. */
//			if ((s - str) + charlen > len || memchr(s, 0, charlen) != NULL)
//			{
//				printfPQExpBuffer(&conn->errorMessage,
//						  libpq_gettext("incomplete multibyte character\n"));
//				return NULL;
//			}

//			/* Adjust s, bearing in mind that for loop will increment it. */
//			s += charlen - 1;
//		}
//	}

//	/* Allocate output buffer. */
//	input_len = s - str;
//	result_size = input_len + num_quotes + 3;	/* two quotes, plus a NUL */
//	if (!as_ident && num_backslashes > 0)
//		result_size += num_backslashes + 2;
//	result = rp = (char *) malloc(result_size);
//	if (rp == NULL)
//	{
//		printfPQExpBuffer(&conn->errorMessage,
//						  libpq_gettext("out of memory\n"));
//		return NULL;
//	}

//	/*
//	 * If we are escaping a literal that contains backslashes, we use the
//	 * escape string syntax so that the result is correct under either value
//	 * of standard_conforming_strings.  We also emit a leading space in this
//	 * case, to guard against the possibility that the result might be
//	 * interpolated immediately following an identifier.
//	 */
//	if (!as_ident && num_backslashes > 0)
//	{
//		*rp++ = ' ';
//		*rp++ = 'E';1
//	}

//	/* Opening quote. */
//	*rp++ = quote_char;

//	/*
//	 * Use fast path if possible.
//	 *
//	 * We've already verified that the input string is well-formed in the
//	 * current encoding.  If it contains no quotes and, in the case of
//	 * literal-escaping, no backslashes, then we can just copy it directly to
//	 * the output buffer, adding the necessary quotes.
//	 *
//	 * If not, we must rescan the input and process each character
//	 * individually.
//	 */
//	if (num_quotes == 0 && (num_backslashes == 0 || as_ident))
//	{
//		memcpy(rp, str, input_len);
//		rp += input_len;
//	}
//	else
//	{
//		for (s = str; s - str < input_len; ++s)
//		{
//			if (*s == quote_char || (!as_ident && *s == '\\'))
//			{
//				*rp++ = *s;
//				*rp++ = *s;
//			}
//			else if (!IS_HIGHBIT_SET(*s))
//				*rp++ = *s;
//			else
//			{
//				int			i = pg_encoding_mblen(conn->client_encoding, s);

//				while (1)
//				{
//					*rp++ = *s;
//					if (--i == 0)
//						break;
//					++s;		/* for loop will provide the final increment */
//				}
//			}
//		}
//	}

//	/* Closing quote and terminating NUL. */
//	*rp++ = quote_char;
//	*rp = '\0';

//	return result;
//}


bool identNeedsQuotes(QString ident)
{
	if (ident[0].isDigit())
		return true;
	for (auto c : ident)
		if ((c < 'a' || c > 'z') && c != '_')
			return true;

	auto kw = getPgsqlKeyword(ident);
	if (kw == nullptr)
		return false;
	else if (kw->getCategory() == UNRESERVED_KEYWORD)
		return false;
//	if (forTypes && sk->category == COL_NAME_KEYWORD)
//		return false;

	return true;
}

QString quoteIdent(QString ident)
{
	assert(ident.length() > 0);

	static const wchar_t dquote = L'"';

	if (identNeedsQuotes(ident)) {
		QString out;
		out += dquote;
		out += ident.replace("\"", "\"\"");
		out += dquote;
		return out;
	}
	else
		return ident;
}


QString dollarQuoteString(const QString &value)
{
	QString def_tag = "BODY";
	QString tag = QString("$%1$").arg(def_tag);

	int counter = 1;
	while (value.indexOf(tag) >= 0)
		tag = QString("$%1%2$").arg(def_tag, counter++);


	return tag
		   +  value
		   +  tag;
}



QString genSchemaPrefix(const PgNamespace &ns)
{
	QString str;
	if (!ns.name.isEmpty()) {
		str = quoteIdent(ns.name) % QString::fromUtf16(u".");
	}
	return str;
}


QString genFQTableName(const PgDatabaseCatalog &catalog, const PgClass &cls)
{
	auto ns = catalog.namespaces()->getByKey(cls.relnamespace);

	return genSchemaPrefix(*ns) % quoteIdent(cls.name);
}

QString genAlterTable(const PgDatabaseCatalog &catalog, const PgClass &cls)
{
	return "ALTER TABLE " % genFQTableName(catalog, cls);
}

QString getDropConstraintDefinition(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	const PgClass *cls = catalog.classes()->getByKey(constraint.relid);
	return genAlterTable(catalog, *cls) % " DROP CONSTRAINT " % quoteIdent(constraint.name) % ";";
}


/// Helper class that builds comma seperated identifier list
class IdentListString {
public:
	void add(QString ident)
	{
		if (!m_str.isEmpty())
			m_str += ",";
		m_str += quoteIdent(ident);
	}
	const QString& str() const { return m_str; }
private:
	QString m_str;
};

QString getColumnNameList(const PgDatabaseCatalog &catalog, Oid relid, const SmallAttNumVec<5> &attnums)
{
	IdentListString result;

	const auto ac = catalog.attributes();
	for (auto an : attnums) {
		result.add(ac->getByKey({ relid, an })->name);
	}
	return result.str();
}

QString getForeignKeyConstraintDefinition(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	//PgClass cls = catalog.classes()->getByKey(constraint.relid);
	const PgClass *fcls = catalog.classes()->getByKey(constraint.frelid);
	QString deferrable;
	QString validated;
	if (!constraint.validated)
		validated += " NOT VALID";
	if (constraint.deferrable) {
		deferrable = QLatin1String(" DEFERRABLE INITIALLY ") % (constraint.deferred ? "DEFERRED" : "IMMEDIATE");
	}

	return "\n    FOREIGN KEY ("
			% getColumnNameList(catalog, constraint.relid, constraint.key) % ")\n    REFERENCES "
			% genFQTableName(catalog, *fcls) % " ("
			% getColumnNameList(catalog, constraint.frelid, constraint.fkey) % ")\n    MATCH "
			% ForeignKeyMatchToString(constraint.fmatchtype)
			%  " ON UPDATE " % ForeignKeyActionToString(constraint.fupdtype)
			%  " ON DELETE " % ForeignKeyActionToString(constraint.fdeltype)
			% deferrable % validated % ";";
}

QString getForeignKeyConstraintReferences(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	const PgClass *fcls = catalog.classes()->getByKey(constraint.frelid);
	QString deferrable;
	QString validated;
	if (!constraint.validated)
		validated += " NOT VALID";
	if (constraint.deferrable) {
		deferrable = QLatin1String(" DEFERRABLE INITIALLY ") % (constraint.deferred ? "DEFERRED" : "IMMEDIATE");
	}

	return "REFERENCES "
			% genFQTableName(catalog, *fcls) % " ("
			% getColumnNameList(catalog, constraint.frelid, constraint.fkey) % ") MATCH "
			% ForeignKeyMatchToString(constraint.fmatchtype)
			%  " ON UPDATE " % ForeignKeyActionToString(constraint.fupdtype)
			%  " ON DELETE " % ForeignKeyActionToString(constraint.fdeltype)
			% deferrable % validated;

}


QString getForeignKeyConstraintReferencesShort(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	const PgClass *fcls = catalog.classes()->getByKey(constraint.frelid);
	QString deferrable;
	QString validated;
	if (!constraint.validated)
		validated += " NOT VALID";
	if (constraint.deferrable) {
		deferrable = QLatin1String(" DEFERRABLE") % (constraint.deferred ? " INITIALLY DEFERRED" : "");
	}
	QString on_update = constraint.fupdtype == ForeignKeyAction::NoAction ? QString() : " ON UPDATE " % ForeignKeyActionToString(constraint.fupdtype);
	QString on_delete = constraint.fdeltype == ForeignKeyAction::NoAction ? QString() : " ON DELETE " % ForeignKeyActionToString(constraint.fdeltype);
	QString match_type = constraint.fmatchtype == ForeignKeyMatch::Simple ? QString() : " MATCH " % ForeignKeyMatchToString(constraint.fmatchtype);

	return genFQTableName(catalog, *fcls) % " ("
			% getColumnNameList(catalog, constraint.frelid, constraint.fkey) % ")"
			% match_type
			% on_update
			% on_delete
			% deferrable % validated;

}

QString getPrimaryKeyConstraintDefinition(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	QString ddl = " PRIMARY KEY ("
			% getColumnNameList(catalog, constraint.relid, constraint.key) % ");";

	return ddl;
}

QString getUniqueConstraintDefinition(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	QString ddl = " UNIQUE ("
			% getColumnNameList(catalog, constraint.relid, constraint.key) % ");";

	return ddl;
}

QString getConstraintDefinition(const PgDatabaseCatalog &catalog, const PgConstraint &constraint)
{
	const PgClass *cls = catalog.classes()->getByKey(constraint.relid);
//	return genAlterTable(catalog, cls) % " ADD CONSTRAINT "
//			% quoteIdent(constraint.name) % " " % constraint.definition % ";";
	QString result = genAlterTable(catalog, *cls) % "\n  ADD CONSTRAINT "
			% quoteIdent(constraint.name);
	switch (constraint.type) {
	case ConstraintType::ForeignKey:
		result += getForeignKeyConstraintDefinition(catalog, constraint);
		break;
	case ConstraintType::PrimaryKey:
		result += getPrimaryKeyConstraintDefinition(catalog, constraint);
		break;
	case ConstraintType::Unique:
		result += getUniqueConstraintDefinition(catalog, constraint);
		break;
	case ConstraintType::Check:
	default:
		result = result % " " % constraint.definition;
		break;
	}
	return result;
}

QString getIndexDefinition(const PgDatabaseCatalog &catalog, const PgIndex &index)
{
//	const PgClass *table_class = catalog.classes()->getByKey(index.relid);
//	const PgClass *index_class = catalog.classes()->getByKey(index.indexrelid);


	return index.definition + ";";

//	QString result;
//	result = "CREATE ";
//	if (index.isunique)
//		result += "UNIQUE ";
//	result += "INDEX "
////			% quoteIdent(getIndexDisplayString(catalog, index.indexrelid))
//			% quoteIdent(index_class.name)
//			% "\n  ON " % genFQTableName(catalog, table_class);
////			% "\n  USING " % index_class.am lookup in pg_am table
//	return result;

#if 0
		   + wxT("\n  USING ") + GetIndexType()
		   + wxT("\n  (");
	if (GetProcName().IsNull())
		str += GetQuotedColumns();
	else
	{
		str += GetQuotedSchemaPrefix(GetProcNamespace()) + qtIdent(GetProcName()) + wxT("(") + GetQuotedColumns() + wxT(")");
		if (!this->GetOperatorClasses().IsNull())
			str += wxT(" ") + GetOperatorClasses();
	}

	str += wxT(")");

	if (GetConnection()->BackendMinimumVersion(8, 2) && GetFillFactor().Length() > 0)
		str += wxT("\n  WITH (FILLFACTOR=") + GetFillFactor() + wxT(")");

	if (GetConnection()->BackendMinimumVersion(8, 0) && tablespace != GetDatabase()->GetDefaultTablespace())
		str += wxT("\nTABLESPACE ") + qtIdent(tablespace);

	AppendIfFilled(str, wxT("\n  WHERE "), GetConstraint());

	str += wxT(";\n");

	if (GetConnection()->BackendMinimumVersion(7, 5))
		if (GetIsClustered())
			str += wxT("ALTER TABLE ") + GetQuotedSchemaPrefix(GetIdxSchema()) + qtIdent(GetIdxTable())
				   +  wxT(" CLUSTER ON ") + qtIdent(GetName())
				   + wxT(";\n");
#endif
}

QString getDropIndexDefinition(const PgDatabaseCatalog &catalog, const PgIndex &index)
{
//	const PgClass *table_class = catalog.classes()->getByKey(index.relid);
//	const PgClass *index_class = catalog.classes()->getByKey(index.indexrelid);

	QString result;
	result = "DROP INDEX "
			% quoteIdent(getIndexDisplayString(catalog, index.indexrelid))
			% ";";
//			% quoteIdent(index_class.name)
//			% "\n  ON " % genFQTableName(catalog, table_class);
////			% "\n  USING " % index_class.am lookup in pg_am table
	return result;
}


/*
wxString sql;

sql = wxT("(") + GetQuotedFkColumns()
	  +  wxT(")\n      REFERENCES ") + GetQuotedSchemaPrefix(GetRefSchema()) + qtIdent(GetReferences())
	  +  wxT(" (") + GetQuotedRefColumns()
	  +  wxT(")");

if (GetDatabase()->BackendMinimumVersion(7, 4) || GetMatch() == wxT("FULL"))
	sql += wxT(" MATCH ") + GetMatch();

sql += wxT("\n      ON UPDATE ") + GetOnUpdate()
	   +  wxT(" ON DELETE ") + GetOnDelete();
if (GetDeferrable())
{
	sql += wxT(" DEFERRABLE INITIALLY ");
	if (GetDeferred())
		sql += wxT("DEFERRED");
	else
		sql += wxT("IMMEDIATE");
}

if (GetDatabase()->BackendMinimumVersion(9, 1) && !GetValid())
	sql += wxT("\n      NOT VALID");

return sql;
*/