QueryImpl.java

  1. /*
  2. Copyright (c) 2008 Health Market Science, Inc.

  4. Licensed under the Apache License, Version 2.0 (the "License");
  5. you may not use this file except in compliance with the License.
  6. You may obtain a copy of the License at

  8.     http://www.apache.org/licenses/LICENSE-2.0

  10. Unless required by applicable law or agreed to in writing, software
  11. distributed under the License is distributed on an "AS IS" BASIS,
  12. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. See the License for the specific language governing permissions and
  14. limitations under the License.
  15. */

  17. package com.healthmarketscience.jackcess.impl.query;

  19. import java.util.ArrayList;
  20. import java.util.Collection;
  21. import java.util.Iterator;
  22. import java.util.List;

  24. import com.healthmarketscience.jackcess.RowId;
  25. import com.healthmarketscience.jackcess.impl.DatabaseImpl;
  26. import com.healthmarketscience.jackcess.impl.RowIdImpl;
  27. import com.healthmarketscience.jackcess.impl.RowImpl;
  28. import static com.healthmarketscience.jackcess.impl.query.QueryFormat.*;
  29. import com.healthmarketscience.jackcess.query.Query;
  30. import org.apache.commons.lang3.builder.ToStringBuilder;
  31. import org.apache.commons.logging.Log;
  32. import org.apache.commons.logging.LogFactory;


  35. /**
  36.  * Base class for classes which encapsulate information about an Access query.
  37.  * The {@link #toSQLString()} method can be used to convert this object into
  38.  * the actual SQL string which this query data represents.
  39.  * 
  40.  * @author James Ahlborn
  41.  */
  42. public abstract class QueryImpl implements Query
  43. {
  44.   protected static final Log LOG = LogFactory.getLog(QueryImpl.class);  

  46.   private static final Row EMPTY_ROW = new Row();

  48.   private final String _name;
  49.   private final List<Row> _rows;
  50.   private final int _objectId;
  51.   private final Type _type;
  52.   private final int _objectFlag;

  54.   protected QueryImpl(String name, List<Row> rows, int objectId, int objectFlag, 
  55.                       Type type) 
  56.   {
  57.     _name = name;
  58.     _rows = rows;
  59.     _objectId = objectId;
  60.     _type = type;
  61.     _objectFlag = objectFlag;

  63.     if(type != Type.UNKNOWN) {
  64.       short foundType = getShortValue(getQueryType(rows),
  65.                                       _type.getValue());
  66.       if(foundType != _type.getValue()) {
  67.         throw new IllegalStateException(withErrorContext(
  68.                 "Unexpected query type " + foundType));
  69.       }
  70.     }
  71.   }

  73.   /**
  74.    * Returns the name of the query.
  75.    */
  76.   @Override
  77.   public String getName() {
  78.     return _name;
  79.   }

  81.   /**
  82.    * Returns the type of the query.
  83.    */
  84.   @Override
  85.   public Type getType() {
  86.     return _type;
  87.   }

  89.   @Override
  90.   public boolean isHidden() {
  91.     return((_objectFlag & DatabaseImpl.HIDDEN_OBJECT_FLAG) != 0);
  92.   }

  94.   /**
  95.    * Returns the unique object id of the query.
  96.    */
  97.   @Override
  98.   public int getObjectId() {
  99.     return _objectId;
  100.   }

  102.   @Override
  103.   public int getObjectFlag() {
  104.     return _objectFlag;
  105.   }

  107.   /**
  108.    * Returns the rows from the system query table from which the query
  109.    * information was derived.
  110.    */
  111.   public List<Row> getRows() {
  112.     return _rows;
  113.   }

  115.   protected List<Row> getRowsByAttribute(Byte attribute) {
  116.     return getRowsByAttribute(getRows(), attribute);
  117.   }

  119.   protected Row getRowByAttribute(Byte attribute) {
  120.     return getUniqueRow(getRowsByAttribute(getRows(), attribute));
  121.   }

  123.   public Row getTypeRow() {
  124.     return getRowByAttribute(TYPE_ATTRIBUTE);
  125.   }

  127.   protected List<Row> getParameterRows() {
  128.     return getRowsByAttribute(PARAMETER_ATTRIBUTE);
  129.   }

  131.   protected Row getFlagRow() {
  132.     return getRowByAttribute(FLAG_ATTRIBUTE);
  133.   }

  135.   protected Row getRemoteDatabaseRow() {
  136.     return getRowByAttribute(REMOTEDB_ATTRIBUTE);
  137.   }

  139.   protected List<Row> getTableRows() {
  140.     return getRowsByAttribute(TABLE_ATTRIBUTE);
  141.   }

  143.   protected List<Row> getColumnRows() {
  144.     return getRowsByAttribute(COLUMN_ATTRIBUTE);
  145.   }

  147.   protected List<Row> getJoinRows() {
  148.     return getRowsByAttribute(JOIN_ATTRIBUTE);
  149.   }

  151.   protected Row getWhereRow() {
  152.     return getRowByAttribute(WHERE_ATTRIBUTE);
  153.   }

  155.   protected List<Row> getGroupByRows() {
  156.     return getRowsByAttribute(GROUPBY_ATTRIBUTE);
  157.   }

  159.   protected Row getHavingRow() {
  160.     return getRowByAttribute(HAVING_ATTRIBUTE);
  161.   }

  163.   protected List<Row> getOrderByRows() {
  164.     return getRowsByAttribute(ORDERBY_ATTRIBUTE);
  165.   }

  167.   protected abstract void toSQLString(StringBuilder builder);

  169.   protected void toSQLParameterString(StringBuilder builder) {
  170.     // handle any parameters
  171.     List<String> params = getParameters();
  172.     if(!params.isEmpty()) {
  173.       builder.append("PARAMETERS ").append(params)
  174.         .append(';').append(NEWLINE);
  175.     }
  176.   }

  178.   @Override
  179.   public List<String> getParameters() 
  180.   {
  181.     return (new RowFormatter(getParameterRows()) {
  182.         @Override protected void format(StringBuilder builder, Row row) {
  183.           String typeName = PARAM_TYPE_MAP.get(row.flag);
  184.           if(typeName == null) {
  185.             throw new IllegalStateException(withErrorContext(
  186.                 "Unknown param type " + row.flag));
  187.           }
  188.               
  189.           builder.append(row.name1).append(' ').append(typeName);
  190.           if((TEXT_FLAG.equals(row.flag)) && (getIntValue(row.extra, 0) > 0)) {
  191.             builder.append('(').append(row.extra).append(')');
  192.           }
  193.         }
  194.       }).format();
  195.   }

  197.   protected List<String> getFromTables() 
  198.   {
  199.     // grab the list of query tables
  200.     List<TableSource> tableExprs = new ArrayList<TableSource>();
  201.     for(Row table : getTableRows()) {
  202.       StringBuilder builder = new StringBuilder();

  204.       if(table.expression != null) {
  205.         toQuotedExpr(builder, table.expression).append(IDENTIFIER_SEP_CHAR);
  206.       }
  207.       if(table.name1 != null) {
  208.         toOptionalQuotedExpr(builder, table.name1, true);
  209.       }
  210.       toAlias(builder, table.name2);

  212.       String key = ((table.name2 != null) ? table.name2 : table.name1);
  213.       tableExprs.add(new SimpleTable(key, builder.toString()));
  214.     }

  216.     // combine the tables with any query joins
  217.     List<Row> joins = getJoinRows();
  218.     for(Row joinRow : joins) {
  219.         
  220.       String fromTable = joinRow.name1;
  221.       String toTable = joinRow.name2;

  223.       TableSource fromTs = null;
  224.       TableSource toTs = null;

  226.       // combine existing join expressions containing the target tables
  227.       for(Iterator<TableSource> joinIter = tableExprs.iterator(); 
  228.           (joinIter.hasNext() && ((fromTs == null) || (toTs == null))); ) {
  229.         TableSource ts = joinIter.next();

  231.         if((fromTs == null) && ts.containsTable(fromTable)) {
  232.           fromTs = ts;

  234.           // special case adding expr to existing join
  235.           if((toTs == null) && ts.containsTable(toTable)) {
  236.             toTs = ts;
  237.             break;
  238.           }

  240.           joinIter.remove();

  242.         } else if((toTs == null) && ts.containsTable(toTable)) {

  244.           toTs = ts;
  245.           joinIter.remove();
  246.         }
  247.       }

  249.       if(fromTs == null) {
  250.         fromTs = new SimpleTable(fromTable);
  251.       }
  252.       if(toTs == null) {
  253.         toTs = new SimpleTable(toTable);
  254.       }

  256.       if(fromTs == toTs) {

  258.         if(fromTs.sameJoin(joinRow.flag, joinRow.expression)) {
  259.           // easy-peasy, we just added the join expression to existing join,
  260.           // nothing more to do
  261.           continue;
  262.         }

  264.         throw new IllegalStateException(withErrorContext(
  265.                 "Inconsistent join types for " + fromTable + " and " + toTable));
  266.       }

  268.       // new join expression
  269.       tableExprs.add(new Join(fromTs, toTs, joinRow.flag, joinRow.expression));
  270.     }

  272.     // convert join objects to SQL strings
  273.     List<String> result = new AppendableList<String>();
  274.     for(TableSource ts : tableExprs) {
  275.       result.add(ts.toString());
  276.     }

  278.     return result;
  279.   }

  281.   protected String getFromRemoteDbPath() 
  282.   {
  283.     return getRemoteDatabaseRow().name1;
  284.   }

  286.   protected String getFromRemoteDbType() 
  287.   {
  288.     return getRemoteDatabaseRow().expression;
  289.   }

  291.   protected String getWhereExpression()
  292.   {
  293.     return getWhereRow().expression;
  294.   }

  296.   protected List<String> getOrderings() 
  297.   {
  298.     return (new RowFormatter(getOrderByRows()) {
  299.         @Override protected void format(StringBuilder builder, Row row) {
  300.           builder.append(row.expression);
  301.           if(DESCENDING_FLAG.equalsIgnoreCase(row.name1)) {
  302.             builder.append(" DESC");
  303.           }
  304.         }
  305.       }).format();
  306.   }

  308.   @Override
  309.   public String getOwnerAccessType() {
  310.     return(hasFlag(OWNER_ACCESS_SELECT_TYPE) ?
  311.            "WITH OWNERACCESS OPTION" : DEFAULT_TYPE);
  312.   }

  314.   protected boolean hasFlag(int flagMask)
  315.   {
  316.     return hasFlag(getFlagRow(), flagMask);
  317.   }

  319.   protected boolean supportsStandardClauses() {
  320.     return true;
  321.   }

  323.   /**
  324.    * Returns the actual SQL string which this query data represents.
  325.    */
  326.   @Override
  327.   public String toSQLString() 
  328.   {
  329.     StringBuilder builder = new StringBuilder();
  330.     if(supportsStandardClauses()) {
  331.       toSQLParameterString(builder);
  332.     }

  334.     toSQLString(builder);

  336.     if(supportsStandardClauses()) {

  338.       String accessType = getOwnerAccessType();
  339.       if(!DEFAULT_TYPE.equals(accessType)) {
  340.         builder.append(NEWLINE).append(accessType);
  341.       }
  342.       
  343.       builder.append(';');
  344.     }
  345.     return builder.toString();
  346.   }

  348.   @Override
  349.   public String toString() {
  350.     return ToStringBuilder.reflectionToString(this);
  351.   }

  353.   /**
  354.    * Creates a concrete Query instance from the given query data.
  355.    *
  356.    * @param objectFlag the flag indicating the type of the query
  357.    * @param name the name of the query
  358.    * @param rows the rows from the system query table containing the data
  359.    *             describing this query
  360.    * @param objectId the unique object id of this query
  361.    *
  362.    * @return a Query instance for the given query data
  363.    */
  364.   public static QueryImpl create(int objectFlag, String name, List<Row> rows, 
  365.                                  int objectId)
  366.   {
  367.     // remove other object flags before testing for query type
  368.     int objTypeFlag = objectFlag & OBJECT_FLAG_MASK;

  370.     if(objTypeFlag == 0) {
  371.       // sometimes the query rows tell a different story
  372.       short rowTypeFlag = getShortValue(getQueryType(rows), objTypeFlag);
  373.       Type rowType = TYPE_MAP.get(rowTypeFlag);
  374.       if((rowType != null) && (rowType.getObjectFlag() != objTypeFlag)) {
  375.         // use row type instead of object flag type
  376.         objTypeFlag = rowType.getObjectFlag();
  377.       }
  378.     }

  380.     try {
  381.       switch(objTypeFlag) {
  382.       case SELECT_QUERY_OBJECT_FLAG:
  383.         return new SelectQueryImpl(name, rows, objectId, objectFlag);
  384.       case MAKE_TABLE_QUERY_OBJECT_FLAG:
  385.         return new MakeTableQueryImpl(name, rows, objectId, objectFlag);
  386.       case APPEND_QUERY_OBJECT_FLAG:
  387.         return new AppendQueryImpl(name, rows, objectId, objectFlag);
  388.       case UPDATE_QUERY_OBJECT_FLAG:
  389.         return new UpdateQueryImpl(name, rows, objectId, objectFlag);
  390.       case DELETE_QUERY_OBJECT_FLAG:
  391.         return new DeleteQueryImpl(name, rows, objectId, objectFlag);
  392.       case CROSS_TAB_QUERY_OBJECT_FLAG:
  393.         return new CrossTabQueryImpl(name, rows, objectId, objectFlag);
  394.       case DATA_DEF_QUERY_OBJECT_FLAG:
  395.         return new DataDefinitionQueryImpl(name, rows, objectId, objectFlag);
  396.       case PASSTHROUGH_QUERY_OBJECT_FLAG:
  397.         return new PassthroughQueryImpl(name, rows, objectId, objectFlag);
  398.       case UNION_QUERY_OBJECT_FLAG:
  399.         return new UnionQueryImpl(name, rows, objectId, objectFlag);
  400.       default:
  401.         // unknown querytype
  402.         throw new IllegalStateException(withErrorContext(
  403.                 "unknown query object flag " + objTypeFlag, name));
  404.       }
  405.     } catch(IllegalStateException e) {
  406.       LOG.warn(withErrorContext("Failed parsing query", name), e);
  407.     }

  409.     // return unknown query
  410.     return new UnknownQueryImpl(name, rows, objectId, objectFlag);
  411.   }

  413.   private static Short getQueryType(List<Row> rows)
  414.   {
  415.     return getFirstRowByAttribute(rows, TYPE_ATTRIBUTE).flag;
  416.   }

  418.   private static List<Row> getRowsByAttribute(List<Row> rows, Byte attribute) {
  419.     List<Row> result = new ArrayList<Row>();
  420.     for(Row row : rows) {
  421.       if(attribute.equals(row.attribute)) {
  422.         result.add(row);
  423.       }
  424.     }
  425.     return result;
  426.   }

  428.   private static Row getFirstRowByAttribute(List<Row> rows, Byte attribute) {
  429.     for(Row row : rows) {
  430.       if(attribute.equals(row.attribute)) {
  431.         return row;
  432.       }
  433.     }
  434.     return EMPTY_ROW;
  435.   }

  437.   protected Row getUniqueRow(List<Row> rows) {
  438.     if(rows.size() == 1) {
  439.       return rows.get(0);
  440.     }
  441.     if(rows.isEmpty()) {
  442.       return EMPTY_ROW;
  443.     }
  444.     throw new IllegalStateException(withErrorContext(
  445.             "Unexpected number of rows for" + rows));
  446.   }

  448.   protected static List<Row> filterRowsByFlag(
  449.       List<Row> rows, final short flag) 
  450.   {
  451.     return new RowFilter() {
  452.         @Override protected boolean keep(Row row) {
  453.           return hasFlag(row, flag);
  454.         }
  455.       }.filter(rows);
  456.   }

  458.   protected static List<Row> filterRowsByNotFlag(
  459.       List<Row> rows, final short flag) 
  460.   {
  461.     return new RowFilter() {
  462.         @Override protected boolean keep(Row row) {
  463.           return !hasFlag(row, flag);
  464.         }
  465.       }.filter(rows);
  466.   }

  468.   protected static boolean hasFlag(Row row, int flagMask)
  469.   {
  470.     return((getShortValue(row.flag, 0) & flagMask) != 0);
  471.   }

  473.   protected static short getShortValue(Short s, int def) {
  474.     return ((s != null) ? (short)s : (short)def);
  475.   }

  477.   protected static int getIntValue(Integer i, int def) {
  478.     return ((i != null) ? (int)i : def);
  479.   }

  481.   protected static StringBuilder toOptionalQuotedExpr(StringBuilder builder, 
  482.                                                       String fullExpr,
  483.                                                       boolean isIdentifier)
  484.   {
  485.     String[] exprs = (isIdentifier ? 
  486.                       IDENTIFIER_SEP_PAT.split(fullExpr) : 
  487.                       new String[]{fullExpr});
  488.     for(int i = 0; i < exprs.length; ++i) {
  489.       String expr = exprs[i];
  490.       if(QUOTABLE_CHAR_PAT.matcher(expr).find()) {
  491.         toQuotedExpr(builder, expr);
  492.       } else {
  493.         builder.append(expr);
  494.       }
  495.       if(i < (exprs.length - 1)) {
  496.         builder.append(IDENTIFIER_SEP_CHAR);
  497.       }
  498.     }
  499.     return builder;
  500.   }

  502.   protected static StringBuilder toQuotedExpr(StringBuilder builder, 
  503.                                               String expr)
  504.   {
  505.     return (!isQuoted(expr) ? 
  506.             builder.append('[').append(expr).append(']') :
  507.             builder.append(expr));
  508.   }

  510.   protected static boolean isQuoted(String expr) {
  511.     return ((expr.length() >= 2) && 
  512.             (expr.charAt(0) == '[') && (expr.charAt(expr.length() - 1) == ']'));
  513.   }

  515.   protected static StringBuilder toRemoteDb(StringBuilder builder,
  516.                                             String remoteDbPath,
  517.                                             String remoteDbType) {
  518.     if((remoteDbPath != null) || (remoteDbType != null)) {
  519.       // note, always include path string, even if empty
  520.       builder.append(" IN '");
  521.       if(remoteDbPath != null) {
  522.         builder.append(remoteDbPath);
  523.       }
  524.       builder.append('\'');
  525.       if(remoteDbType != null) {
  526.         builder.append(" [").append(remoteDbType).append(']');
  527.       }
  528.     }
  529.     return builder;
  530.   }

  532.   protected static StringBuilder toAlias(StringBuilder builder,
  533.                                          String alias) {
  534.     if(alias != null) {
  535.       toOptionalQuotedExpr(builder.append(" AS "), alias, false);
  536.     }
  537.     return builder;
  538.   }

  540.   private String withErrorContext(String msg) {
  541.     return withErrorContext(msg, getName());
  542.   }

  544.   private static String withErrorContext(String msg, String queryName) {
  545.     return msg + " (Query: " + queryName + ")";
  546.   }


  549.   private static final class UnknownQueryImpl extends QueryImpl
  550.   {
  551.     private UnknownQueryImpl(String name, List<Row> rows, int objectId, 
  552.                              int objectFlag) 
  553.     {
  554.       super(name, rows, objectId, objectFlag, Type.UNKNOWN);
  555.     }

  557.     @Override
  558.     protected void toSQLString(StringBuilder builder) {
  559.       throw new UnsupportedOperationException();
  560.     }
  561.   }

  563.   /**
  564.    * Struct containing the information from a single row of the system query
  565.    * table.
  566.    */
  567.   public static final class Row
  568.   {
  569.     private final RowId _id;
  570.     public final Byte attribute;
  571.     public final String expression;
  572.     public final Short flag;
  573.     public final Integer extra;
  574.     public final String name1;
  575.     public final String name2;
  576.     public final Integer objectId;
  577.     public final byte[] order;

  579.     private Row() {
  580.       this._id = null;
  581.       this.attribute = null;
  582.       this.expression = null;
  583.       this.flag = null;
  584.       this.extra = null;
  585.       this.name1 = null;
  586.       this.name2= null;
  587.       this.objectId = null;
  588.       this.order = null;
  589.     }

  591.     public Row(com.healthmarketscience.jackcess.Row tableRow) {
  592.       this(tableRow.getId(),
  593.            tableRow.getByte(COL_ATTRIBUTE),
  594.            tableRow.getString(COL_EXPRESSION),
  595.            tableRow.getShort(COL_FLAG),
  596.            tableRow.getInt(COL_EXTRA),
  597.            tableRow.getString(COL_NAME1),
  598.            tableRow.getString(COL_NAME2),
  599.            tableRow.getInt(COL_OBJECTID),
  600.            tableRow.getBytes(COL_ORDER));
  601.     }

  603.     public Row(RowId id, Byte attribute, String expression, Short flag,
  604.                Integer extra, String name1, String name2,
  605.                Integer objectId, byte[] order)
  606.     {
  607.       this._id = id;
  608.       this.attribute = attribute;
  609.       this.expression = expression;
  610.       this.flag = flag;
  611.       this.extra = extra;
  612.       this.name1 = name1;
  613.       this.name2= name2;
  614.       this.objectId = objectId;
  615.       this.order = order;
  616.     }

  618.     public com.healthmarketscience.jackcess.Row toTableRow()
  619.     {
  620.       com.healthmarketscience.jackcess.Row tableRow = new RowImpl((RowIdImpl)_id);

  622.       tableRow.put(COL_ATTRIBUTE, attribute);
  623.       tableRow.put(COL_EXPRESSION, expression);
  624.       tableRow.put(COL_FLAG, flag);
  625.       tableRow.put(COL_EXTRA, extra);
  626.       tableRow.put(COL_NAME1, name1);
  627.       tableRow.put(COL_NAME2, name2);
  628.       tableRow.put(COL_OBJECTID, objectId);
  629.       tableRow.put(COL_ORDER, order);

  631.       return tableRow;
  632.     }

  634.     @Override
  635.     public String toString() {
  636.       return ToStringBuilder.reflectionToString(this);
  637.     }
  638.   }

  640.   protected static abstract class RowFormatter
  641.   {
  642.     private final List<Row> _list;

  644.     protected RowFormatter(List<Row> list) {
  645.       _list = list;
  646.     }

  648.     public List<String> format() {
  649.       return format(new AppendableList<String>());
  650.     }

  652.     public List<String> format(List<String> strs) {
  653.       for(Row row : _list) {
  654.         StringBuilder builder = new StringBuilder();
  655.         format(builder, row);
  656.         strs.add(builder.toString());
  657.       }
  658.       return strs;
  659.     }

  661.     protected abstract void format(StringBuilder builder, Row row);
  662.   }

  664.   protected static abstract class RowFilter
  665.   {
  666.     protected RowFilter() {
  667.     }

  669.     public List<Row> filter(List<Row> list) {
  670.       for(Iterator<Row> iter = list.iterator(); iter.hasNext(); ) {
  671.         if(!keep(iter.next())) {
  672.           iter.remove();
  673.         }
  674.       }
  675.       return list;
  676.     }

  678.     protected abstract boolean keep(Row row);
  679.   }

  681.   protected static class AppendableList<E> extends ArrayList<E>
  682.   {
  683.     private static final long serialVersionUID = 0L;

  685.     protected AppendableList() {
  686.     }

  688.     protected AppendableList(Collection<? extends E> c) {
  689.       super(c);
  690.     }

  692.     protected String getSeparator() {
  693.       return ", ";
  694.     }

  696.     @Override
  697.     public String toString() {
  698.       StringBuilder builder = new StringBuilder();
  699.       for(Iterator<E> iter = iterator(); iter.hasNext(); ) {
  700.         builder.append(iter.next().toString());
  701.         if(iter.hasNext()) {
  702.           builder.append(getSeparator());
  703.         }
  704.       }
  705.       return builder.toString();
  706.     }
  707.   }

  709.   /**
  710.    * Base type of something which provides table data in a query
  711.    */
  712.   private static abstract class TableSource
  713.   {
  714.     @Override
  715.     public String toString() {
  716.       StringBuilder sb = new StringBuilder();
  717.       toString(sb, true);
  718.       return sb.toString();
  719.     }

  721.     protected abstract void toString(StringBuilder sb, boolean isTopLevel);

  723.     public abstract boolean containsTable(String table);

  725.     public abstract boolean sameJoin(short type, String on);
  726.   }

  728.   /**
  729.    * Table data provided by a single table expression.
  730.    */
  731.   private static final class SimpleTable extends TableSource
  732.   {
  733.     private final String _tableName;
  734.     private final String _tableExpr;

  736.     private SimpleTable(String tableName) {
  737.       this(tableName, toOptionalQuotedExpr(
  738.                new StringBuilder(), tableName, true).toString());
  739.     }

  741.     private SimpleTable(String tableName, String tableExpr) {
  742.       _tableName = tableName;
  743.       _tableExpr = tableExpr;
  744.     }

  746.     @Override
  747.     protected void toString(StringBuilder sb, boolean isTopLevel) {
  748.       sb.append(_tableExpr);
  749.     }

  751.     @Override
  752.     public boolean containsTable(String table) {
  753.       return _tableName.equalsIgnoreCase(table);
  754.     }

  756.     @Override
  757.     public boolean sameJoin(short type, String on) {
  758.       return false;
  759.     }
  760.   }

  762.   /**
  763.    * Table data provided by a join expression.
  764.    */
  765.   private final class Join extends TableSource
  766.   {
  767.     private final TableSource _from;
  768.     private final TableSource _to;
  769.     private final short _jType;
  770.     // combine all the join expressions with "AND"
  771.     private final List<String> _on = new AppendableList<String>() {
  772.       private static final long serialVersionUID = 0L;
  773.       @Override
  774.       protected String getSeparator() {
  775.         return ") AND (";
  776.       }
  777.     };

  779.     private Join(TableSource from, TableSource to, short type, String on) {
  780.       _from = from;
  781.       _to = to;
  782.       _jType = type;
  783.       _on.add(on);
  784.     }

  786.     @Override
  787.     protected void toString(StringBuilder sb, boolean isTopLevel) {
  788.       String joinType = JOIN_TYPE_MAP.get(_jType);
  789.       if(joinType == null) {
  790.         throw new IllegalStateException(withErrorContext(
  791.                                             "Unknown join type " + _jType));
  792.       }

  794.       if(!isTopLevel) {
  795.         sb.append("(");
  796.       }

  798.       _from.toString(sb, false);
  799.       sb.append(joinType);
  800.       _to.toString(sb, false);
  801.       sb.append(" ON ");

  803.       boolean multiOnExpr = (_on.size() > 1);
  804.       if(multiOnExpr) {
  805.         sb.append("(");
  806.       }
  807.       sb.append(_on);
  808.       if(multiOnExpr) {
  809.         sb.append(")");
  810.       }

  812.       if(!isTopLevel) {
  813.         sb.append(")");
  814.       }
  815.     }

  817.     @Override
  818.     public boolean containsTable(String table) {
  819.       return _from.containsTable(table) || _to.containsTable(table);
  820.     }

  822.     @Override
  823.     public boolean sameJoin(short type, String on) {
  824.       if(_jType == type) {
  825.         // note, AND conditions are added in _reverse_ order
  826.         _on.add(0, on);
  827.         return true;
  828.       }
  829.       return false;
  830.     }
  831.   }
  832. }
Created with JaCoCo 0.8.2.201808211720