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*/
020package 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 */
029public 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