Busqué en Google esta pregunta, pero no entiendo claramente qué es un esquema XML y DTD (definición de tipo de documento), y por qué el esquema XML es más poderoso en comparación con DTD.

Cualquier orientación sería muy apreciada.

De la sección Diferencias entre DTD y esquema de la conversión de un DTD en un artículo de esquema :

La diferencia crítica entre los DTD y el esquema XML es que el esquema XML utiliza una sintaxis basada en XML, mientras que los DTD tienen una sintaxis única retenida de los DTD de SGML. Aunque los DTD a menudo son criticados por esta necesidad de aprender una nueva sintaxis, la sintaxis en sí es bastante breve. Lo contrario es cierto para el Esquema XML, que es detallado, pero también hace uso de etiquetas y XML para que los autores de XML encuentren la sintaxis del Esquema XML menos intimidante.

El objetivo de los DTD era mantener un nivel de compatibilidad con SGML para las aplicaciones que querrían convertir los DTD de SGML en DTD XML. Sin embargo, de acuerdo con uno de los objetivos de XML, "la brevedad en el marcado XML es de importancia mínima", no existe una preocupación real por mantener breve la sintaxis.

[...]

Entonces, ¿cuáles son algunas de las otras diferencias que podrían ser especialmente importantes cuando estamos convirtiendo un DTD? Vamos a ver.

Mecanografía

La diferencia más significativa entre DTDs y XML Schema es la capacidad de crear y usar tipos de datos en Schema junto con declaraciones de elementos y atributos. De hecho, es una diferencia tan importante que la mitad de la Recomendación del Esquema XML está dedicada al tipo de datos y al Esquema XML. Cubrimos los tipos de datos en detalle en la Parte III de este libro, "Tipos de datos de esquema XML".

[...]

Restricciones de ocurrencia

Otra área donde los DTD y el esquema difieren significativamente es con las restricciones de ocurrencia. Si recuerda de nuestros ejemplos anteriores en el Capítulo 2, "Estructura de esquema" (o su propio trabajo con DTD), hay tres símbolos que puede usar para limitar el número de ocurrencias de un elemento: *, + y?.

[...]

Enumeraciones

Entonces, digamos que teníamos un elemento y queríamos poder definir un atributo de tamaño para la camisa, lo que permitió a los usuarios elegir un tamaño: pequeño, mediano o grande. Nuestro DTD se vería así:

<!ELEMENT item (shirt)>
<!ELEMENT shirt (#PCDATA)>
<!ATTLIST shirt
    size_value (small | medium | large)>

[...]

Pero, ¿y si quisiéramos sizeser un elemento? No podemos hacer eso con un DTD. Los DTD no proporcionan enumeraciones en el contenido de texto de un elemento. Sin embargo, debido a los tipos de datos con Schema, cuando declaramos la enumeración en el ejemplo anterior, en realidad creamos un simpleTypellamado size_valuesque ahora podemos usar con un elemento:

<xs:element name="size" type="size_value">

[...]

Las diferencias entre una definición de esquema XML (XSD) y la definición de tipo de documento (DTD) incluyen:

• Los esquemas XML se escriben en XML, mientras que DTD se deriva de la sintaxis SGML.
• Los esquemas XML definen tipos de datos para elementos y atributos, mientras que DTD no admite tipos de datos.
• Los esquemas XML permiten la compatibilidad con espacios de nombres, mientras que DTD no.
• Los esquemas XML definen el número y el orden de los elementos secundarios, mientras que DTD no.
• Los esquemas XML se pueden manipular por su cuenta con XML DOM, pero no es posible en el caso de DTD.
• El uso del esquema XML del usuario no necesita aprender un nuevo idioma, pero trabajar con DTD es difícil para un usuario.
• El esquema XML proporciona una comunicación de datos segura, es decir, el emisor puede describir los datos de una manera que el receptor lo entienda, pero en caso de que los datos de DTD puedan ser mal interpretados por el receptor.
• Los esquemas XML son extensibles, mientras que DTD no es extensible.

ACTUALIZACIÓN : 2015.08.26

No todas estas viñetas son 100% precisas, pero entiendes la esencia.

Por otra parte:

• DTD le permite definir nuevos valores de ENTIDAD para usar en su archivo XML.
• DTD le permite extenderlo localmente a un archivo XML individual.

Como muchas personas han mencionado antes, el Esquema XML utiliza una sintaxis basada en XML y los DTD tienen una sintaxis única. DTD no admite tipos de datos, lo que sí importa.

Veamos un ejemplo muy simple en el que la universidad tiene varios estudiantes y cada estudiante tiene dos elementos "nombre" y "año". Tenga en cuenta que tengo usos "// ->" en mi código solo para comentarios.

Ahora escribiré este ejemplo tanto en DTD como en XSD.

DTD

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE university[              // --> university as root element 
<!ELEMENT university (student*)>   // --> university has  * = Multiple students
<!ELEMENT student (name,year)>     // --> Student has elements name and year
<!ELEMENT name (#PCDATA)>          // --> name as Parsed character data
<!ELEMENT year (#PCDATA)>          // --> year as Parsed character data
]>

<university>
    <student>
        <name>
            John Niel             //---> I can also use an Integer,not good
        </name>
        <year>
            2000                 //---> I can also use a string,not good
        </year>
    </student>
</university>

Definición de esquema XML (XSD)

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<xsd:complexType name ="uniType">                    //--> complex datatype uniType
 <xsd:sequence>
  <xsd:element ref="student" maxOccurs="unbounded"/> //--> has unbounded no.of students
 </xsd:sequence>
</xsd:complexType>

<xsd:complexType name="stuType">                     //--> complex datatype stuType
 <xsd:sequence>
  <xsd:element ref="name"/>                          //--> has element name
  <xsd:element ref="year"/>                          //--> has element year
 </xsd:sequence>
</xsd:complexType>

<xsd:element name="university" type="uniType"/>       //--> university of type UniType 
<xsd:element name="student" type="stuType"/>          //--> student of type stuType
<xsd:element name="name" type="xsd:string"/>          //--> name of datatype string
<xsd:element name="year" type="xsd:integer"/>         //--> year of datatype integer
</xsd:schema>



<?xml version="1.0" encoding="UTF-8"?>
<university>
    <student>
        <name>
            John Niel          
        </name>
        <year>
            2000                      //--> only an Integer value is allowed
        </year>
    </student>
</university>

DTD es anterior a XML y, por lo tanto, no es un XML válido en sí mismo. Esa es probablemente la razón más importante para la invención de XSD.

Similitudes entre XSD y DTD

both specify elements, attributes, nesting, ordering, #occurences

Diferencias entre XSD y DTD

XSD also has data types, (typed) pointers, namespaces, keys and more.... unlike DTD 

Además, aunque XSD es poco detallado, su sintaxis es una extensión de XML, por lo que es conveniente aprender rápido.

Una diferencia es que en un DTD el modelo de contenido de un elemento está completamente determinado por su nombre, independientemente de dónde aparezca en el documento:

Asumiendo que quieres tener

• un personelemento
• con un elemento hijo llamado name
• un namesí tiene elementos secundarios firsty last.

Me gusta esto

   <person>
       <name>
            <first></first>
            <last></last>
       </name>
   </person>

Si un cityelemento en el mismo documento también debe tener 'nombre' de un elemento hijo del DTD requiere que este elemento 'nombre' debe tener elementos secundarios firsty lastasí. A pesar del hecho de que city.nameno requiere firsty lastcomo niños.

En contraste, el Esquema XML le permite declarar tipos de elementos secundarios localmente; podría declarar los nameelementos secundarios para ambos persony por cityseparado. Dándoles así sus modelos de contenido adecuados en esos contextos.

La otra gran diferencia es el soporte para espacios de nombres. Dado que los DTD son parte de la especificación XML original (y se heredan de SGML), no son conscientes del espacio de nombres porque los espacios de nombres XML se especificaron más adelante. Puede usar DTD en combinación con espacios de nombres, pero requiere algunas contorsiones, como ser forzado a definir los prefijos en el DTD y usar solo esos prefijos, en lugar de poder usar prefijos arbitrarios.

Para mí, otras diferencias son en su mayoría superficiales. El soporte de tipo de datos podría agregarse fácilmente a los DTD, y la sintaxis es solo sintaxis. (Yo, por mi parte, encuentro horrible la sintaxis del Esquema XML y nunca quisiera mantener un Esquema XML a mano, lo que no diría sobre DTD o esquemas RELAX NG; si por alguna razón necesito un Esquema XML, generalmente escribo uno RELAX NG y conviértalo con trang.)

Similitudes :

Los DTD y los esquemas realizan las mismas funciones básicas:

• Primero, ambos declaran una larga lista de elementos y atributos.
• Segundo, ambos describen cómo esos elementos se agrupan, anidan o usan dentro del XML. En otras palabras, declaran las reglas por las cuales le permite a alguien crear un archivo XML dentro de su flujo de trabajo, y
• En tercer lugar, tanto los DTD como los esquemas proporcionan métodos para restringir o forzar el tipo o formato de un elemento. Por ejemplo, dentro de DTD o Schema, puede forzar que un campo de fecha se escriba como 01/05/06 o 1/5/2006.

Diferencias:

• Los DTD son mejores para aplicaciones con uso intensivo de texto, mientras que los esquemas tienen varias ventajas para los flujos de trabajo con uso intensivo de datos.

• Los esquemas se escriben en XML y, por lo tanto, siguen las mismas reglas, mientras que los DTD se escriben en un lenguaje completamente diferente.

Ejemplos:

DTD:

<?xml version="1.0" encoding="UTF-8"?>
    <!ELEMENT employees (Efirstname, Elastname, Etitle, Ephone, Eemail)>
         <!ELEMENT Efirstname (#PCDATA)>
         <!ELEMENT Elastname (#PCDATA)>
         <!ELEMENT Etitle (#PCDATA)>
         <!ELEMENT Ephone (#PCDATA)>
         <!ELEMENT Eemail (#PCDATA)>

XSD:

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:od="urn:schemas-microsoft-com:officedata">
<xsd:element name="dataroot">
     <xsd:complexType>
          <xsd:sequence>
               <xsd:element ref="employees" minOccurs="0" maxOccurs="unbounded"/>
          </xsd:sequence>
          <xsd:attribute name="generated" type="xsd:dateTime"/>
      </xsd:complexType>
</xsd:element>
<xsd:element name="employees">
      <xsd:annotation>
           <xsd:appinfo>
               <od:index index-name="PrimaryKey" index-key="Employeeid " primary="yes"
                unique="yes" clustered="no"/>
          <od:index index-name="Employeeid" index-key="Employeeid " primary="no" unique="no"
           clustered="no"/>
     </xsd:appinfo>
</xsd:annotation>
     <xsd:complexType>
          <xsd:sequence>
               <xsd:element name="Elastname" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Etitle" minOccurs="0" od:jetType="text" od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Ephone" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Eemail" minOccurs="0" od:jetType="text"
               od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
               <xsd:element name="Ephoto" minOccurs="0" od:jetType="text"
                od:sqlSType="nvarchar">
                    <xsd:simpleType>
                         <xsd:restriction base="xsd:string">
                              <xsd:maxLength value="50"/>
                         </xsd:restriction>
                    </xsd:simpleType>
               </xsd:element>
          </xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>

DTD solo puede tener dos tipos de datos, el CDATA y el PCDATA. Pero en un esquema, puede usar todo el tipo de datos primitivos que usa en el lenguaje de programación y tiene la flexibilidad de definir sus propios tipos de datos personalizados.

El desarrollador que crea un esquema puede crear tipos de datos personalizados basados ​​en los tipos de datos principales y utilizando diferentes operadores y modificadores.

Cuando salió XML por primera vez, nos dijeron que resolvería todos nuestros problemas: XML será fácil de usar, infinitamente extensible, evitará el tipeo fuerte y no requerirá ninguna habilidad de programación. Aprendí sobre DTD y escribí mi propio analizador XML. Más de 15 años después, veo que la mayoría de XML no es fácil de usar y no es muy extensible (dependiendo de su uso). Tan pronto como algunos zuecos inteligentes conectaron XML a una base de datos, supe que los tipos de datos eran casi inevitables. Y, debería ver el XSLT (archivo de transformación) que tuve que trabajar el otro día. Si eso no es programación, ¡no sé qué es! Hoy en día no es inusual ver que todo tipo de problemas relacionados con los datos XML o las interfaces han salido mal. Me encanta XML, pero se ha alejado mucho de su punto de partida altruista original.

La respuesta corta? Los DTD han quedado en desuso a favor de los XSD porque un XSD le permite definir una estructura XML con más precisión.

DTD XML

El propósito de un DTD es definir la estructura de un documento XML. Define la estructura con una lista de elementos legales:

<!ATTLIST contact type CDATA #IMPLIED>
<!ELEMENT address1 ( #PCDATA)>
<!ELEMENT city ( #PCDATA)>
<!ELEMENT state ( #PCDATA)>
<!ELEMENT zip ( #PCDATA)>

Esquema XML

El esquema XML permite a los autores de esquemas especificar que los datos de la cantidad de elementos deben ser numéricos o, aún más específicamente, un número entero. En el siguiente ejemplo utilicé string:

<xs:element name="note">
<xs:complexType>
  <xs:sequence>
    <xs:element name="address1" type="xs:string"/>
    <xs:element name="city" type="xs:string"/>
    <xs:element name="state" type="xs:string"/>
    <xs:element name="zip" type="xs:string"/>
  </xs:sequence>
</xs:complexType>

DTD está bastante en desuso porque tiene una utilidad limitada como lenguaje de esquema, no admite espacio de nombres y no admite el tipo de datos. Además, la sintaxis de DTD es bastante complicada, lo que dificulta su comprensión y mantenimiento.

DTD indica la sintaxis del elemento XML

Los esquemas XML son la alternativa de Microsoft a DTD para validar XML