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