com.xdev.jadoth.sqlengine.dbms.standard.StandardDMLAssembler Maven / Gradle / Ivy
/*
* XDEV Application Framework - XDEV Application Framework
* Copyright © 2003 XDEV Software (https://xdev.software)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see getSingletonStandardDMLAssembler(){
return StandardDbmsAdaptor.getSingletonStandardDbmsAdaptor().getDMLAssembler();
}
///////////////////////////////////////////////////////////////////////////
// constructors //
/////////////////////
/**
* Instantiates a new standard dml assembler.
*
* @param dbmsAdaptor the dbms adaptor
*/
public StandardDMLAssembler(final A dbmsAdaptor) {
super(dbmsAdaptor);
}
///////////////////////////////////////////////////////////////////////////
// getters //
/////////////////////
///////////////////////////////////////////////////////////////////////////
// setters //
/////////////////////
/**
* @param query
* @param sb
* @param indentLevel
* @param flags
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleQuery(Query, java.lang.StringBuilder, int, int)
*/
@Override
public void assembleQuery(
final Query query,
final StringBuilder sb,
final int indentLevel,
int flags
)
{
final boolean singleLineMode = isSingleLine(flags);
final String clauseSeperator = singleLineMode || isPacked(flags)?"":NEW_LINE;
final String newLine = singleLineMode?" ":NEW_LINE;
final DbmsConfiguration config = this.getDbmsAdaptor().getConfiguration();
flags = flags
| bitDelimitTableIdentifiers(config.isDelimitTableIdentifiers())
| bitDelimitColumnIdentifiers(config.isDelimitColumnIdentifiers())
| bitDelimitAliases(config.isDelimitAliases())
;
this.assembleQueryName(query, sb, indentLevel, singleLineMode);
this.assembleQueryComment(query, sb, indentLevel, singleLineMode);
this.assembleQuerySubclassContext(query, sb, indentLevel, flags, clauseSeperator, newLine);
}
/**
* Assemble query name.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param singleLine the single line
* @return the string builder
*/
protected StringBuilder assembleQueryName(
final Query query, final StringBuilder sb, final int indentLevel, final boolean singleLine
)
{
final String name = query.getName();
if(name == null) return sb;
indent(sb, indentLevel, singleLine);
sb.append(singleLine?blockCommentStart:singleLineComment);
sb.append(name);
sb.append(singleLine?blockCommentEnd:NEW_LINE);
return sb;
}
/**
* Assemble query comment.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param singleLine the single line
* @return the string builder
*/
protected StringBuilder assembleQueryComment(
final Query query, final StringBuilder sb, final int indentLevel, final boolean singleLine
)
{
if(query.getComment() == null) return sb;
indent(sb, indentLevel, singleLine);
sb.append(blockCommentStart).append(singleLine?_:NEW_LINE);
this.assembleCommentLines(query, sb, indentLevel, singleLine);
sb.append(singleLine?_:NEW_LINE);
indent(sb, indentLevel, singleLine).append(blockCommentEnd);
sb.append(singleLine?_:NEW_LINE);
return sb;
}
/**
* Assemble comment lines.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param singleLine the single line
* @return the string builder
*/
protected StringBuilder assembleCommentLines(
final Query query, StringBuilder sb, final int indentLevel, final boolean singleLine
)
{
final String[] comments = query.getCommentLines();
if(comments == null){
return sb;
}
if(sb == null){
final String comment = query.getComment();
int commentLength = 0;
if(comment != null){
commentLength = comment.length();
}
else {
for(final String s : comments) {
if(s == null) break;
commentLength += s.length();
}
}
sb = new StringBuilder(commentLength);
}
final char seperator = singleLine?' ':n;
for(int i = 0; i < comments.length; i++) {
if(i > 0){
sb.append(seperator);
}
indent(sb, indentLevel, singleLine);
sb.append(comments[i]);
}
return sb;
}
/**
* Assemble query subclass context.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @return the string builder
* @return
*/
protected StringBuilder assembleQuerySubclassContext(
final Query query,
final StringBuilder sb,
final int indentLevel,
final int flags,
final String clauseSeperator,
final String newLine
){
if(query instanceof SELECT){
return this.assembleSELECT(
(SELECT)query, sb, indentLevel, flags, clauseSeperator, newLine
);
}
else if(query instanceof INSERT){
return this.assembleINSERT(
(INSERT)query, sb, flags, clauseSeperator, newLine, indentLevel
);
}
else if(query instanceof UPDATE){
return this.assembleUPDATE(
(UPDATE)query, sb, indentLevel, flags, clauseSeperator, newLine
);
}
else if(query instanceof DELETE){
return this.assembleDELETE(
(DELETE)query, sb, flags, clauseSeperator, newLine, indentLevel
);
}
else {
throw new RuntimeException("Unhandled Query Type: "+query.getClass().getName());
}
}
/**
* Assemble select distinct.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleSelectDISTINCT(
final SELECT query,
final StringBuilder sb,
final int indentLevel,
final int flags
)
{
if(query.isDistinct()){
sb.append(_).append(DISTINCT);
}
return sb;
}
/**
* Assemble select items.
*
* @param query the query
* @param sb the sb
* @param flags the flags
* @param indentLevel the indent level
* @param newLine the new line
* @return the string builder
*/
protected StringBuilder assembleSelectItems(
final SELECT query,
final StringBuilder sb,
final int flags,
final int indentLevel,
final String newLine
)
{
final boolean singleLine = isSingleLine(flags);
final String indentItem = singleLine
?""
:indent(new StringBuilder(indentLevel), indentLevel, singleLine).append(__).toString()
;
final String itemSeperator = singleLine?comma_:SQL.config.list_CommaNewLine ?selectItem_Comma_NEW_LINE
:selectItem_NEW_LINE_Comma;
final List selectItems = query.getSelectItems();
if(selectItems == null || selectItems.isEmpty()){
if(query.getFromClause() != null){
sb.append(_star);
}
//otherwise, add no item at all
}
else{
sb.append(newLine).append(indentItem);
for(int i = 0, size = selectItems.size(); i < size; i++) {
if(i > 0){
sb.append(itemSeperator).append(indentItem);
}
this.assembleSelectItem(selectItems.get(i), sb, indentLevel, flags);
}
}
return sb;
}
/**
* @param selectItem
* @param sb
* @param indentLevel
* @param flags
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleSelectItem(com.xdev.jadoth.sqlengine.internal.interfaces.SelectItem, java.lang.StringBuilder, int, int)
*/
@Override
public void assembleSelectItem(
final SelectItem selectItem, final StringBuilder sb, final int indentLevel, final int flags
)
{
QueryPart.assembleObject(selectItem, this, sb, indentLevel, flags | MINIINDENT | ASEXPRESSION);
}
/**
* @param expression
* @param sb
* @param indentLevel
* @param flags
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleExpression(com.xdev.jadoth.sqlengine.internal.SqlExpression, java.lang.StringBuilder, int, int)
*/
@Override
public void assembleExpression(final SqlExpression expression, final StringBuilder sb, final int indentLevel, final int flags)
{
QueryPart.assembleObject(expression, this, sb, indentLevel, flags | MINIINDENT | ASEXPRESSION);
}
/**
* Assemble sql clause head.
*
* @param sqlClause the sql clause
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleSqlClauseHead(
final SqlClause sqlClause,
final StringBuilder sb,
final int indentLevel,
final int flags
)
{
assembleKeyword: {
final String keyword = sqlClause.keyword();
if(keyword == null) break assembleKeyword;
indent(sb, indentLevel, isSingleLine(flags));
sb.append(keyword);
sb.append(isSingleLine(flags) ?_ :sqlClause.getKeyWordSeperator());
}
return sb;
}
/**
* Assemble sql clause body.
*
* @param sqlClause the sql clause
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleSqlClauseBody(
final SqlClause sqlClause,
final StringBuilder sb,
final int indentLevel,
final int flags
)
{
final boolean singleLine = isSingleLine(flags);
final String bodySep = sqlClause.getBodyElementSeperator(singleLine);
final String indent = !singleLine && sqlClause.isIndentationAllowed()
?QueryPart.indent(new StringBuilder(indentLevel), indentLevel, singleLine).toString()
:""
;
if(sqlClause.isIndentFirstBodyElement()){
sb.append(indent);
}
boolean notEmpty = false;
for (final Object o : sqlClause) {
if(notEmpty){
sb.append(bodySep).append(indent);
}
else {
notEmpty = true;
}
if(o instanceof SqlExpression) {
this.assembleExpression((SqlExpression)o, sb, indentLevel, flags);
}
else {
QueryPart.assembleObject(o, this, sb, indentLevel, flags | MINIINDENT | ASEXPRESSION);
}
}
return sb;
}
/**
* Assemble parenthesized list clause body.
*
* @param sqlClause the sql clause
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleParenthesizedListClauseBody(
final SqlClause sqlClause,
final StringBuilder sb,
final int indentLevel,
final int flags
)
{
indent(sb, indentLevel, isSingleLine(flags));
sb.append(par);
this.assembleSqlClauseBody(sqlClause, sb, indentLevel, flags);
sb.append(rap);
return sb;
}
/**
* Assemble sql clause.
*
* @param parentQuery the parent query
* @param sqlClause the sql clause
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
public StringBuilder assembleSqlClause(
// final TableQuery parentQuery,
final SqlClause sqlClause,
final StringBuilder sb,
final int indentLevel,
final int flags
)
{
if(sqlClause == null) return sb;
/* (12.11.2009 TM)NOTE:
* Bad instanceof switch: assembleSqlClause() is supposed to avoid boiler plate code in calling context.
* But assemble() can't be moved back do SqlClause class itself because it's QueryAssembler-dependant.
*/
if(sqlClause instanceof FROM){
return this.assembleFROM(null, (FROM)sqlClause, sb, indentLevel, flags);
}
else if(sqlClause instanceof WHERE){
return this.assembleWHERE(null, (WHERE)sqlClause, sb, indentLevel, flags);
}
else if(sqlClause instanceof ORDER_BY){
return this.assembleORDERBY(null, (ORDER_BY)sqlClause, sb, indentLevel, flags);
}
else if(sqlClause instanceof GROUP_BY){
return this.assembleGROUPBY(null, (GROUP_BY)sqlClause, sb, indentLevel, flags);
}
else if(sqlClause instanceof HAVING){
return this.assembleHAVING(null, (HAVING)sqlClause, sb, indentLevel, flags);
}
else if(sqlClause instanceof JoinClause){
return this.assembleJOIN(null, (JoinClause)sqlClause, sb, indentLevel, flags);
}
else {
throw new SQLEngineAssembleException("Unhandled SqlClause: "+sqlClause);
}
}
/**
* Assemble from.
*
* @param parentQuery the parent query
* @param from the from
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleFROM(
final TableQuery parentQuery,
final FROM from,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(from, sb, indentLevel, flags);
final String clauseSeperator = isSingleLine(flags) || isPacked(flags)?"":NEW_LINE;
final String lineSeperator = isSingleLine(flags)?" ":NEW_LINE;
final int passFlags = flags | ASEXPRESSION;
this.assembleTableExpression(from.getTable(), sb, indentLevel, passFlags);
final List joins = from.getJoins();
if(joins != null){
//joins is known to be an ArrayList
for(int i = 0, size = joins.size(); i < size; i++){
sb.append(lineSeperator).append(clauseSeperator);
this.assembleJOIN(parentQuery, joins.get(i), sb, indentLevel, passFlags);
}
}
return sb;
}
protected StringBuilder assembleJOIN(
final TableQuery parentQuery,
final JoinClause join,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(join, sb, indentLevel, flags);
final String lineSeperator = isSingleLine(flags)?" ":NEW_LINE;
final int passFlags = flags | ASEXPRESSION;
this.assembleTableExpression(join.getTable(), sb, indentLevel, passFlags);
sb.append(_ON_);
QueryPart.assembleObject(join.getJoinCondition(), this, sb, indentLevel, passFlags);
for(final SqlCondition sqlCondition : join) {
sb.append(lineSeperator);
QueryPart.assembleObject(sqlCondition, this, sb, indentLevel, passFlags);
}
return sb;
}
/**
* Assemble where.
*
* @param parentQuery the parent query
* @param where the where
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleWHERE(
final TableQuery parentQuery,
final WHERE where,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(where, sb, indentLevel, flags);
sb = this.assembleSqlClauseBody(where, sb, indentLevel, flags);
return sb;
}
/**
* Assemble groupby.
*
* @param parentQuery the parent query
* @param groupBy the group by
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleGROUPBY(
final TableQuery parentQuery,
final GROUP_BY groupBy,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(groupBy, sb, indentLevel, flags);
sb = this.assembleSqlClauseBody(groupBy, sb, indentLevel, flags);
return sb;
}
/**
* Assemble having.
*
* @param parentQuery the parent query
* @param having the having
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleHAVING(
final TableQuery parentQuery,
final HAVING having,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(having, sb, indentLevel, flags);
sb = this.assembleSqlClauseBody(having, sb, indentLevel, flags|ASEXPRESSION);
return sb;
}
/**
* Assemble orderby.
*
* @param parentQuery the parent query
* @param orderby the orderby
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleORDERBY(
final TableQuery parentQuery,
final ORDER_BY orderby,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(orderby, sb, indentLevel, flags);
sb = this.assembleSqlClauseBody(orderby, sb, indentLevel, flags);
return sb;
}
/**
* Assemble select row limit.
*
* @param query the query
* @param sb the sb
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @param indentLevel the indent level
* @return the string builder
*/
protected StringBuilder assembleSelectRowLimit(
final SELECT query,
final StringBuilder sb,
final int flags,
final String clauseSeperator,
final String newLine,
final int indentLevel
)
{
final Integer skip = query.getOffsetSkipCount();
final Integer range = query.getFetchFirstRowCount();
if(skip != null){
sb.append(newLine).append(clauseSeperator).append(OFFSET_).append(skip).append(skip==1?_ROW:_ROWS);
}
if(range != null){
sb.append(newLine);
if(skip != null){
sb.append(clauseSeperator);
}
sb.append(FETCH_FIRST_).append(range).append(range==1?_ROW_ONLY:_ROWS_ONLY);
}
return sb;
}
/**
* Assemble set.
*
* @param parentQuery the parent query
* @param set the set
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleSET(
final TableQuery parentQuery,
final SET set,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(set, sb, indentLevel, flags);
sb = this.assembleSqlClauseBody(set, sb, indentLevel, flags);
return sb;
}
/**
* Assemble assignment columns clause.
*
* @param parentQuery the parent query
* @param columns the columns
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleAssignmentColumnsClause(
final TableQuery parentQuery,
final AssignmentColumnsClause columns,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(columns, sb, indentLevel, flags);
sb = this.assembleParenthesizedListClauseBody(columns, sb, indentLevel, flags);
return sb;
}
/**
* Assemble assignment values clause.
*
* @param parentQuery the parent query
* @param values the values
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
*/
protected StringBuilder assembleAssignmentValuesClause(
final TableQuery parentQuery,
final AssignmentValuesClause values,
StringBuilder sb,
final int indentLevel,
final int flags
)
{
sb = this.assembleSqlClauseHead(values, sb, indentLevel, flags);
sb = this.assembleParenthesizedListClauseBody(values, sb, indentLevel, flags|ASEXPRESSION);
return sb;
}
/**
* Assemble select.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @return the string builder
* @return
*/
protected StringBuilder assembleSELECT(
final SELECT query,
final StringBuilder sb,
final int indentLevel,
final int flags,
final String clauseSeperator,
final String newLine
)
{
indent(sb, indentLevel, isSingleLine(flags));
sb.append(query.keyword());
this.assembleSelectDISTINCT(query, sb, indentLevel, flags);
this.assembleSelectItems(query, sb, flags, indentLevel, newLine);
this.assembleSelectSqlClauses(query, sb, indentLevel, flags|ASEXPRESSION, clauseSeperator, newLine);
this.assembleSelectRowLimit(query, sb, flags, clauseSeperator, newLine, indentLevel);
this.assembleAppendSELECTs(query, sb, indentLevel, flags, clauseSeperator, newLine);
return sb;
}
/**
* Assemble append selec ts.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @return the string builder
*/
protected StringBuilder assembleAppendSELECTs(
final SELECT query,
final StringBuilder sb,
final int indentLevel,
final int flags,
final String clauseSeperator,
final String newLine
)
{
SELECT appendSelect = query.getUnionSelect();
if(appendSelect != null) {
this.assembleAppendSelect(appendSelect, sb, indentLevel, flags, clauseSeperator, newLine, UNION);
return sb;
}
appendSelect = query.getUnionAllSelect();
if(appendSelect != null) {
this.assembleAppendSelect(appendSelect, sb, indentLevel, flags, clauseSeperator, newLine, UNION_ALL);
return sb;
}
appendSelect = query.getIntersectSelect();
if(appendSelect != null) {
this.assembleAppendSelect(appendSelect, sb, indentLevel, flags, clauseSeperator, newLine, INTERSECT);
return sb;
}
appendSelect = query.getExceptSelect();
if(appendSelect != null) {
this.assembleAppendSelect(appendSelect, sb, indentLevel, flags, clauseSeperator, newLine, EXCEPT);
return sb;
}
return sb;
}
/**
* Assemble append select.
*
* @param appendSelect the append select
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @param appendKeyword the append keyword
* @return the string builder
*/
protected StringBuilder assembleAppendSelect(
final SELECT appendSelect,
final StringBuilder sb,
final int indentLevel,
final int flags,
final String clauseSeperator,
final String newLine,
final String appendKeyword
)
{
sb.append(clauseSeperator).append(newLine).append(appendKeyword).append(newLine).append(clauseSeperator);
QueryPart.assembleObject(appendSelect, this, sb, indentLevel, flags &~MINIINDENT &~ASEXPRESSION);
return sb;
}
public StringBuilder assembleObject(final Object object, final StringBuilder sb, final int indentLevel, final int flags)
{
if(object == null) {
sb.append((String)null);
}
else if(object instanceof AssembableSqlExpression){
((AssembableSqlExpression)object).assemble(this, sb, indentLevel, flags);
}
else {
this.assembleStringValue(object.toString(), sb, indentLevel, flags);
}
return sb;
}
/**
* Assemble select sql clauses.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @return the string builder
*/
protected StringBuilder assembleSelectSqlClauses(
final SELECT query,
final StringBuilder sb,
final int indentLevel,
final int flags,
final String clauseSeperator,
final String newLine
)
{
for(final SqlClause sqlClause : query.getSqlClauses()) {
if(sqlClause == null) continue;
sb.append(newLine).append(clauseSeperator);
this.assembleSqlClause(sqlClause, sb, indentLevel, flags);
}
return sb;
}
/**
* Assemble insert.
*
* @param query the query
* @param sb the sb
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @param indentLevel the indent level
* @return the string builder
* @return
*/
protected StringBuilder assembleINSERT(
final INSERT query,
final StringBuilder sb,
final int flags,
final String clauseSeperator,
final String newLine,
final int indentLevel
)
{
indent(sb, indentLevel, isSingleLine(flags)).append(query.keyword()).append(_INTO_);
this.assembleTableIdentifier(query.getTable(), sb, indentLevel, flags);
sb.append(newLine);
this.assembleAssignmentColumnsClause(query, query.getColumnsClause(), sb, indentLevel, flags|UNQUALIFIED);
sb.append(newLine);
final SELECT valueSelect = query.filterSelect();
if(valueSelect != null){
sb.append(clauseSeperator);
QueryPart.assembleObject(valueSelect, this, sb, indentLevel, flags);
}
else{
final AssignmentValuesClause values = query.getValuesClause();
if(values != null) {
this.assembleAssignmentValuesClause(query, values, sb, indentLevel, flags);
}
else{
indent(sb, indentLevel, isSingleLine(flags)).append(DEFAULT_VALUES);
}
}
return sb;
}
/**
* Assemble update.
*
* @param query the query
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @return the string builder
* @return
*/
protected StringBuilder assembleUPDATE(
final UPDATE query,
final StringBuilder sb,
final int indentLevel,
final int flags,
final String clauseSeperator,
final String newLine
)
{
indent(sb, indentLevel, isSingleLine(flags));
sb.append(query.keyword());
sb.append(_);
this.assembleTableIdentifier(query.getTable(), sb, indentLevel, flags);
final SET set = query.getSetClause();
sb.append(newLine);
this.assembleSET(query, set, sb, indentLevel, flags);
final FROM from = query.getFromClause();
if(from != null) {
sb.append(newLine).append(clauseSeperator);
this.assembleFROM(query, from, sb, indentLevel, flags);
}
final WHERE where = query.getWhereClause();
if(where != null){
sb.append(newLine).append(clauseSeperator);
this.assembleWHERE(query, where, sb, indentLevel, flags);
}
return sb;
}
/**
* Assemble delete.
*
* @param query the query
* @param sb the sb
* @param flags the flags
* @param clauseSeperator the clause seperator
* @param newLine the new line
* @param indentLevel the indent level
* @return the string builder
* @return
*/
protected StringBuilder assembleDELETE(
final DELETE query,
final StringBuilder sb,
final int flags,
final String clauseSeperator,
final String newLine,
final int indentLevel
)
{
//the first FROM is mandatory
indent(sb, indentLevel, isSingleLine(flags)).append(query.keyword()).append(_FROM_);
this.assembleTableIdentifier(query.getTable(), sb, indentLevel, flags);
final FROM from = query.getFromClause();
if(from != null) {
sb.append(newLine).append(clauseSeperator);
this.assembleFROM(query, from, sb, indentLevel, flags);
}
final WHERE where = query.getWhereClause();
if(where != null){
sb.append(newLine).append(clauseSeperator);
this.assembleWHERE(query, where, sb, indentLevel, flags);
}
return sb;
}
/**
* Assemble double quoted expression.
*
* @param expression the expression
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleDoubleQuotedExpression(com.xdev.jadoth.sqlengine.internal.DoubleQuotedExpression, java.lang.StringBuilder, int, int)
*/
@Override
public StringBuilder assembleDoubleQuotedExpression(
final DoubleQuotedExpression expression, final StringBuilder sb, final int indentLevel, final int flags
)
{
final Object expressionObject = expression.getExpressionObject();
if(expressionObject == null){
return sb.append((String)null);
}
sb.append(qt);
QueryPart.assembleObject(expressionObject, this, sb, indentLevel, flags | ESCAPE_DBL_QUOTES);
sb.append(qt);
return sb;
}
/**
* Assemble quoted expression.
*
* @param expression the expression
* @param sb the sb
* @param indentLevel the indent level
* @param flags the flags
* @return the string builder
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleQuotedExpression(com.xdev.jadoth.sqlengine.internal.QuotedExpression, java.lang.StringBuilder, int, int)
*/
@Override
public StringBuilder assembleQuotedExpression(
final QuotedExpression expression, final StringBuilder sb, final int indentLevel, final int flags
)
{
final Object expressionObject = expression.getExpressionObject();
if(expressionObject == null){
return sb.append((String)null);
}
sb.append(apo);
QueryPart.assembleObject(expressionObject, this, sb, indentLevel, flags | ESCAPE_QUOTES);
sb.append(apo);
return sb;
}
///////////////////////////////////////////////////////////////////////////
// override methods //
/////////////////////
/**
* @return
*/
@Override
public DateFormat getDateFormatDATE()
{
return dateToDATE;
}
/**
* @return
*/
@Override
public DateFormat getDateFormatTIME()
{
return dateToTIME;
}
/**
* @return
*/
@Override
public DateFormat getDateFormatTIMESTAMP()
{
return dateToTIMESTAMP;
}
@Override
public StringBuilder assembleDateTimeExpression(final SqlTimestamp dateTimeExpression, final StringBuilder sb)
{
sb.append(
dateTimeExpression instanceof SqlDate ?SQL.LANG.DATE
:dateTimeExpression instanceof SqlTime ?SQL.LANG.TIME
:SQL.LANG.TIMESTAMP
)
.append(_).append(apo)
.append(dateTimeExpression.getDateFormat(this).format(dateTimeExpression.getDate()))
.append(apo)
;
return sb;
}
/**
* @param column
* @param sb
* @param flags
* @return
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleColumnQualifier(com.xdev.jadoth.sqlengine.internal.SqlColumn, java.lang.StringBuilder, int)
*/
@Override
public StringBuilder assembleColumnQualifier(final SqlColumn column, final StringBuilder sb, final int flags)
{
final TableExpression owner = column.getOwner();
String qualifier = getAlias(owner);
if(qualifier == null || QueryPart.isQualifyByTable(flags)){
qualifier = owner.toString();
}
return sb.append(qualifier).append(dot);
}
/**
* @param column
* @param sb
* @param flags
* @return
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleColumn(com.xdev.jadoth.sqlengine.internal.SqlColumn, java.lang.StringBuilder, int)
*/
@Override
public StringBuilder assembleColumn(
final SqlColumn column, final StringBuilder sb, final int indentLevel, int flags
)
{
final TableExpression owner = column.getOwner();
final DbmsAdaptor dbms = this.getDbmsAdaptor();
final boolean delimColumn = dbms.getConfiguration().isDelimitColumnIdentifiers()
|| QueryPart.isDelimitColumnIdentifiers(flags)
;
final char delim = dbms.getIdentifierDelimiter();
flags |= QueryPart.bitDelimitColumnIdentifiers(
this.getDbmsAdaptor().getConfiguration().isDelimitColumnIdentifiers()
);
if(delimColumn){
sb.append(delim);
}
if(owner != null && !QueryPart.isUnqualified(flags)) {
this.assembleColumnQualifier(column, sb, flags);
}
QueryPart.assembleObject(column.getExpressionObject(), this, sb, indentLevel, flags);
if(delimColumn){
sb.append(delim);
}
return sb;
}
/**
* @param identifier
* @param sb
* @param flags
* @return
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleDelimitedIdentifier(java.lang.String, java.lang.StringBuilder, int)
*/
@Override
public StringBuilder assembleDelimitedIdentifier(final String identifier, final StringBuilder sb, final int flags)
{
return sb.append(IDENTIFIER_DELIMITER).append(identifier).append(IDENTIFIER_DELIMITER);
}
/**
* @param object
* @param sb
* @param indentLevel
* @param flags
* @return
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleObject(java.lang.Object, java.lang.StringBuilder, int, int)
*/
@Override
public StringBuilder assembleStringValue(final String s, final StringBuilder sb, final int indentLevel, final int flags)
{
final DbmsAdaptor dbms = this.getDbmsAdaptor();
if(dbms.getConfiguration().isAutoEscapeReservedWords() && dbms.getSyntax().isReservedWord(s)){
final char d = dbms.getIdentifierDelimiter();
sb.append(d).append(s).append(d);
return sb;
}
final int length = s.length();
final char[] chars = new char[length];
s.getChars(0, length, chars, 0);
sb.ensureCapacity(sb.length() + length + 10);
if (QueryPart.isEscapeQuotes(flags)) {
for(final char c : chars){
if(c == apo) {
sb.append(apo);
}
sb.append(c);
}
}
else if (QueryPart.isEscapeDoubleQuotes(flags)) {
for(final char c : chars){
if(c == qt) {
sb.append(qt);
}
sb.append(c);
}
}
else {
sb.append(s);
}
return sb;
}
/**
* @param tableExpression
* @param sb
* @param indentLevel
* @param flags
* @return
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleTableExpression(com.xdev.jadoth.sqlengine.internal.interfaces.TableExpression, java.lang.StringBuilder, int, int)
*/
@Override
public StringBuilder assembleTableExpression(
final TableExpression tableExpression, final StringBuilder sb, final int indentLevel, final int flags
)
{
if(tableExpression instanceof SqlTableIdentity){
return this.assembleTableIdentifier((SqlTableIdentity)tableExpression, sb, indentLevel, flags);
}
QueryPart.assembleObject(tableExpression, this, sb, indentLevel, flags);
if(!isOmitAlias(flags)){
final String alias = TableExpression.Utils.getAlias(tableExpression);
if(alias != null) {
sb.append(_);
sb.append(alias);
}
}
return sb;
}
/**
* @param table
* @param sb
* @param indentLevel
* @param flags
* @return
* @see com.xdev.jadoth.sqlengine.dbms.DbmsDMLAssembler#assembleTableIdentifier(com.xdev.jadoth.sqlengine.internal.tables.SqlTableIdentity, java.lang.StringBuilder, int, int)
*/
@Override
public StringBuilder assembleTableIdentifier(
final SqlTableIdentity table, final StringBuilder sb, final int indentLevel, final int flags
)
{
final DbmsAdaptor dbms = this.getDbmsAdaptor();
final DbmsSyntax syntax = dbms.getSyntax();
final DbmsConfiguration config = dbms.getConfiguration();
final char delim = dbms.getIdentifierDelimiter();
final SqlTableIdentity.Sql sql = table.sql();
final String schema = sql.schema;
final String name = sql.name;
final boolean delimTable = QueryPart.isDelimitTableIdentifiers(flags)
|| config.isDelimitTableIdentifiers()
|| config.isAutoEscapeReservedWords()
&&
(syntax.isReservedWord(name) || schema != null && syntax.isReservedWord(schema))
;
if(delimTable){
sb.append(delim);
}
if(schema != null){
sb.append(schema).append(dot);
}
sb.append(name);
if(delimTable){
sb.append(delim);
}
if(!isOmitAlias(flags)){
final String alias = sql.alias;
if(alias != null && alias.length() > 0){
sb.append(_);
if(config.isDelimitAliases() || config.isAutoEscapeReservedWords() && syntax.isReservedWord(alias)){
sb.append(delim).append(alias).append(delim);
}
else {
sb.append(alias);
}
}
}
return sb;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy