guipanel.java

nesC写的heed算法

			rf.setLocation(5,30);
			if (logCheckBox.isSelected())
		    {
				try {
					DBLogger dbLogger = new DBLogger(curQuery, sqlString.getText(), nw);
				    // XXX keep track of this so we can delete the listener when the query is cancelled
					TinyDBMain.addQueryListener(dbLogger);
				} catch (SQLException e) {
					e.printStackTrace();
				}
		    }
			
			
			TinyDBMain.notifyAddedQuery(curQuery);
			
			rf.show();
			if (resultWins.size() <= (qid + 1))
				resultWins.setSize(qid+1);
			resultWins.setElementAt(rf,qid);
			if (TinyDBMain.debug) System.out.println(curQuery);
			try {
				nw.sendQuery(curQuery);
			} catch (IOException e) {
				e.printStackTrace();
			}
	    }
    }
	
    public void triggerCheckBoxAction() {
		if (triggerCheckBox.isSelected()) { //user selected the box
			if (checkSelectionConsistency(selectDestList,null)) {
				triggerActionBox.setEnabled(true);
				triggerLabel.setEnabled(true);
			} else {
				triggerCheckBox.setSelected(false);
			}
		} else { //user deselected the box
			if (checkSelectionConsistency(selectDestList,null)) {
				triggerActionBox.setEnabled(false);
				triggerLabel.setEnabled(false);
			} else {
				triggerCheckBox.setSelected(true);
			}
		}
		
		//update the aggregate operators available for the current source selection
		constrainAggregateChoices();
		
		//refresh the SQL clause to reflect this change
		updateSQL();
		
    }
    
    /** Called when the "-" button to remove a where clause is pressed */
    public void removeWhereButtonActionPerformed(ActionEvent evt, int panelId) {
		boolean removed = false;
		for (int i = 0; i < panels.length; i++) {
			if (!removed) {
				if (panels[i] != null && panels[i].getId() == panelId) {
					numPanels--;
					selectGroupPanel.remove(panels[i]);
					
					panels[i] = null;
					removed = true;
					validate();
				}
			} else {
				if (panels[i] != null) panels[i].setId(panels[i].getId() - 1);
				panels[i-1] = panels[i];
				panels[i] = null;
			}
		}
		repaint();
		updateSQL();
    }
    
    /** Called when the "<<<" to remove a selection attribute is clicked */
    private void removeSelButtonActionPerformed() {
	    Object value = selectDestList.getSelectedValue();
	    if (value != null) {
			Vector values = new Vector();
			ListModel model = selectDestList.getModel();
			for (int i = 0; i < model.getSize(); i++) {
				if(model.getElementAt(i) != value)
					values.addElement(model.getElementAt(i));
			}
			selectDestList.setListData(values);
	    }
	    updateSQL();
    }
    
    
    /** Called when the ">>>" to add a selection attribute is clicked */
    private void addSelButtonActionPerformed() {
	    QueryField value = (QueryField)selectSrcList.getSelectedValue();
	    AggOp op;
		
	    if (aggregateBox.getSelectedItem().toString().equals("None"))
			op = null;
	    else
			op = (AggOp)aggregateBox.getSelectedItem();
		
	    if (value != null) {
			SelectionField sf = new SelectionField(op, value);
			if (op == null || checkSelectionConsistency(selectDestList,sf)) {
				Vector values = new Vector();
				ListModel model = selectDestList.getModel();
				for (int i = 0; i < model.getSize(); i++) {
					values.addElement(model.getElementAt(i));
				}
				values.addElement(sf);
				selectDestList.setListData(values);
			}
	    }
	    updateSQL();
    }
    
    int oldIdx = -1;
    boolean oldGrouping = false;
    int oldGroupIdx = -1;
    
    
    /**
	 * Called when something happens in the attribute selection list --
	 * main goal is to constrain the aggregate operations menu so that
	 * only valid aggregate choices are available.
	 */
    private void constrainAggregateChoices() {
		int idx = selectSrcList.getMinSelectionIndex();
		boolean grouping = groupCheckBox.isSelected();
		int groupIdx = groupBox.getSelectedIndex();
		
		if (idx != oldIdx || grouping != oldGrouping || oldGroupIdx != groupIdx) {
			oldIdx = idx;
			oldGroupIdx = groupIdx;
			oldGrouping = grouping;
			
			updateSQL();
			
			constrainAggMenu(aggregateBox, grouping, groupIdx == idx, hasAgg());
		}
    }
    
    /** Limit the items available in the aggregation menu based
	 on whether we're grouping or not
	 */
    private void constrainAggMenu(JComboBox menu, boolean grouping, boolean groupbyField,  boolean hasAgg) {
	    menu.removeAllItems();
	    if (grouping && groupbyField) { //must not be an agg
			menu.addItem("None");
			return;
	    }
	    if (hasAgg || grouping) { //must be an agg
		    fillAggsFromCatalog(menu);
		    return;
		}
	    //either ok
	    menu.addItem("None");
	    fillAggsFromCatalog(menu);
		/**
		 for (int i = 0; i < aggs.length; i++) {
		 //else {
		 if (hasAgg || grouping) { //must be an agg
		 if (aggs[i] != null)
		 menu.addItem(aggs[i]);
		 } else {
		 if (aggs[i] == null)
		 menu.addItem("None");
		 else
		 menu.addItem(aggs[i]);
		 }
		 }
		 }**/
    }
    
    
    
    /** Called when the grouping check box is selected / deselected
	 Have to make sure that this is OK (can't have agg / non agg fields in same
	 if not grouping.
	 */
    private void groupCheckBoxAction(ActionEvent evt) {
		if (groupCheckBox.isSelected()) { //user selected the box
			if (checkSelectionConsistency(selectDestList,null)) {
				groupBox.setEnabled(true);
				groupLabel.setEnabled(true);
				groupByOps.setEnabled(true);
			} else {
				groupCheckBox.setSelected(false);
			}
		} else { //user deselected the box
			if (checkSelectionConsistency(selectDestList,null)) {
				groupBox.setEnabled(false);
				groupLabel.setEnabled(false);
				groupByOps.setEnabled(false);
				groupByConst.setEnabled(false);
			} else {
				groupCheckBox.setSelected(true);
			}
		}
		
		//update the attribute lists to reflect group by operators
		//updateAttributeLists();
		
		//update the aggregate operators available for the current source selection
		constrainAggregateChoices();
		
		//refresh the SQL clause to reflect this change
		updateSQL();
    }
    
    
    //User added a selection predicate -- create the new panel (if there's a slot for it.)
    private void newPredButtonActionPerformed(ActionEvent evt) {
		JPanel newPanel = null;
		
		if (numPanels < 3) {
			newPanel = new WherePanel(numPanels, this);
			panels[numPanels++] = (WherePanel)newPanel;
		} else {
			setError("At most three selection predicates allowed per query.");
		}
		
		if (newPanel != null) {
			selectGroupPanel.add(newPanel);
			
			validate();
		}
		
		
		repaint();
		updateSQL();
    }
    
    
    /** Add the available arithmetic operations to the menu */
    public void addArithOpsToMenu(JComboBox menu) {
		for (int i = 0; i < arithOps.length; i++) {
			menu.addItem(arithOps[i]);
		}
    }
    
    
    /** Add the available query fields (from the catalog) to the menu */
    public void addFieldsToMenu(JComboBox menu) {
		for (int i = 0; i < Catalog.curCatalog.numAttrs(); i++) {
			menu.addItem(Catalog.curCatalog.getAttr(i));
		}
    }
    
    /** Add the available selection operators to the specified menu */
    public void addOpsToMenu(JComboBox menu) {
		for (int i = 0; i < ops.length; i++) {
			menu.addItem(ops[i]);
		}
    }
    
    /** Add the vailable aggregate operators to the specified menu */
    private void addAggsToMenu(JComboBox menu) {
	    menu.addItem("None");
	    fillAggsFromCatalog(menu);
    }
    
    private void fillAggsFromCatalog(JComboBox menu) {
		for(Iterator it = Catalog.currentCatalog().getAggregates().iterator(); it.hasNext(); ) {
			AggregateEntry entry = (AggregateEntry)it.next();
			//only add those aggs that dont take any arguments
			if (entry.getArgCount() == 0) {
				menu.addItem(new AggOp(entry.getName()));
			}
	    }
	}
    
    /** Add the available epoch durations to the menu */
    private void addEpochsToMenu(JComboBox menu) {
		int es[] = {128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144};
		for (int i =0 ; i < es.length; i++)
			menu.addItem(new Integer(es[i]));
		menu.setSelectedIndex(4);
    }
    
    
    /** Add the available selection attributes to the specific list */
    private void addSelectChoices(JList list) {
		Vector fields = new Vector();
		
		for (int i = 0; i < Catalog.curCatalog.numAttrs(); i++) {
			fields.add(Catalog.curCatalog.getAttr(i));
		}
		
		list.setListData(fields);
		
    }
    
    /** Given a list of current attrs in the query and a (possibly null) attr to add
	 to that list, return true iff the addition is OK (or newf == null) AND
	 the current settings (e.g. grouping, group by field, etc) are consistent.
	 
	 Return false otherwise.
	 
	 This is used extensively to determine if some user action produces a consistent
	 query.  It sets appropriate error messages when consistency checks fail.
	 */
    public boolean checkSelectionConsistency(JList list, SelectionField newf) {
		
		//is an agg -- check and see if there are any non-aggs in the list
		//if so, if we aren't grouping by them, ask the user what to do
		//if user wants to remove them, do so
		//otherwise, return false
		
		ListModel model = list.getModel();
		boolean hasAgg = hasAgg();
		boolean newAgg = newf != null && newf.getOp() != null;
		
		for (int i = 0; i < model.getSize(); i ++) {
			SelectionField sf = (SelectionField)model.getElementAt(i);
			boolean isGroupField = groupCheckBox.isSelected() && groupBox.getSelectedItem() == sf.getField();
			
			if (groupCheckBox.isSelected() && sf.getOp() == null && !isGroupField) {
				setError("Can't group if a non-aggregate field is present");
				return false;
			} else if (hasAgg && sf.getOp() == null && !isGroupField) {
				setError("Can't have non-aggregate field when other aggregates are present");
				return false;
			} else if ((!hasAgg && !isGroupField)  && (sf.getOp() != null || newAgg)) {
				setError("Can't have aggregate field when non-aggregates are present");
				return false;
			} else if (triggerCheckBox.isSelected() && sf.getOp() != null) {
				setError("Can't enabled triggers when aggregates are present");
				return false;
			}
			
			//else if (hasAgg && newAgg) {
			//	    setError("Only one aggregate allow per query in current implementation.");
			//	    return false;
			//	}
		}
		if (triggerCheckBox.isSelected() && newAgg) {
			setError("Can't add aggregates when triggering");
			return false;
		}
		return true;
    }
    
    //check and see if there are any aggs in the selection list
    public boolean hasAgg() {
		ListModel model = selectDestList.getModel();
		for (int i = 0; i < model.getSize(); i++) {
			SelectionField sf = (SelectionField)model.getElementAt(i);
			if (sf.getOp() != null) return true;
		}
		return false;
    }
    
    public void setError(String txt) {
		sqlString.setText(txt);
		setError = true;
    }
    
    /** Generate a SQL string for the current query */
    public void updateSQL() {
		String sql = "SELECT ";
		boolean first = true;
		
		if(setError) {
			setError = false;
			return;
		}
		
		ListModel model = selectDestList.getModel();
		
		if (model.getSize() == 0) {
			sql = "Query must SELECT at least one attribute.";
		} else {
			for (int i = 0; i < model.getSize(); i++) {
				SelectionField sf = (SelectionField)model.getElementAt(i);
				if (first) {
					sql += sf.toString();
					first = false;
				}      else
					sql += ", " + sf.toString();
			}
			sql += " FROM sensors ";
			first = true;
			for (int i = 0; i < panels.length; i++) {
				if (panels[i] != null) {
					if (first) {
						sql += "\nWHERE " + panels[i].toString();
						first = false;
					} else {
						sql += " AND " + panels[i].toString();
					}
					
				}
			}
			
			if (groupCheckBox.isSelected()) {
				Integer atten = (Integer)attenuationBox.getSelectedItem();
				
				sql += "\nGROUP BY " + groupBox.getSelectedItem().toString();
				
				String groupByOp = (String) groupByOps.getSelectedItem();
				
				if (!groupByOp.equals(""))
					sql += " " + groupByOp + " " + groupByConst.getText();
				//if (atten.intValue() == 0)
				//    sql += groupBox.getSelectedItem().toString();
				//else
				//    sql += "(" + groupBox.getSelectedItem().toString() + ">>" + atten + ")";
			}
			
			sql += "\nSAMPLE PERIOD " + epochDur;
			
			if (triggerCheckBox.isSelected()) {
				TriggerAction ta= (TriggerAction)triggerActionBox.getSelectedItem();
				
				sql += "\nTRIGGER ACTION " + ta.command;
				
				if (ta.hasParam)
					sql += "(" + ta.param +")";
			}
			
		}
		sqlString.setText(sql);
		
    }