001 /*
002 // $Id: XmlaConstants.java 485 2012-01-17 06:57:57Z jhyde $
003 //
004 // Licensed to Julian Hyde under one or more contributor license
005 // agreements. See the NOTICE file distributed with this work for
006 // additional information regarding copyright ownership.
007 //
008 // Julian Hyde licenses this file to you under the Apache License,
009 // Version 2.0 (the "License"); you may not use this file except in
010 // compliance with the License. You may obtain a copy of the License at:
011 //
012 // http://www.apache.org/licenses/LICENSE-2.0
013 //
014 // Unless required by applicable law or agreed to in writing, software
015 // distributed under the License is distributed on an "AS IS" BASIS,
016 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017 // See the License for the specific language governing permissions and
018 // limitations under the License.
019 */
020 package org.olap4j.metadata;
021
022 /**
023 * Collection of various enumerations and constants defined by the XML for
024 * Analysis (XMLA) and OLE DB for OLAP specifications.
025 *
026 * @author jhyde
027 * @version $Id: XmlaConstants.java 485 2012-01-17 06:57:57Z jhyde $
028 */
029 public class XmlaConstants
030 {
031 // Suppresses default constructor, ensuring non-instantiability.
032 private XmlaConstants() {
033 }
034
035 public enum VisualMode implements XmlaConstant {
036 DEFAULT(
037 0,
038 "Provider-dependent. In Microsoft SQL Server 2000 Analysis "
039 + "Services, this is equivalent to "
040 + "DBPROPVAL_VISUAL_MODE_ORIGINAL."),
041 VISUAL(
042 1,
043 "Visual totals are enabled."),
044 ORIGINAL(
045 2,
046 "Visual totals are not enabled.");
047
048 private final int xmlaOrdinal;
049 private final String description;
050
051 private static final DictionaryImpl<VisualMode> DICTIONARY =
052 DictionaryImpl.forClass(VisualMode.class);
053
054 /**
055 * Per {@link XmlaConstant}, returns a dictionary
056 * of all values of this enumeration.
057 *
058 * @return Dictionary of all values
059 */
060 public static Dictionary<VisualMode> getDictionary() {
061 return DICTIONARY;
062 }
063
064 VisualMode(
065 int xmlaOrdinal, String description)
066 {
067 this.xmlaOrdinal = xmlaOrdinal;
068 this.description = description;
069 }
070
071 public String xmlaName() {
072 return "DBPROPVAL_VISUAL_MODE_";
073 }
074
075 public String getDescription() {
076 return description;
077 }
078
079 public int xmlaOrdinal() {
080 return xmlaOrdinal;
081 }
082 }
083
084 public static enum Method implements XmlaConstant {
085 DISCOVER,
086 EXECUTE,
087 DISCOVER_AND_EXECUTE;
088
089 private static final DictionaryImpl<Method> DICTIONARY =
090 DictionaryImpl.forClass(Method.class);
091
092 /**
093 * Per {@link XmlaConstant}, returns a dictionary
094 * of all values of this enumeration.
095 *
096 * @return Dictionary of all values
097 */
098 public static Dictionary<Method> getDictionary() {
099 return DICTIONARY;
100 }
101
102 public String xmlaName() {
103 return name();
104 }
105
106 public String getDescription() {
107 return null;
108 }
109
110 public int xmlaOrdinal() {
111 return -1;
112 }
113 }
114
115 public enum Access implements XmlaConstant {
116 Read(1),
117 Write(2),
118 ReadWrite(3);
119
120 private final int xmlaOrdinal;
121
122 private static final DictionaryImpl<Access> DICTIONARY =
123 DictionaryImpl.forClass(Access.class);
124
125 /**
126 * Per {@link XmlaConstant}, returns a dictionary
127 * of all values of this enumeration.
128 *
129 * @return Dictionary of all values
130 */
131 public static Dictionary<Access> getDictionary() {
132 return DICTIONARY;
133 }
134
135 Access(int xmlaOrdinal) {
136 this.xmlaOrdinal = xmlaOrdinal;
137 }
138
139 public String xmlaName() {
140 return name();
141 }
142
143 public String getDescription() {
144 return null;
145 }
146
147 public int xmlaOrdinal() {
148 return xmlaOrdinal;
149 }
150 }
151
152 public static enum AuthenticationMode implements XmlaConstant {
153 Unauthenticated("no user ID or password needs to be sent."),
154 Authenticated(
155 "User ID and Password must be included in the information required "
156 + "for the connection."),
157 Integrated(
158 "the data source uses the underlying security to determine "
159 + "authorization, such as Integrated Security provided by "
160 + "Microsoft Internet Information Services (IIS).");
161
162 private final String description;
163
164 private static final DictionaryImpl<AuthenticationMode> DICTIONARY =
165 DictionaryImpl.forClass(AuthenticationMode.class);
166
167 /**
168 * Per {@link XmlaConstant}, returns a dictionary
169 * of all values of this enumeration.
170 *
171 * @return Dictionary of all values
172 */
173 public static Dictionary<AuthenticationMode> getDictionary() {
174 return DICTIONARY;
175 }
176
177 AuthenticationMode(String description) {
178 this.description = description;
179 }
180
181 public String xmlaName() {
182 return name();
183 }
184
185 public String getDescription() {
186 return description;
187 }
188
189 public int xmlaOrdinal() {
190 return -1;
191 }
192 }
193
194 public static enum ProviderType implements XmlaConstant {
195 TDP("tabular data provider."),
196 MDP("multidimensional data provider."),
197 DMP(
198 "data mining provider. A DMP provider implements the OLE DB for "
199 + "Data Mining specification.");
200
201 private final String description;
202
203 private static final DictionaryImpl<ProviderType> DICTIONARY =
204 DictionaryImpl.forClass(ProviderType.class);
205
206 /**
207 * Per {@link XmlaConstant}, returns a dictionary
208 * of all values of this enumeration.
209 *
210 * @return Dictionary of all values
211 */
212 public static Dictionary<ProviderType> getDictionary() {
213 return DICTIONARY;
214 }
215
216 private ProviderType(String description) {
217 this.description = description;
218 }
219
220 public String xmlaName() {
221 return name();
222 }
223
224 public String getDescription() {
225 return description;
226 }
227
228 public int xmlaOrdinal() {
229 return -1;
230 }
231 }
232
233 public static enum Updateable implements XmlaConstant {
234 MD_MASK_ENABLED(
235 0x00000000,
236 "The cell can be updated."),
237
238 MD_MASK_NOT_ENABLED(
239 0x10000000,
240 "The cell cannot be updated."),
241
242 CELL_UPDATE_ENABLED(
243 0x00000001,
244 "Cell can be updated in the cellset."),
245
246 CELL_UPDATE_ENABLED_WITH_UPDATE(
247 0x00000002,
248 "The cell can be updated with an update statement. The update may "
249 + "fail if a leaf cell is updated that is not write-enabled."),
250
251 CELL_UPDATE_NOT_ENABLED_FORMULA(
252 0x10000001,
253 "The cell cannot be updated because the cell has a calculated "
254 + "member among its coordinates; the cell was retrieved with a set "
255 + "in the where clause. A cell can be updated even though a "
256 + "formula affects, or a calculated cell is on, the value of a "
257 + "cell (is somewhere along the aggregation path). In this "
258 + "scenario, the final value of the cell may not be the updated "
259 + "value, because the calculation will affect the result."),
260
261 CELL_UPDATE_NOT_ENABLED_NONSUM_MEASURE(
262 0x10000002,
263 "The cell cannot be updated because non-sum measures (count, min, "
264 + "max, distinct count, semi-additive) can not be updated."),
265
266 CELL_UPDATE_NOT_ENABLED_NACELL_VIRTUALCUBE(
267 0x10000003,
268 "The cell cannot be updated because the cell does not exist as it "
269 + "is at the intersection of a measure and a dimension member "
270 + "unrelated to the measure???s measure group."),
271
272 CELL_UPDATE_NOT_ENABLED_SECURE(
273 0x10000005,
274 "The cell cannot be updated because the cell is secured."),
275
276 CELL_UPDATE_NOT_ENABLED_CALCLEVEL(
277 0x10000006,
278 "Reserved for future use."),
279
280 CELL_UPDATE_NOT_ENABLED_CANNOTUPDATE(
281 0x10000007,
282 "The cell cannot be updated because of internal reasons."),
283
284 CELL_UPDATE_NOT_ENABLED_INVALIDDIMENSIONTYPE(
285 0x10000009,
286 "The cell cannot be updated because update is not supported in "
287 + "mining model, indirect, or data mining dimensions.");
288
289 private final int xmlaOrdinal;
290 private final String description;
291
292 private static final Dictionary<Updateable> DICTIONARY =
293 DictionaryImpl.forClass(Updateable.class);
294
295 /**
296 * Per {@link XmlaConstant}, returns a dictionary
297 * of all values of this enumeration.
298 *
299 * @return Dictionary of all values
300 */
301 public static Dictionary<Updateable> getDictionary() {
302 return DICTIONARY;
303 }
304
305 Updateable(int xmlaOrdinal, String description) {
306 this.xmlaOrdinal = xmlaOrdinal;
307 this.description = description;
308 }
309
310 public String xmlaName() {
311 return name();
312 }
313
314 public String getDescription() {
315 return description;
316 }
317
318 public int xmlaOrdinal() {
319 return xmlaOrdinal;
320 }
321 }
322
323 public static enum FontFlag implements XmlaConstant {
324 BOLD(1),
325 ITALIC(2),
326 UNDERLINE(4),
327 STRIKEOUT(8);
328
329 private final int xmlaOrdinal;
330
331 private static final Dictionary<FontFlag> DICTIONARY =
332 DictionaryImpl.forClass(FontFlag.class);
333
334 /**
335 * Per {@link XmlaConstant}, returns a dictionary
336 * of all values of this enumeration.
337 *
338 * @return Dictionary of all values
339 */
340 public static Dictionary<FontFlag> getDictionary() {
341 return DICTIONARY;
342 }
343
344 FontFlag(int xmlaOrdinal) {
345 this.xmlaOrdinal = xmlaOrdinal;
346 }
347
348 public String xmlaName() {
349 return "MDFF_" + name();
350 }
351
352 public String getDescription() {
353 return name();
354 }
355
356 public int xmlaOrdinal() {
357 return xmlaOrdinal;
358 }
359 }
360
361 /**
362 * Action type.
363 *
364 * <p>Fields correspond to XMLA constants MDACTION_TYPE_URL (0x01),
365 * MDACTION_TYPE_HTML (0x02),
366 * MDACTION_TYPE_STATEMENT (0x04),
367 * MDACTION_TYPE_DATASET (0x08),
368 * MDACTION_TYPE_ROWSET (0x10),
369 * MDACTION_TYPE_COMMANDLINE (0x20),
370 * MDACTION_TYPE_PROPRIETARY (0x40),
371 * MDACTION_TYPE_REPORT (0x80),
372 * MDACTION_TYPE_DRILLTHROUGH (0x100)</p>
373 */
374 public static enum ActionType implements XmlaConstant {
375 URL(0x01),
376 HTML(0x02),
377 STATEMENT(0x04),
378 DATASET(0x08),
379 ROWSET(0x10),
380 COMMANDLINE(0x20),
381 PROPRIETARY(0x40),
382 REPORT(0x80),
383 DRILLTHROUGH(0x100);
384
385 private final int xmlaOrdinal;
386
387 private static final Dictionary<ActionType> DICTIONARY =
388 DictionaryImpl.forClass(ActionType.class);
389
390 /**
391 * Per {@link XmlaConstant}, returns a dictionary
392 * of all values of this enumeration.
393 *
394 * @return Dictionary of all values
395 */
396 public static Dictionary<ActionType> getDictionary() {
397 return DICTIONARY;
398 }
399
400 ActionType(int xmlaOrdinal) {
401 this.xmlaOrdinal = xmlaOrdinal;
402 }
403
404 public String xmlaName() {
405 return "MDACTION_TYPE_" + name();
406 }
407
408 public String getDescription() {
409 return name();
410 }
411
412 public int xmlaOrdinal() {
413 return xmlaOrdinal;
414 }
415 }
416
417 /**
418 * How the COORDINATE restriction column is interpreted.
419 *
420 * <p>Fields correspond to the XMLA values
421 * MDACTION_COORDINATE_CUBE (1),
422 * MDACTION_COORDINATE_DIMENSION (2)
423 * MDACTION_COORDINATE_LEVEL (3),
424 * MDACTION_COORDINATE_MEMBER (4),
425 * MDACTION_COORDINATE_SET (5),
426 * MDACTION_COORDINATE_CELL (6)</p>
427 */
428 public static enum CoordinateType implements XmlaConstant {
429 CUBE(1),
430 DIMENSION(2),
431 LEVEL(3),
432 MEMBER(4),
433 SET(5),
434 CELL(6);
435
436 private final int xmlaOrdinal;
437
438 private static final Dictionary<ActionType> DICTIONARY =
439 DictionaryImpl.forClass(ActionType.class);
440
441 /**
442 * Per {@link XmlaConstant}, returns a dictionary
443 * of all values of this enumeration.
444 *
445 * @return Dictionary of all values
446 */
447 public static Dictionary<ActionType> getDictionary() {
448 return DICTIONARY;
449 }
450
451 CoordinateType(int xmlaOrdinal) {
452 this.xmlaOrdinal = xmlaOrdinal;
453 }
454
455 public String xmlaName() {
456 return "MDACTION_COORDINATE_" + name();
457 }
458
459 public String getDescription() {
460 return name();
461 }
462
463 public int xmlaOrdinal() {
464 return xmlaOrdinal;
465 }
466 }
467
468 /**
469 * The only OLE DB Types Indicators returned by SQL Server are thoses coded
470 * below.
471 */
472 public enum DBType implements XmlaConstant {
473 /*
474 * The following values exactly match VARENUM
475 * in Automation and may be used in VARIANT.
476 */
477 I4(
478 "INTEGER", 3, "DBTYPE_I4", "A four-byte, signed integer: INTEGER"),
479
480 R8(
481 "DOUBLE", 5, "DBTYPE_R8",
482 "A double-precision floating-point value: Double"),
483
484 CY(
485 "CURRENCY", 6, "DBTYPE_CY",
486 "A currency value: LARGE_INTEGER, Currency is a fixed-point number "
487 + "with four digits to the right of the decimal point. It is "
488 + "stored in an eight-byte signed integer, scaled by 10,000."),
489
490 BOOL(
491 "BOOLEAN", 11, "DBTYPE_BOOL",
492 "A Boolean value stored in the same way as in Automation: "
493 + "VARIANT_BOOL; 0 means false and ~0 (bitwise, the value is not "
494 + "0; that is, all bits are set to 1) means true."),
495
496 /**
497 * Used by SQL Server for value.
498 */
499 VARIANT(
500 "VARIANT", 12, "DBTYPE_VARIANT", "An Automation VARIANT"),
501
502 /**
503 * Used by SQL Server for font size.
504 */
505 UI2("UNSIGNED_SHORT", 18, "DBTYPE_UI2", "A two-byte, unsigned integer"),
506
507 /**
508 * Used by SQL Server for colors, font flags and cell ordinal.
509 */
510 UI4(
511 "UNSIGNED_INTEGER", 19, "DBTYPE_UI4",
512 "A four-byte, unsigned integer"),
513
514 /*
515 * The following values exactly match VARENUM
516 * in Automation but cannot be used in VARIANT.
517 */
518 I8(
519 "LARGE_INTEGER", 20, "DBTYPE_I8",
520 "An eight-byte, signed integer: LARGE_INTEGER"),
521
522 /*
523 * The following values are not in VARENUM in OLE.
524 */
525 WSTR(
526 "STRING", 130, "DBTYPE_WSTR",
527 "A null-terminated Unicode character string: wchar_t[length]; If "
528 + "DBTYPE_WSTR is used by itself, the number of bytes allocated "
529 + "for the string, including the null-termination character, is "
530 + "specified by cbMaxLen in the DBBINDING structure. If "
531 + "DBTYPE_WSTR is combined with DBTYPE_BYREF, the number of bytes "
532 + "allocated for the string, including the null-termination "
533 + "character, is at least the length of the string plus two. In "
534 + "either case, the actual length of the string is determined from "
535 + "the bound length value. The maximum length of the string is the "
536 + "number of allocated bytes divided by sizeof(wchar_t) and "
537 + "truncated to the nearest integer.");
538
539
540 public final String userName;
541
542 /**
543 * The length of a non-numeric column or parameter that refers to either
544 * the maximum or the length defined for this type by the provider. For
545 * character data, this is the maximum or defined length in characters.
546 * For DateTime data types, this is the length of the string
547 * representation (assuming the maximum allowed precision of the
548 * fractional seconds component).
549 *
550 * If the data type is numeric, this is the upper bound on the maximum
551 * precision of the data type.
552 int columnSize;
553 */
554
555 private final int xmlaOrdinal;
556
557 /*
558 * A Boolean that indicates whether the data type is nullable.
559 * VARIANT_TRUE indicates that the data type is nullable.
560 * VARIANT_FALSE indicates that the data type is not nullable.
561 * NULL-- indicates that it is not known whether the data type is
562 * nullable.
563 boolean isNullable;
564 */
565
566 private String description;
567
568 private static final Dictionary<DBType> DICTIONARY =
569 DictionaryImpl.forClass(DBType.class);
570
571 /**
572 * Per {@link XmlaConstant}, returns a dictionary
573 * of all values of this enumeration.
574 *
575 * @return Dictionary of all values
576 */
577 public static Dictionary<DBType> getDictionary() {
578 return DICTIONARY;
579 }
580
581 DBType(
582 String userName,
583 int xmlaOrdinal,
584 String dbTypeIndicator,
585 String description)
586 {
587 this.userName = userName;
588 this.xmlaOrdinal = xmlaOrdinal;
589 this.description = description;
590 assert xmlaName().equals(dbTypeIndicator);
591 }
592
593 public String xmlaName() {
594 return "DBTYPE_" + name();
595 }
596
597 public String getDescription() {
598 return description;
599 }
600
601 public int xmlaOrdinal() {
602 return xmlaOrdinal;
603 }
604 }
605
606 public enum Format implements XmlaConstant {
607 Tabular(
608 "a flat or hierarchical rowset. Similar to the XML RAW format in "
609 + "SQL. The Format property should be set to Tabular for OLE DB "
610 + "for Data Mining commands."),
611 Multidimensional(
612 "Indicates that the result set will use the MDDataSet format "
613 + "(Execute method only)."),
614 Native(
615 "The client does not request a specific format, so the provider "
616 + "may return the format appropriate to the query. (The actual "
617 + "result type is identified by namespace of the result.)");
618
619 private final String description;
620
621 private static final Dictionary<Format> DICTIONARY =
622 DictionaryImpl.forClass(Format.class);
623
624 /**
625 * Per {@link XmlaConstant}, returns a dictionary
626 * of all values of this enumeration.
627 *
628 * @return Dictionary of all values
629 */
630 public static Dictionary<Format> getDictionary() {
631 return DICTIONARY;
632 }
633
634 Format(String description) {
635 this.description = description;
636 }
637
638 public String xmlaName() {
639 return name();
640 }
641
642 public String getDescription() {
643 return description;
644 }
645
646 public int xmlaOrdinal() {
647 return -1;
648 }
649 }
650
651 public enum AxisFormat implements XmlaConstant {
652 TupleFormat(
653 "The MDDataSet axis is made up of one or more CrossProduct "
654 + "elements."),
655 ClusterFormat(
656 "Analysis Services uses the TupleFormat format for this setting."),
657 CustomFormat(
658 "The MDDataSet axis contains one or more Tuple elements.");
659
660 private final String description;
661
662 private static final XmlaConstant.Dictionary<AxisFormat> DICTIONARY =
663 DictionaryImpl.forClass(AxisFormat.class);
664
665 /**
666 * Per {@link XmlaConstant}, returns a dictionary
667 * of all values of this enumeration.
668 *
669 * @return Dictionary of all values
670 */
671 public static XmlaConstant.Dictionary<AxisFormat> getDictionary() {
672 return DICTIONARY;
673 }
674
675 AxisFormat(String description) {
676 this.description = description;
677 }
678
679 public String xmlaName() {
680 return name();
681 }
682
683 public String getDescription() {
684 return description;
685 }
686
687 public int xmlaOrdinal() {
688 return -1;
689 }
690 }
691
692 public enum Content {
693 None,
694 Schema,
695 Data,
696 SchemaData,
697 DataOmitDefaultSlicer,
698 DataIncludeDefaultSlicer;
699
700 /** The content type default value - shared across more than one file */
701 public static final Content DEFAULT = SchemaData;
702 }
703
704 public enum MdxSupport {
705 Core
706 }
707
708 public enum StateSupport {
709 None,
710 Sessions
711 }
712
713 public enum Literal implements XmlaConstant {
714 CATALOG_NAME(
715 2, null, 24, ".", "0123456789",
716 "A catalog name in a text command."),
717 CATALOG_SEPARATOR(3, ".", 0, null, null, null),
718 COLUMN_ALIAS(5, null, -1, "'\"[]", "0123456789", null),
719 COLUMN_NAME(6, null, -1, ".", "0123456789", null),
720 CORRELATION_NAME(7, null, -1, "'\"[]", "0123456789", null),
721 CUBE_NAME(21, null, -1, ".", "0123456789", null),
722 DIMENSION_NAME(22, null, -1, ".", "0123456789", null),
723 HIERARCHY_NAME(23, null, -1, ".", "0123456789", null),
724 LEVEL_NAME(24, null, -1, ".", "0123456789", null),
725 MEMBER_NAME(25, null, -1, ".", "0123456789", null),
726 PROCEDURE_NAME(14, null, -1, ".", "0123456789", null),
727 PROPERTY_NAME(26, null, -1, ".", "0123456789", null),
728 QUOTE(
729 15, "[", -1, null, null,
730 "The character used in a text command as the opening quote for "
731 + "quoting identifiers that contain special characters."),
732 QUOTE_SUFFIX(
733 28, "]", -1, null, null,
734 "The character used in a text command as the closing quote for "
735 + "quoting identifiers that contain special characters. 1.x "
736 + "providers that use the same character as the prefix and suffix "
737 + "may not return this literal value and can set the lt member of "
738 + "the DBLITERAL structure to DBLITERAL_INVALID if requested."),
739 TABLE_NAME(17, null, -1, ".", "0123456789", null),
740 TEXT_COMMAND(
741 18, null, -1, null, null,
742 "A text command, such as an SQL statement."),
743 USER_NAME(19, null, 0, null, null, null);
744
745 /*
746 // Enum DBLITERALENUM and DBLITERALENUM20, OLEDB.H.
747 public static final int DBLITERAL_INVALID = 0,
748 DBLITERAL_BINARY_LITERAL = 1,
749 DBLITERAL_CATALOG_NAME = 2,
750 DBLITERAL_CATALOG_SEPARATOR = 3,
751 DBLITERAL_CHAR_LITERAL = 4,
752 DBLITERAL_COLUMN_ALIAS = 5,
753 DBLITERAL_COLUMN_NAME = 6,
754 DBLITERAL_CORRELATION_NAME = 7,
755 DBLITERAL_CURSOR_NAME = 8,
756 DBLITERAL_ESCAPE_PERCENT = 9,
757 DBLITERAL_ESCAPE_UNDERSCORE = 10,
758 DBLITERAL_INDEX_NAME = 11,
759 DBLITERAL_LIKE_PERCENT = 12,
760 DBLITERAL_LIKE_UNDERSCORE = 13,
761 DBLITERAL_PROCEDURE_NAME = 14,
762 DBLITERAL_QUOTE = 15,
763 DBLITERAL_QUOTE_PREFIX = DBLITERAL_QUOTE,
764 DBLITERAL_SCHEMA_NAME = 16,
765 DBLITERAL_TABLE_NAME = 17,
766 DBLITERAL_TEXT_COMMAND = 18,
767 DBLITERAL_USER_NAME = 19,
768 DBLITERAL_VIEW_NAME = 20,
769 DBLITERAL_CUBE_NAME = 21,
770 DBLITERAL_DIMENSION_NAME = 22,
771 DBLITERAL_HIERARCHY_NAME = 23,
772 DBLITERAL_LEVEL_NAME = 24,
773 DBLITERAL_MEMBER_NAME = 25,
774 DBLITERAL_PROPERTY_NAME = 26,
775 DBLITERAL_SCHEMA_SEPARATOR = 27,
776 DBLITERAL_QUOTE_SUFFIX = 28;
777 */
778
779 private int xmlaOrdinal;
780 private final String literalValue;
781 private final int literalMaxLength;
782 private final String literalInvalidChars;
783 private final String literalInvalidStartingChars;
784 private final String description;
785
786 private static final Dictionary<Literal> DICTIONARY =
787 DictionaryImpl.forClass(Literal.class);
788
789 /**
790 * Per {@link XmlaConstant}, returns a dictionary
791 * of all values of this enumeration.
792 *
793 * @return Dictionary of all values
794 */
795 public static Dictionary<Literal> getDictionary() {
796 return DICTIONARY;
797 }
798
799 Literal(
800 int xmlaOrdinal,
801 String literalValue,
802 int literalMaxLength,
803 String literalInvalidChars,
804 String literalInvalidStartingChars,
805 String description)
806 {
807 this.xmlaOrdinal = xmlaOrdinal;
808 this.literalValue = literalValue;
809 this.literalMaxLength = literalMaxLength;
810 this.literalInvalidChars = literalInvalidChars;
811 this.literalInvalidStartingChars = literalInvalidStartingChars;
812 this.description = description;
813 }
814
815 public String getLiteralName() {
816 return xmlaName();
817 }
818
819 public String getLiteralValue() {
820 return literalValue;
821 }
822
823 public String getLiteralInvalidChars() {
824 return literalInvalidChars;
825 }
826
827 public String getLiteralInvalidStartingChars() {
828 return literalInvalidStartingChars;
829 }
830
831 public int getLiteralMaxLength() {
832 return literalMaxLength;
833 }
834
835 public String xmlaName() {
836 return "DBLITERAL_" + name();
837 }
838
839 public String getDescription() {
840 return description;
841 }
842
843 public int xmlaOrdinal() {
844 return xmlaOrdinal;
845 }
846 }
847
848 public interface EnumWithDesc {
849 String getDescription();
850 }
851 }
852
853 // End XmlaConstants.java