casacore
TaQLNodeDer.h
Go to the documentation of this file.
1 //# TaQLNodeDer.h: Specialized nodes in the raw TaQL parse tree
2 //# Copyright (C) 2005
3 //# Associated Universities, Inc. Washington DC, USA.
4 //#
5 //# This library is free software; you can redistribute it and/or modify it
6 //# under the terms of the GNU Library General Public License as published by
7 //# the Free Software Foundation; either version 2 of the License, or (at your
8 //# option) any later version.
9 //#
10 //# This library is distributed in the hope that it will be useful, but WITHOUT
11 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 //# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13 //# License for more details.
14 //#
15 //# You should have received a copy of the GNU Library General Public License
16 //# along with this library; if not, write to the Free Software Foundation,
17 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18 //#
19 //# Correspondence concerning AIPS++ should be addressed as follows:
20 //# Internet email: aips2-request@nrao.edu.
21 //# Postal address: AIPS++ Project Office
22 //# National Radio Astronomy Observatory
23 //# 520 Edgemont Road
24 //# Charlottesville, VA 22903-2475 USA
25 //#
26 //# $Id$
27 
28 #ifndef TABLES_TAQLNODEDER_H
29 #define TABLES_TAQLNODEDER_H
30 
31 //# Includes
32 #include <casacore/casa/aips.h>
33 #include <casacore/tables/TaQL/TaQLNode.h>
34 #include <casacore/casa/BasicSL/Complex.h>
35 #include <casacore/casa/BasicSL/String.h>
36 #include <casacore/casa/Utilities/Regex.h>
37 #include <casacore/casa/Quanta/MVTime.h>
38 #include <casacore/casa/Containers/Block.h>
39 #include <vector>
40 #include <iostream>
41 
42 namespace casacore { //# NAMESPACE CASACORE - BEGIN
43 
44 
45 // <summary>
46 // Raw TaQL parse tree node defining a constant value.
47 // </summary>
48 // <use visibility=local>
49 // <reviewed reviewer="" date="" tests="tTaQLNode">
50 // </reviewed>
51 // <prerequisite>
52 //# Classes you should understand before using this one.
53 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
54 // </prerequisite>
55 // <synopsis>
56 // This class is a TaQLNodeRep holding a constant expression or a table name.
57 // The types supported are Bool, Int, Double, DComplex, String, and MVTime.
58 // Note that a keyword or column name is represented by TaQLKeyColNodeRep.
59 // </synopsis>
60 
62 {
63 public:
64  // Do not change the values of this enum, as objects might be persistent.
65  enum Type {CTBool =0,
66  CTInt =1,
67  CTReal =2,
70  CTTime =5};
71  explicit TaQLConstNodeRep (Bool value);
72  explicit TaQLConstNodeRep (Int64 value, Bool isTableName=False);
73  explicit TaQLConstNodeRep (Double value);
74  explicit TaQLConstNodeRep (Double value, const String& unit);
75  explicit TaQLConstNodeRep (DComplex value);
76  explicit TaQLConstNodeRep (const String& value, Bool isTableName=False);
77  explicit TaQLConstNodeRep (const MVTime& value);
78  virtual ~TaQLConstNodeRep();
80  { itsIsTableName = True; }
81  const String& getString() const;
82  const String& getUnit() const
83  { return itsUnit; }
84  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
85  virtual void show (std::ostream& os) const;
86  virtual void save (AipsIO& aio) const;
87  static TaQLConstNodeRep* restore (AipsIO& aio);
88 
98 };
99 
100 
101 // <summary>
102 // Raw TaQL parse tree node defining a constant regex value.
103 // </summary>
104 // <use visibility=local>
105 // <reviewed reviewer="" date="" tests="tTaQLNode">
106 // </reviewed>
107 // <prerequisite>
108 //# Classes you should understand before using this one.
109 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
110 // </prerequisite>
111 // <synopsis>
112 // This class is a TaQLNodeRep holding a constant regex/pattern value.
113 // Part of the regex are the delimiters (like p//).
114 // It also holds if the regex is case-insensitive and if a match or no match
115 // operator is given.
116 // </synopsis>
117 
119 {
120 public:
121  explicit TaQLRegexNodeRep (const String& value);
122  TaQLRegexNodeRep (const String& value, Bool caseInsensitive, Bool negate,
123  Bool ignoreBlanks, Int maxDistance);
124  virtual ~TaQLRegexNodeRep();
125  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
126  virtual void show (std::ostream& os) const;
127  virtual void save (AipsIO& aio) const;
128  static TaQLRegexNodeRep* restore (AipsIO& aio);
129 
132  Bool itsNegate; //# True means !~
133  //# The following members are only used for distance.
136 };
137 
138 
139 // <summary>
140 // Raw TaQL parse tree node defining a unary operator.
141 // </summary>
142 // <use visibility=local>
143 // <reviewed reviewer="" date="" tests="tTaQLNode">
144 // </reviewed>
145 // <prerequisite>
146 //# Classes you should understand before using this one.
147 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
148 // </prerequisite>
149 // <synopsis>
150 // This class is a TaQLNodeRep holding a unary operator and operand.
151 // The operators supported are -, ~, NOT, EXISTS, and NOT EXISTS.
152 // Note the unary operator + is superfluous and is ignored by the parser.
153 // </synopsis>
154 
156 {
157 public:
158  // Do not change the values of this enum, as objects might be persistent.
159  enum Type {U_MINUS =0,
160  U_NOT =1,
161  U_EXISTS =2,
162  U_NOTEXISTS=3,
163  U_BITNOT =4};
164  TaQLUnaryNodeRep (Type type, const TaQLNode& child);
165  virtual ~TaQLUnaryNodeRep();
166  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
167  virtual void show (std::ostream& os) const;
168  virtual void save (AipsIO& aio) const;
169  static TaQLUnaryNodeRep* restore (AipsIO& aio);
170 
173 };
174 
175 
176 // <summary>
177 // Raw TaQL parse tree node defining a binary operator.
178 // </summary>
179 // <use visibility=local>
180 // <reviewed reviewer="" date="" tests="tTaQLNode">
181 // </reviewed>
182 // <prerequisite>
183 //# Classes you should understand before using this one.
184 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
185 // </prerequisite>
186 // <synopsis>
187 // This class is a TaQLNodeRep holding a binary operator and operands.
188 // All standard mathematical (including % and ^), relational, bit, and logical
189 // operators are supported. Furthermore operator IN and the INDEX operator
190 // (for indexing in an array) are supported.
191 // </synopsis>
192 
194 {
195 public:
196  // Do not change the values of this enum, as objects might be persistent.
197  enum Type {B_PLUS =0,
198  B_MINUS =1,
199  B_TIMES =2,
200  B_DIVIDE=3,
201  B_MODULO=4,
202  B_POWER =5,
203  B_EQ =6,
204  B_NE =7,
205  B_GT =8,
206  B_GE =9,
207  B_LT =10,
208  B_LE =11,
209  B_OR =12,
210  B_AND =13,
211  B_IN =14,
212  B_INDEX =15,
213  B_DIVIDETRUNC=16,
214  B_EQREGEX =17,
215  B_NEREGEX =18,
216  B_BITAND =19,
217  B_BITXOR =20,
218  B_BITOR =21};
219  TaQLBinaryNodeRep (Type type, const TaQLNode& left, const TaQLNode& right);
220  virtual ~TaQLBinaryNodeRep();
221  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
222  virtual void show (std::ostream& os) const;
223  virtual void save (AipsIO& aio) const;
224  static TaQLBinaryNodeRep* restore (AipsIO& aio);
225  // Handle a comparison wih a regex. The operator (~ or !~) is extracted
226  // from the regex.
227  static TaQLBinaryNodeRep* handleRegex (const TaQLNode& left,
228  const TaQLRegexNode& regex);
229 
233 };
234 
235 
236 // <summary>
237 // Raw TaQL parse tree node defining a list of nodes.
238 // </summary>
239 // <use visibility=local>
240 // <reviewed reviewer="" date="" tests="tTaQLNode">
241 // </reviewed>
242 // <prerequisite>
243 //# Classes you should understand before using this one.
244 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
245 // </prerequisite>
246 // <synopsis>
247 // This class is a TaQLNodeRep holding a list of heterogeneous nodes.
248 // </synopsis>
249 
251 {
252 public:
253  explicit TaQLMultiNodeRep (Bool isSetOrArray=False);
254  TaQLMultiNodeRep(const String& prefix, const String& postfix,
255  Bool isSetOrArray=False);
256  virtual ~TaQLMultiNodeRep();
258  { itsIsSetOrArray = True; }
259  void setPPFix (const String& prefix, const String& postfix)
260  { itsPrefix = prefix; itsPostfix = postfix; }
261  void setSeparator (const String& sep)
262  { itsSep = sep; }
263  void setSeparator (uInt incr, const String& sep)
264  { itsIncr = incr; itsSep2 = sep; }
265  void add (const TaQLNode& node)
266  { itsNodes.push_back (node); }
267  const std::vector<TaQLNode>& getNodes() const
268  { return itsNodes; }
269  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
270  virtual void show (std::ostream& os) const;
271  virtual void save (AipsIO& aio) const;
272  static TaQLMultiNodeRep* restore (AipsIO& aio);
273 
274  std::vector<TaQLNode> itsNodes;
281 };
282 
283 
284 // <summary>
285 // Raw TaQL parse tree node defining a function.
286 // </summary>
287 // <use visibility=local>
288 // <reviewed reviewer="" date="" tests="tTaQLNode">
289 // </reviewed>
290 // <prerequisite>
291 //# Classes you should understand before using this one.
292 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
293 // </prerequisite>
294 // <synopsis>
295 // This class is a TaQLNodeRep holding a function name and its arguments.
296 // </synopsis>
297 
299 {
300 public:
301  TaQLFuncNodeRep (const String& name);
302  TaQLFuncNodeRep (const String& name, const TaQLMultiNode& args);
303  virtual ~TaQLFuncNodeRep();
304  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
305  virtual void show (std::ostream& os) const;
306  virtual void save (AipsIO& aio) const;
307  static TaQLFuncNodeRep* restore (AipsIO& aio);
308 
311 };
312 
313 
314 // <summary>
315 // Raw TaQL parse tree node defining a range.
316 // </summary>
317 // <use visibility=local>
318 // <reviewed reviewer="" date="" tests="tTaQLNode">
319 // </reviewed>
320 // <prerequisite>
321 //# Classes you should understand before using this one.
322 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
323 // </prerequisite>
324 // <synopsis>
325 // This class is a TaQLNodeRep holding the optional start and end values
326 // of a range (i.e. an interval) and flags if the range is open or closed.
327 // </synopsis>
328 
330 {
331 public:
332  TaQLRangeNodeRep (Bool leftClosed, TaQLNode start,
333  const TaQLNode& end, Bool rightClosed);
334  TaQLRangeNodeRep (Bool leftClosed, const TaQLNode& start);
335  TaQLRangeNodeRep (const TaQLNode& end, Bool rightClosed);
336  virtual ~TaQLRangeNodeRep();
337  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
338  virtual void show (std::ostream& os) const;
339  virtual void save (AipsIO& aio) const;
340  static TaQLRangeNodeRep* restore (AipsIO& aio);
341 
346 };
347 
348 
349 // <summary>
350 // Raw TaQL parse tree node defining an index in a array.
351 // </summary>
352 // <use visibility=local>
353 // <reviewed reviewer="" date="" tests="tTaQLNode">
354 // </reviewed>
355 // <prerequisite>
356 //# Classes you should understand before using this one.
357 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
358 // </prerequisite>
359 // <synopsis>
360 // This class is a TaQLNodeRep holding the optional start, end, and incr
361 // values of an index in an array.
362 // </synopsis>
363 
365 {
366 public:
367  TaQLIndexNodeRep (const TaQLNode& start, const TaQLNode& end,
368  const TaQLNode& incr);
369  virtual ~TaQLIndexNodeRep();
370  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
371  virtual void show (std::ostream& os) const;
372  virtual void save (AipsIO& aio) const;
373  static TaQLIndexNodeRep* restore (AipsIO& aio);
374 
378 };
379 
380 
381 // <summary>
382 // Raw TaQL parse tree node defining a join operation.
383 // </summary>
384 // <use visibility=local>
385 // <reviewed reviewer="" date="" tests="tTaQLNode">
386 // </reviewed>
387 // <prerequisite>
388 //# Classes you should understand before using this one.
389 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
390 // </prerequisite>
391 // <synopsis>
392 // This class is a TaQLNodeRep holding the expressions of a join operation.
393 // This is, however, a placeholder and not implemented yet.
394 // </synopsis>
395 
397 {
398 public:
399  TaQLJoinNodeRep (const TaQLMultiNode& tables, const TaQLNode& condition);
400  virtual ~TaQLJoinNodeRep();
401  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
402  virtual void show (std::ostream& os) const;
403  virtual void save (AipsIO& aio) const;
404  static TaQLJoinNodeRep* restore (AipsIO& aio);
405 
408 };
409 
410 
411 // <summary>
412 // Raw TaQL parse tree node defining a keyword or column name.
413 // </summary>
414 // <use visibility=local>
415 // <reviewed reviewer="" date="" tests="tTaQLNode">
416 // </reviewed>
417 // <prerequisite>
418 //# Classes you should understand before using this one.
419 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
420 // </prerequisite>
421 // <synopsis>
422 // This class is a TaQLNodeRep holding the name of a keyword or column.
423 // The name can contain . and :: delimiters for scoping.
424 // </synopsis>
425 
427 {
428 public:
429  TaQLKeyColNodeRep (const String& name, const String& nameMask = String());
430  virtual ~TaQLKeyColNodeRep();
431  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
432  virtual void show (std::ostream& os) const;
433  virtual void save (AipsIO& aio) const;
434  static TaQLKeyColNodeRep* restore (AipsIO& aio);
435 
438 };
439 
440 
441 // <summary>
442 // Raw TaQL parse tree node defining a table.
443 // </summary>
444 // <use visibility=local>
445 // <reviewed reviewer="" date="" tests="tTaQLNode">
446 // </reviewed>
447 // <prerequisite>
448 //# Classes you should understand before using this one.
449 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
450 // </prerequisite>
451 // <synopsis>
452 // This class is a TaQLNodeRep holding the info defining a table.
453 // It can be a constant value holding a name or it can be a subquery.
454 // Furthermore the alias of the table is defined (which can be empty).
455 // </synopsis>
456 
458 {
459 public:
460  TaQLTableNodeRep (const TaQLNode& table, const String& alias);
461  virtual ~TaQLTableNodeRep();
462  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
463  virtual void show (std::ostream& os) const;
464  virtual void save (AipsIO& aio) const;
465  static TaQLTableNodeRep* restore (AipsIO& aio);
466 
469 };
470 
471 
472 // <summary>
473 // Raw TaQL parse tree node defining a select column expression.
474 // </summary>
475 // <use visibility=local>
476 // <reviewed reviewer="" date="" tests="tTaQLNode">
477 // </reviewed>
478 // <prerequisite>
479 //# Classes you should understand before using this one.
480 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
481 // </prerequisite>
482 // <synopsis>
483 // This class is a TaQLNodeRep holding a column expression in the
484 // column list of the select clause.
485 // A new column name and data type can be defined for the column (expression).
486 // The expression can be a wildcarded column name (a regex) preceeded by
487 // ~ or !~ (meaning include or exclude).
488 // </synopsis>
489 
491 {
492 public:
493  TaQLColNodeRep (const TaQLNode& expr, const String& name,
494  const String& nameMask, const String& dtype);
495  virtual ~TaQLColNodeRep();
496  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
497  virtual void show (std::ostream& os) const;
498  virtual void save (AipsIO& aio) const;
499  static TaQLColNodeRep* restore (AipsIO& aio);
500 
505 };
506 
507 
508 // <summary>
509 // Raw TaQL parse tree node defining a select column list.
510 // </summary>
511 // <use visibility=local>
512 // <reviewed reviewer="" date="" tests="tTaQLNode">
513 // </reviewed>
514 // <prerequisite>
515 //# Classes you should understand before using this one.
516 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
517 // </prerequisite>
518 // <synopsis>
519 // This class is a TaQLNodeRep holding a select column list.
520 // It also defines if the result must be distinct (unique)
521 // </synopsis>
522 
524 {
525 public:
526  TaQLColumnsNodeRep (Bool distinct, const TaQLMultiNode& nodes);
527  virtual ~TaQLColumnsNodeRep();
528  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
529  virtual void show (std::ostream& os) const;
530  virtual void save (AipsIO& aio) const;
531  static TaQLColumnsNodeRep* restore (AipsIO& aio);
532 
535 };
536 
537 
538 // <summary>
539 // Raw TaQL parse tree node defining a groupby list.
540 // </summary>
541 // <use visibility=local>
542 // <reviewed reviewer="" date="" tests="tTaQLNode">
543 // </reviewed>
544 // <prerequisite>
545 //# Classes you should understand before using this one.
546 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
547 // </prerequisite>
548 // <synopsis>
549 // This class is a TaQLNodeRep holding a groupby list with the optional
550 // ROLLUP qualifier.
551 // </synopsis>
552 
554 {
555 public:
556  // Do not change the values of this enum, as objects might be persistent.
557  enum Type {Normal=0,
558  Rollup=1}; //# in the future type Cube could be added
559  TaQLGroupNodeRep (Type type, const TaQLMultiNode& nodes);
560  virtual ~TaQLGroupNodeRep();
561  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
562  virtual void show (std::ostream& os) const;
563  virtual void save (AipsIO& aio) const;
564  static TaQLGroupNodeRep* restore (AipsIO& aio);
565 
568 };
569 
570 
571 // <summary>
572 // Raw TaQL parse tree node defining a sort key.
573 // </summary>
574 // <use visibility=local>
575 // <reviewed reviewer="" date="" tests="tTaQLNode">
576 // </reviewed>
577 // <prerequisite>
578 //# Classes you should understand before using this one.
579 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
580 // </prerequisite>
581 // <synopsis>
582 // This class is a TaQLNodeRep holding a sort key and the optional order
583 // in which this key must be sorted.
584 // </synopsis>
585 
587 {
588 public:
589  // Do not change the values of this enum, as objects might be persistent.
590  enum Type {Ascending =0,
591  Descending=1,
592  None =2};
593  TaQLSortKeyNodeRep (Type type, const TaQLNode& child);
594  virtual ~TaQLSortKeyNodeRep();
595  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
596  virtual void show (std::ostream& os) const;
597  virtual void save (AipsIO& aio) const;
598  static TaQLSortKeyNodeRep* restore (AipsIO& aio);
599 
602 };
603 
604 
605 // <summary>
606 // Raw TaQL parse tree node defining a sort list.
607 // </summary>
608 // <use visibility=local>
609 // <reviewed reviewer="" date="" tests="tTaQLNode">
610 // </reviewed>
611 // <prerequisite>
612 //# Classes you should understand before using this one.
613 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
614 // </prerequisite>
615 // <synopsis>
616 // This class is a TaQLNodeRep holding a sort list and the default order
617 // for each individual sort key.
618 // </synopsis>
619 
621 {
622 public:
623  // Do not change the values of this enum, as objects might be persistent.
624  enum Type {Ascending =0,
625  Descending=1};
626  TaQLSortNodeRep (Bool unique, Type type, const TaQLMultiNode& keys);
627  virtual ~TaQLSortNodeRep();
628  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
629  virtual void show (std::ostream& os) const;
630  virtual void save (AipsIO& aio) const;
631  static TaQLSortNodeRep* restore (AipsIO& aio);
632 
636 };
637 
638 
639 // <summary>
640 // Raw TaQL parse tree node defining a limit/offset expression.
641 // </summary>
642 // <use visibility=local>
643 // <reviewed reviewer="" date="" tests="tTaQLNode">
644 // </reviewed>
645 // <prerequisite>
646 //# Classes you should understand before using this one.
647 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
648 // </prerequisite>
649 // <synopsis>
650 // This class is a TaQLNodeRep holding the optional expressions for the
651 // LIMIT and OFFSET clause.
652 // </synopsis>
653 
655 {
656 public:
657  TaQLLimitOffNodeRep (const TaQLNode& limit, const TaQLNode& offset);
658  virtual ~TaQLLimitOffNodeRep();
659  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
660  virtual void show (std::ostream& os) const;
661  virtual void save (AipsIO& aio) const;
662  static TaQLLimitOffNodeRep* restore (AipsIO& aio);
663 
666 };
667 
668 
669 // <summary>
670 // Raw TaQL parse tree node defining a giving expression list.
671 // </summary>
672 // <use visibility=local>
673 // <reviewed reviewer="" date="" tests="tTaQLNode">
674 // </reviewed>
675 // <prerequisite>
676 //# Classes you should understand before using this one.
677 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
678 // </prerequisite>
679 // <synopsis>
680 // This class is a TaQLNodeRep holding the values for a GIVING clause.
681 // The value can be a table name or a list of expressions.
682 // </synopsis>
683 
685 {
686 public:
687  explicit TaQLGivingNodeRep (const String& name, const TaQLMultiNode& type);
688  explicit TaQLGivingNodeRep (const TaQLMultiNode& exprlist);
689  virtual ~TaQLGivingNodeRep();
690  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
691  virtual void show (std::ostream& os) const;
692  virtual void save (AipsIO& aio) const;
693  static TaQLGivingNodeRep* restore (AipsIO& aio);
694 
698 };
699 
700 
701 // <summary>
702 // Raw TaQL parse tree node defining a column update expression.
703 // </summary>
704 // <use visibility=local>
705 // <reviewed reviewer="" date="" tests="tTaQLNode">
706 // </reviewed>
707 // <prerequisite>
708 //# Classes you should understand before using this one.
709 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
710 // </prerequisite>
711 // <synopsis>
712 // This class is a TaQLNodeRep holding the values for an update expression.
713 // It defines the column name and the expression for the new value.
714 // Optionally an index can be defined in case the column contains array
715 // values for which only some values need to be updated.
716 // </synopsis>
717 
719 {
720 public:
721  TaQLUpdExprNodeRep (const String& name, const String& nameMask,
722  const TaQLNode& expr);
723  TaQLUpdExprNodeRep (const String& name, const String& nameMask,
724  const TaQLMultiNode& indices,
725  const TaQLNode& expr);
726  TaQLUpdExprNodeRep (const String& name, const String& nameMask,
727  const TaQLMultiNode& indices1,
728  const TaQLMultiNode& indices2,
729  const TaQLNode& expr);
730  virtual ~TaQLUpdExprNodeRep();
731  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
732  virtual void show (std::ostream& os) const;
733  virtual void save (AipsIO& aio) const;
734  static TaQLUpdExprNodeRep* restore (AipsIO& aio);
735 
738  TaQLMultiNode itsIndices1; //# indices or mask
739  TaQLMultiNode itsIndices2; //# mask or indices
741 };
742 
743 
744 // <summary>
745 // Raw TaQL parse tree node defining a selection command.
746 // </summary>
747 // <use visibility=local>
748 // <reviewed reviewer="" date="" tests="tTaQLNode">
749 // </reviewed>
750 // <prerequisite>
751 //# Classes you should understand before using this one.
752 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
753 // </prerequisite>
754 // <synopsis>
755 // This class is an abstract TaQLNodeRep for a selection command that can
756 // also be used as a subquery.
757 // It holds flags telling if and how the select command must be
758 // executed when the node is visited for TaQLNodeHandler.
759 // </synopsis>
760 
762 {
763 public:
765  virtual ~TaQLQueryNodeRep();
766  void setBrackets()
767  { itsBrackets = True; }
769  { itsNoExecute = True; }
771  { itsFromExecute = True; }
773  { return itsBrackets; }
775  { return itsNoExecute; }
777  { return itsFromExecute; }
778  virtual void show (std::ostream& os) const;
779 protected:
780  virtual void saveSuper (AipsIO& aio) const;
781  virtual void restoreSuper (AipsIO& aio);
782 private:
783  virtual void showDerived (std::ostream& os) const = 0;
785  Bool itsNoExecute; //# no execute in EXISTS operator
786  Bool itsFromExecute; //# special execute in FROM
787 };
788 
789 
790 // <summary>
791 // Raw TaQL parse tree node defining a select command.
792 // </summary>
793 // <use visibility=local>
794 // <reviewed reviewer="" date="" tests="tTaQLNode">
795 // </reviewed>
796 // <prerequisite>
797 //# Classes you should understand before using this one.
798 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
799 // </prerequisite>
800 // <synopsis>
801 // This class is a TaQLNodeRep holding the different parts of a
802 // select expression.
803 // It also holds flags telling if and how the select command must be
804 // executed when the node is visited for TaQLNodeHandler.
805 // </synopsis>
806 
808 {
809 public:
810  TaQLSelectNodeRep (const TaQLNode& columns, const TaQLNode& where,
811  const TaQLNode& groupby, const TaQLNode& having,
812  const TaQLNode& sort, const TaQLNode& limitoff,
813  const TaQLNode& giving, const TaQLMultiNode& dminfo);
814  TaQLSelectNodeRep (const TaQLNode& columns, const TaQLMultiNode& tables,
815  const TaQLNode& join, const TaQLNode& where,
816  const TaQLNode& groupby, const TaQLNode& having,
817  const TaQLNode& sort, const TaQLNode& limitoff,
818  const TaQLNode& giving, const TaQLMultiNode& dminfo);
819  virtual ~TaQLSelectNodeRep();
820  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
821  virtual void showDerived (std::ostream& os) const;
822  virtual void save (AipsIO& aio) const;
823  static TaQLSelectNodeRep* restore (AipsIO& aio);
824 
835 };
836 
837 
838 // <summary>
839 // Raw TaQL parse tree node defining a count command.
840 // </summary>
841 // <use visibility=local>
842 // <reviewed reviewer="" date="" tests="tTaQLNode">
843 // </reviewed>
844 // <prerequisite>
845 //# Classes you should understand before using this one.
846 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
847 // </prerequisite>
848 // <synopsis>
849 // This class is a TaQLNodeRep holding the parts for a count command.
850 // </synopsis>
851 
853 {
854 public:
855  TaQLCountNodeRep (const TaQLNode& columns, const TaQLMultiNode& tables,
856  const TaQLNode& where);
857  virtual ~TaQLCountNodeRep();
858  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
859  virtual void showDerived (std::ostream& os) const;
860  virtual void save (AipsIO& aio) const;
861  static TaQLCountNodeRep* restore (AipsIO& aio);
862 
866 };
867 
868 
869 // <summary>
870 // Raw TaQL parse tree node defining an update command.
871 // </summary>
872 // <use visibility=local>
873 // <reviewed reviewer="" date="" tests="tTaQLNode">
874 // </reviewed>
875 // <prerequisite>
876 //# Classes you should understand before using this one.
877 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
878 // </prerequisite>
879 // <synopsis>
880 // This class is a TaQLNodeRep holding the parts for an update command.
881 // The tables to be used can be defined in two parts: the main one in
882 // the UPDATE clause, possible other ones in the FROM command.
883 // </synopsis>
884 
886 {
887 public:
888  TaQLUpdateNodeRep (const TaQLMultiNode& tables, const TaQLMultiNode& update,
889  const TaQLMultiNode& from, const TaQLNode& where,
890  const TaQLNode& sort, const TaQLNode& limitoff);
891  virtual ~TaQLUpdateNodeRep();
892  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
893  virtual void show (std::ostream& os) const;
894  virtual void save (AipsIO& aio) const;
895  static TaQLUpdateNodeRep* restore (AipsIO& aio);
896 
903 };
904 
905 
906 // <summary>
907 // Raw TaQL parse tree node defining an insert command.
908 // </summary>
909 // <use visibility=local>
910 // <reviewed reviewer="" date="" tests="tTaQLNode">
911 // </reviewed>
912 // <prerequisite>
913 //# Classes you should understand before using this one.
914 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
915 // </prerequisite>
916 // <synopsis>
917 // This class is a TaQLNodeRep holding the parts for an insert command.
918 // The values cvan be a list of expressions or a subquery.
919 // </synopsis>
920 
922 {
923 public:
924  TaQLInsertNodeRep (const TaQLMultiNode& tables, const TaQLMultiNode& columns,
925  const TaQLNode& values, const TaQLNode& limit);
926  TaQLInsertNodeRep (const TaQLMultiNode& tables, const TaQLMultiNode& insert);
927  virtual ~TaQLInsertNodeRep();
928  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
929  virtual void show (std::ostream& os) const;
930  virtual void save (AipsIO& aio) const;
931  static TaQLInsertNodeRep* restore (AipsIO& aio);
932 
937 };
938 
939 
940 // <summary>
941 // Raw TaQL parse tree node defining a delete command.
942 // </summary>
943 // <use visibility=local>
944 // <reviewed reviewer="" date="" tests="tTaQLNode">
945 // </reviewed>
946 // <prerequisite>
947 //# Classes you should understand before using this one.
948 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
949 // </prerequisite>
950 // <synopsis>
951 // This class is a TaQLNodeRep holding the parts for a delete command.
952 // </synopsis>
953 
955 {
956 public:
957  TaQLDeleteNodeRep (const TaQLMultiNode& tables, const TaQLNode& where,
958  const TaQLNode& sort, const TaQLNode& limitoff);
959  virtual ~TaQLDeleteNodeRep();
960  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
961  virtual void show (std::ostream& os) const;
962  virtual void save (AipsIO& aio) const;
963  static TaQLDeleteNodeRep* restore (AipsIO& aio);
964 
969 };
970 
971 
972 // <summary>
973 // Raw TaQL parse tree node defining a calc command.
974 // </summary>
975 // <use visibility=local>
976 // <reviewed reviewer="" date="" tests="tTaQLNode">
977 // </reviewed>
978 // <prerequisite>
979 //# Classes you should understand before using this one.
980 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
981 // </prerequisite>
982 // <synopsis>
983 // This class is a TaQLNodeRep holding the parts of the calc command.
984 // </synopsis>
985 
987 {
988 public:
989  TaQLCalcNodeRep (const TaQLMultiNode& tables, const TaQLNode& expr,
990  const TaQLNode& where,
991  const TaQLNode& sort, const TaQLNode& limitoff);
992  virtual ~TaQLCalcNodeRep();
993  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
994  virtual void show (std::ostream& os) const;
995  virtual void save (AipsIO& aio) const;
996  static TaQLCalcNodeRep* restore (AipsIO& aio);
997 
1003 };
1004 
1005 
1006 // <summary>
1007 // Raw TaQL parse tree node defining a create table command.
1008 // </summary>
1009 // <use visibility=local>
1010 // <reviewed reviewer="" date="" tests="tTaQLNode">
1011 // </reviewed>
1012 // <prerequisite>
1013 //# Classes you should understand before using this one.
1014 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1015 // </prerequisite>
1016 // <synopsis>
1017 // This class is a TaQLNodeRep holding the parts of the create table command.
1018 // </synopsis>
1019 
1021 {
1022 public:
1023  TaQLCreTabNodeRep (const TaQLNode& giving, const TaQLMultiNode& cols,
1024  const TaQLNode& limit, const TaQLMultiNode& dminfo);
1025  virtual ~TaQLCreTabNodeRep();
1026  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1027  virtual void showDerived (std::ostream& os) const;
1028  virtual void save (AipsIO& aio) const;
1029  static TaQLCreTabNodeRep* restore (AipsIO& aio);
1030 
1035 };
1036 
1037 
1038 // <summary>
1039 // Raw TaQL parse tree node defining a create column specification.
1040 // </summary>
1041 // <use visibility=local>
1042 // <reviewed reviewer="" date="" tests="tTaQLNode">
1043 // </reviewed>
1044 // <prerequisite>
1045 //# Classes you should understand before using this one.
1046 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1047 // </prerequisite>
1048 // <synopsis>
1049 // This class is a TaQLNodeRep holding the parts of a column specification
1050 // in the create table command.
1051 // </synopsis>
1052 
1054 {
1055 public:
1056  TaQLColSpecNodeRep (const String& name, const String& dtype,
1057  const TaQLMultiNode& spec);
1058  virtual ~TaQLColSpecNodeRep();
1059  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1060  virtual void show (std::ostream& os) const;
1061  virtual void save (AipsIO& aio) const;
1062  static TaQLColSpecNodeRep* restore (AipsIO& aio);
1063 
1067 };
1068 
1069 
1070 // <summary>
1071 // Raw TaQL parse tree node defining a record field.
1072 // </summary>
1073 // <use visibility=local>
1074 // <reviewed reviewer="" date="" tests="tTaQLNode">
1075 // </reviewed>
1076 // <prerequisite>
1077 //# Classes you should understand before using this one.
1078 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1079 // </prerequisite>
1080 // <synopsis>
1081 // This class is a TaQLNodeRep holding the parts of a record field.
1082 // </synopsis>
1083 
1085 {
1086 public:
1087  TaQLRecFldNodeRep (const String& name,
1088  const TaQLNode& values, const String& dtype);
1089  TaQLRecFldNodeRep (const String& name, const TaQLRecFldNodeRep&);
1090  TaQLRecFldNodeRep (const String& name, const String& fromName,
1091  const String& dtype);
1092  virtual ~TaQLRecFldNodeRep();
1093  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1094  virtual void show (std::ostream& os) const;
1095  virtual void save (AipsIO& aio) const;
1096  static TaQLRecFldNodeRep* restore (AipsIO& aio);
1097 
1102 };
1103 
1104 
1105 // <summary>
1106 // Raw TaQL parse tree node defining a unit.
1107 // </summary>
1108 // <use visibility=local>
1109 // <reviewed reviewer="" date="" tests="tTaQLNode">
1110 // </reviewed>
1111 // <prerequisite>
1112 //# Classes you should understand before using this one.
1113 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1114 // </prerequisite>
1115 // <synopsis>
1116 // This class is a TaQLNodeRep holding the parts of a record field.
1117 // </synopsis>
1118 
1120 {
1121 public:
1122  TaQLUnitNodeRep (const String& unit, const TaQLNode& child);
1123  virtual ~TaQLUnitNodeRep();
1124  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1125  virtual void show (std::ostream& os) const;
1126  virtual void save (AipsIO& aio) const;
1127  static TaQLUnitNodeRep* restore (AipsIO& aio);
1128 
1131 };
1132 
1133 
1134 // <summary>
1135 // Raw TaQL parse tree node defining an alter table command.
1136 // </summary>
1137 // <use visibility=local>
1138 // <reviewed reviewer="" date="" tests="tTaQLNode">
1139 // </reviewed>
1140 // <prerequisite>
1141 //# Classes you should understand before using this one.
1142 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1143 // </prerequisite>
1144 // <synopsis>
1145 // This class is a TaQLNodeRep holding the parts of the alter table command.
1146 // </synopsis>
1147 
1149 {
1150 public:
1151  TaQLAltTabNodeRep (const TaQLNode& table,
1152  const TaQLMultiNode& from,
1153  const TaQLMultiNode& commands);
1154  virtual ~TaQLAltTabNodeRep();
1155  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1156  virtual void showDerived (std::ostream& os) const;
1157  virtual void save (AipsIO& aio) const;
1158  static TaQLAltTabNodeRep* restore (AipsIO& aio);
1159 
1163 };
1164 
1165 
1166 // <summary>
1167 // Raw TaQL parse tree node defining an alter table add column command.
1168 // </summary>
1169 // <use visibility=local>
1170 // <reviewed reviewer="" date="" tests="tTaQLNode">
1171 // </reviewed>
1172 // <prerequisite>
1173 //# Classes you should understand before using this one.
1174 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1175 // </prerequisite>
1176 // <synopsis>
1177 // This class is a TaQLNodeRep holding the parts of the add column subcommand.
1178 // </synopsis>
1179 
1181 {
1182 public:
1183  TaQLAddColNodeRep (const TaQLMultiNode& cols, const TaQLMultiNode& dminfo);
1184  virtual ~TaQLAddColNodeRep();
1185  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1186  virtual void show (std::ostream& os) const;
1187  virtual void save (AipsIO& aio) const;
1188  static TaQLAddColNodeRep* restore (AipsIO& aio);
1189 
1192 };
1193 
1194 
1195 // <summary>
1196 // Raw TaQL parse tree node defining an alter table rename or drop command.
1197 // </summary>
1198 // <use visibility=local>
1199 // <reviewed reviewer="" date="" tests="tTaQLNode">
1200 // </reviewed>
1201 // <prerequisite>
1202 //# Classes you should understand before using this one.
1203 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1204 // </prerequisite>
1205 // <synopsis>
1206 // This class is a TaQLNodeRep holding the parts of the rename or drop subcommand.
1207 // </synopsis>
1208 
1210 {
1211 public:
1212  TaQLRenDropNodeRep (Int type, const TaQLMultiNode& cols);
1213  virtual ~TaQLRenDropNodeRep();
1214  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1215  virtual void show (std::ostream& os) const;
1216  virtual void save (AipsIO& aio) const;
1217  static TaQLRenDropNodeRep* restore (AipsIO& aio);
1218 
1221 };
1222 
1223 
1224 // <summary>
1225 // Raw TaQL parse tree node defining an alter table set keyword command.
1226 // </summary>
1227 // <use visibility=local>
1228 // <reviewed reviewer="" date="" tests="tTaQLNode">
1229 // </reviewed>
1230 // <prerequisite>
1231 //# Classes you should understand before using this one.
1232 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1233 // </prerequisite>
1234 // <synopsis>
1235 // This class is a TaQLNodeRep holding the parts of the set keyword subcommand.
1236 // </synopsis>
1237 
1239 {
1240 public:
1241  TaQLSetKeyNodeRep (const TaQLMultiNode& keyvals);
1242  virtual ~TaQLSetKeyNodeRep();
1243  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1244  virtual void show (std::ostream& os) const;
1245  virtual void save (AipsIO& aio) const;
1246  static TaQLSetKeyNodeRep* restore (AipsIO& aio);
1247 
1249 };
1250 
1251 
1252 // <summary>
1253 // Raw TaQL parse tree node defining an alter table add rows command.
1254 // </summary>
1255 // <use visibility=local>
1256 // <reviewed reviewer="" date="" tests="tTaQLNode">
1257 // </reviewed>
1258 // <prerequisite>
1259 //# Classes you should understand before using this one.
1260 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1261 // </prerequisite>
1262 // <synopsis>
1263 // This class is a TaQLNodeRep holding the parts of the add rows subcommand.
1264 // </synopsis>
1265 
1267 {
1268 public:
1269  TaQLAddRowNodeRep (const TaQLNode& nrow);
1270  virtual ~TaQLAddRowNodeRep();
1271  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1272  virtual void show (std::ostream& os) const;
1273  virtual void save (AipsIO& aio) const;
1274  static TaQLAddRowNodeRep* restore (AipsIO& aio);
1275 
1277 };
1278 
1279 
1280 // <summary>
1281 // Raw TaQL parse tree node defining an alter table command.
1282 // </summary>
1283 // <use visibility=local>
1284 // <reviewed reviewer="" date="" tests="tTaQLNode">
1285 // </reviewed>
1286 // <prerequisite>
1287 //# Classes you should understand before using this one.
1288 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1289 // </prerequisite>
1290 // <synopsis>
1291 // This class is a TaQLNodeRep holding the parts of the alter table command.
1292 // </synopsis>
1293 
1295 {
1296 public:
1297  TaQLConcTabNodeRep (const String& tableName,
1298  const TaQLMultiNode& tables,
1299  const TaQLMultiNode& subtableNames);
1300  virtual ~TaQLConcTabNodeRep();
1301  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1302  virtual void showDerived (std::ostream& os) const;
1303  virtual void save (AipsIO& aio) const;
1304  static TaQLConcTabNodeRep* restore (AipsIO& aio);
1305 
1309 };
1310 
1311 
1312 // <summary>
1313 // Raw TaQL parse tree node defining a show command.
1314 // </summary>
1315 // <use visibility=local>
1316 // <reviewed reviewer="" date="" tests="tTaQLNode">
1317 // </reviewed>
1318 // <prerequisite>
1319 //# Classes you should understand before using this one.
1320 // <li> <linkto class=TaQLNodeRep>TaQLNodeRep</linkto>
1321 // </prerequisite>
1322 // <synopsis>
1323 // This class is a TaQLNodeRep holding the parts of the show command.
1324 // </synopsis>
1325 
1327 {
1328 public:
1329  TaQLShowNodeRep (const TaQLMultiNode& names);
1330  virtual ~TaQLShowNodeRep();
1331  virtual TaQLNodeResult visit (TaQLNodeVisitor&) const;
1332  virtual void show (std::ostream& os) const;
1333  virtual void save (AipsIO& aio) const;
1334  static TaQLShowNodeRep* restore (AipsIO& aio);
1335 
1337 };
1338 
1339 
1340 } //# NAMESPACE CASACORE - END
1341 
1342 #endif
Raw TaQL parse tree node defining a selection command.
Definition: TaQLNodeDer.h:761
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size)
Definition: aipsxtype.h:38
Raw TaQL parse tree node defining a count command.
Definition: TaQLNodeDer.h:852
int Int
Definition: aipstype.h:50
static TaQLConstNodeRep * restore(AipsIO &aio)
Raw TaQL parse tree node defining an alter table add rows command.
Definition: TaQLNodeDer.h:1266
Raw TaQL parse tree node defining a select command.
Definition: TaQLNodeDer.h:807
Raw TaQL parse tree node defining an update command.
Definition: TaQLNodeDer.h:885
const std::vector< TaQLNode > & getNodes() const
Definition: TaQLNodeDer.h:267
AipsIO is the object persistency mechanism of Casacore.
Definition: AipsIO.h:168
virtual TaQLNodeResult visit(TaQLNodeVisitor &) const
Visit a node for tree traversal.
char nodeType() const
Get the node type of the derived class.
Definition: TaQLNodeRep.h:142
void setPPFix(const String &prefix, const String &postfix)
Definition: TaQLNodeDer.h:259
const String & getString() const
virtual void show(std::ostream &os) const
Print the object in an ostream.
Raw TaQL parse tree node defining a range.
Definition: TaQLNodeDer.h:329
Raw TaQL parse tree node defining an alter table set keyword command.
Definition: TaQLNodeDer.h:1238
Raw TaQL parse tree node defining a constant value.
Definition: TaQLNodeDer.h:61
Raw TaQL parse tree node defining a create table command.
Definition: TaQLNodeDer.h:1020
Raw TaQL parse tree node defining an index in a array.
Definition: TaQLNodeDer.h:364
Raw TaQL parse tree node defining a calc command.
Definition: TaQLNodeDer.h:986
virtual void save(AipsIO &aio) const
Save the object.
Raw TaQL parse tree node defining a list of nodes.
Definition: TaQLNodeDer.h:250
const String & getUnit() const
Definition: TaQLNodeDer.h:82
Raw TaQL parse tree node defining a delete command.
Definition: TaQLNodeDer.h:954
Envelope class for a node containing a list of nodes.
Definition: TaQLNode.h:223
Raw TaQL parse tree node defining a table.
Definition: TaQLNodeDer.h:457
Raw TaQL parse tree node defining a groupby list.
Definition: TaQLNodeDer.h:553
Raw TaQL parse tree node defining a giving expression list.
Definition: TaQLNodeDer.h:684
Envelope class for a node containing a constant regex value.
Definition: TaQLNode.h:200
Raw TaQL parse tree node defining a unary operator.
Definition: TaQLNodeDer.h:155
Raw TaQL parse tree node defining a constant regex value.
Definition: TaQLNodeDer.h:118
Normal or Gaussian distribution.
Definition: Random.h:997
Raw TaQL parse tree node defining a record field.
Definition: TaQLNodeDer.h:1084
double Double
Definition: aipstype.h:55
Raw TaQL parse tree node defining an alter table command.
Definition: TaQLNodeDer.h:1294
Raw TaQL parse tree node defining a keyword or column name.
Definition: TaQLNodeDer.h:426
bool Bool
Define the standard types used by Casacore.
Definition: aipstype.h:42
Raw TaQL parse tree node defining a function.
Definition: TaQLNodeDer.h:298
Raw TaQL parse tree node defining an alter table rename or drop command.
Definition: TaQLNodeDer.h:1209
Raw TaQL parse tree node defining a create column specification.
Definition: TaQLNodeDer.h:1053
const Bool False
Definition: aipstype.h:44
Raw TaQL parse tree node defining a unit.
Definition: TaQLNodeDer.h:1119
Raw TaQL parse tree node defining a column update expression.
Definition: TaQLNodeDer.h:718
Type
Do not change the values of this enum, as objects might be persistent.
Definition: TaQLNodeDer.h:590
TableExprNode regex(const TableExprNode &node)
Functions for regular expression matching and pattern matching.
Definition: ExprNode.h:1647
Type
Do not change the values of this enum, as objects might be persistent.
Definition: TaQLNodeDer.h:197
Envelope class to hold the result of a visit to the node tree.
Raw TaQL parse tree node defining a limit/offset expression.
Definition: TaQLNodeDer.h:654
void setSeparator(uInt incr, const String &sep)
Definition: TaQLNodeDer.h:263
std::vector< TaQLNode > itsNodes
Definition: TaQLNodeDer.h:274
Raw TaQL parse tree node defining a sort key.
Definition: TaQLNodeDer.h:586
Raw TaQL parse tree node defining a sort list.
Definition: TaQLNodeDer.h:620
Type
Do not change the values of this enum, as objects might be persistent.
Definition: TaQLNodeDer.h:159
Raw TaQL parse tree node defining an alter table add column command.
Definition: TaQLNodeDer.h:1180
String: the storage and methods of handling collections of characters.
Definition: String.h:223
Raw TaQL parse tree node defining a select column expression.
Definition: TaQLNodeDer.h:490
Raw TaQL parse tree node defining a show command.
Definition: TaQLNodeDer.h:1326
Raw TaQL parse tree node defining a select column list.
Definition: TaQLNodeDer.h:523
Raw TaQL parse tree node defining a join operation.
Definition: TaQLNodeDer.h:396
Envelope class for a node in the raw TaQL parse tree.
Definition: TaQLNode.h:81
Class to visit the nodes in the raw TaQL parse tree.
Type
Do not change the values of this enum, as objects might be persistent.
Definition: TaQLNodeDer.h:624
Type
Do not change the values of this enum, as objects might be persistent.
Definition: TaQLNodeDer.h:65
Class to handle date/time type conversions and I/O.
Definition: MVTime.h:266
void setSeparator(const String &sep)
Definition: TaQLNodeDer.h:261
const Bool True
Definition: aipstype.h:43
Raw TaQL parse tree node defining a binary operator.
Definition: TaQLNodeDer.h:193
this file contains all the compiler specific defines
Definition: mainpage.dox:28
Raw TaQL parse tree node defining an alter table command.
Definition: TaQLNodeDer.h:1148
LatticeExprNode value(const LatticeExprNode &expr)
This function returns the value of the expression without a mask.
Representation of a node in the raw TaQL parse tree.
Definition: TaQLNodeRep.h:76
Raw TaQL parse tree node defining an insert command.
Definition: TaQLNodeDer.h:921
unsigned int uInt
Definition: aipstype.h:51
void add(const TaQLNode &node)
Definition: TaQLNodeDer.h:265
Type
Do not change the values of this enum, as objects might be persistent.
Definition: TaQLNodeDer.h:557