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