net.sf.jsqlparser.statement.select.SelectItem Java Examples

private void validate() throws ParseException {
    List<SelectItem> selectItems = sqlCommandInfoHolder.getSelectItems();
    List<SelectItem> filteredItems = Lists.newArrayList(Iterables.filter(selectItems, new Predicate<SelectItem>() {
        @Override
        public boolean apply(SelectItem selectItem) {
            try {
                if (SelectExpressionItem.class.isInstance(selectItem)
                        && Column.class.isInstance(((SelectExpressionItem) selectItem).getExpression())) {
                    return true;
                }
            } catch (NullPointerException e) {
                return false;
            }
            return false;
        }
    }));

    SqlUtils.isFalse((selectItems.size() >1
            || SqlUtils.isSelectAll(selectItems))
            && sqlCommandInfoHolder.isDistinct(),"cannot run distinct one more than one column");
    SqlUtils.isFalse(sqlCommandInfoHolder.getGoupBys().size() == 0 && selectItems.size()!=filteredItems.size() && !SqlUtils.isSelectAll(selectItems)
            && !SqlUtils.isCountAll(selectItems)&& !sqlCommandInfoHolder.isTotalGroup(),"illegal expression(s) found in select clause.  Only column names supported");
}
 

@Test
public void test() {
    Select select = select("select max(name),code,min(aa),nvl(ab,0),heh from user where a > 100");
    List<SelectItem> selectItems = ((PlainSelect) select.getSelectBody()).getSelectItems();
    for (SelectItem item : selectItems) {
        if (item instanceof SelectExpressionItem) {
            Expression exp = ((SelectExpressionItem) item).getExpression();
            if (exp instanceof Function) {
                System.out.println("Function:" + item.toString());
            } else {
                System.out.println("Not a function:" + exp.toString());
            }
        } else {
            System.out.println("Not a function:" + item.toString());
        }
    }
}
 

private void initColumns(Select select) {
  columns = new ArrayList<>();
  aliases = new ArrayList<>();
  select.getSelectBody().accept(new SelectVisitorAdapter() {
    @Override
    public void visit(PlainSelect plainSelect) {
      for (SelectItem selectItem : plainSelect.getSelectItems()) {
        selectItem.accept(new SelectItemVisitor() {
          private boolean foundColumn = false;

          @Override
          public void visit(SelectExpressionItem selectExpressionItem) {
            selectExpressionItem.getExpression().accept(new ExpressionVisitorAdapter() {
              @Override
              public void visit(Column column) {
                registerColumn(column, selectExpressionItem.getAlias());
                foundColumn = true;
              }
            });
            if (!foundColumn) {
              registerColumn(null, selectExpressionItem.getAlias());
            }
          }

          @Override
          public void visit(AllTableColumns allTableColumns) {
            registerAllTableColumns(allTableColumns.getTable());
          }

          @Override
          public void visit(AllColumns allColumns) {
            for (Table table : tables) {
              registerAllTableColumns(table);
            }
          }
        });
      }
    }
  });
}
 

/**
 * Erase table base alias
 * @param lsel
 * @param tholder
 * @return
 */
private List<SelectItem> preprocessSelect(List<SelectItem> lsel, FromHolder tholder){
	for(SelectItem sel : lsel) {
		sel.accept(new ExpVisitorEraseAliasTableBaseBuilder(tholder.getBaseAliasTable()));
	}
	return lsel;
}
 

private Expression getExpression(SelectItem item, Table table) {
	SelectExpressionItem rightSelectItem = (SelectExpressionItem) item;
	Expression rightExp = rightSelectItem.getExpression();
	if (rightExp instanceof Column) {
		Column c = (Column) rightExp;
		if (c.getTable() == null) {
			c.setTable(table);
		}
	}
	return rightExp;
}
 

@Test
public void test2() {
    Select select = select("select distinct(name) from user where a > 100");
    List<SelectItem> selectItems = ((PlainSelect) select.getSelectBody()).getSelectItems();
    for (SelectItem item : selectItems) {
        if (item instanceof Function) {
            System.out.println("Function:" + item.toString());
        } else {
            System.out.println("Not a function:" + item.toString());
        }
    }
}
 

@Override
public void visit(PlainSelect plainSelect) {

    // 访问 select
    if (plainSelect.getSelectItems() != null) {
        for (SelectItem item : plainSelect.getSelectItems()) {
            item.accept(new SelectItemVisitorImpl());
        }
    }

    // 访问from
    FromItem fromItem = plainSelect.getFromItem();
    FromItemVisitorImpl fromItemVisitorImpl = new FromItemVisitorImpl();
    fromItem.accept(fromItemVisitorImpl);

    if (fromItemVisitorImpl.getSubSelect() != null) {
        plainSelect.setFromItem(fromItemVisitorImpl.getSubSelect());
        if (!DPHelper.getChangeTable()) {
            DPHelper.setChangeTable(true);
        }
    }

    // 访问where
    if (plainSelect.getWhere() != null) {
        plainSelect.getWhere().accept(new ExpressionVisitorImpl());
    }

    // 访问join
    if (plainSelect.getJoins() != null) {
        for (Join join : plainSelect.getJoins()) {
            FromItemVisitorImpl fromItemVisitorImplTemp = new FromItemVisitorImpl();
            join.getRightItem().accept(fromItemVisitorImplTemp);
            if (fromItemVisitorImplTemp.getSubSelect() != null) {
                join.setRightItem(fromItemVisitorImplTemp.getSubSelect());
                if (!DPHelper.getChangeTable()) {
                    DPHelper.setChangeTable(true);
                }
            }
        }
    }

    // 访问 order by
    if (plainSelect.getOrderByElements() != null) {
        for (OrderByElement orderByElement : plainSelect
                .getOrderByElements()) {
            orderByElement.getExpression().accept(
                    new ExpressionVisitorImpl());
        }
    }

    // 访问group by having
    if (plainSelect.getHaving() != null) {
        plainSelect.getHaving().accept(new ExpressionVisitorImpl());
    }

}
 

/**
 * Search in ANY object using SQL Syntax subset, similar to CMIS SQL
 * @param SQL complete query
 * @return and opened @Cursor
 * @throws PDException In any Error
 */
public Cursor SearchSelect(String SQL) throws PDException
{
if (PDLog.isDebug())
    PDLog.Debug("ObjPD.SearchSelect>:"+SQL);
Query QBE=null;
try {
Select ParsedSQL = (Select) CCJSqlParserUtil.parse(SQL);
//-- Calculate Table Names ------------
TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
List<String> TableListSQL = tablesNamesFinder.getTableList(ParsedSQL);
Vector <String> OPDTabs=CalculateTabs(TableListSQL);
//-- Calculate Fields -------------
List<SelectItem> selectItems = ((PlainSelect)ParsedSQL.getSelectBody()).getSelectItems();
Vector<String> Fields=new Vector<String>();
if (!( selectItems.get(0) instanceof AllColumns))
    for (int i = 0; i < selectItems.size(); i++)
        Fields.add(((SelectExpressionItem)selectItems.get(i)).getExpression().toString());      
Record Rec=CalculateRec(Fields, OPDTabs);
//-- Calculate Conds in Select ------------
Expression When = ((PlainSelect)ParsedSQL.getSelectBody()).getWhere();
Conditions CondSel=EvalExpr(When);

//-- Check Additional-Security Conditions ----
Conditions FinalConds;
Conditions AddedConds=NeededMoreConds(TableListSQL, OPDTabs);
if (AddedConds==null)
    FinalConds=CondSel;
else
    {
    FinalConds=new Conditions();
    FinalConds.addCondition(AddedConds);
    FinalConds.addCondition(CondSel);
    }
//-- Calculate Order ------------
Vector <String> Order=new Vector<String>();
Vector <Boolean> OrderAsc=new Vector<Boolean>();
List<OrderByElement> orderByElements = ((PlainSelect)ParsedSQL.getSelectBody()).getOrderByElements(); 
if (orderByElements!=null)
    for (int i = 0; i < orderByElements.size(); i++)
        {
        Order.add(orderByElements.get(i).getExpression().toString());
        OrderAsc.add(orderByElements.get(i).isAsc());
        }
//-- Create Query --------------
QBE=new Query(OPDTabs, Rec, FinalConds, Order, OrderAsc);
if (PDLog.isDebug())
    PDLog.Debug("ObjPD.SearchSelect <");
} catch (Exception Ex)
    {
    Ex.printStackTrace();
    PDException.GenPDException("Processing_SQL", Ex.getLocalizedMessage());
    }
return(getDrv().OpenCursor(QBE));
}