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