feat: add basic parser for xml

adapter/sql/SqlIdentifierApp.go

 package sql
 
 import (
+	"fmt"
 	"github.com/antlr/antlr4/runtime/Go/antlr"
+	. "github.com/phodal/coca/adapter/sql/parse"
 	parser "github.com/phodal/coca/language/sql"
 	"os"
 	"path/filepath"
@@ -13,6 +15,17 @@ type SqlIdentifierApp struct {
 }
 
 func (j *SqlIdentifierApp) AnalysisPath(codeDir string) {
+	xmlFiles := (*SqlIdentifierApp)(nil).xmlFiles(codeDir)
+	for _, xmlFile := range xmlFiles {
+		xmlFile, err := os.Open(xmlFile)
+		if err != nil {
+			fmt.Println(err)
+		}
+
+		parsedXml := ParseXml(xmlFile)
+		fmt.Println(parsedXml)
+	}
+
 	files := (*SqlIdentifierApp)(nil).sqlFiles(codeDir)
 	for index := range files {
 		file := files[index]
@@ -26,6 +39,17 @@ func (j *SqlIdentifierApp) AnalysisPath(codeDir string) {
 	}
 }
 
+func (j *SqlIdentifierApp) xmlFiles(codeDir string) []string {
+	files := make([]string, 0)
+	_ = filepath.Walk(codeDir, func(path string, fi os.FileInfo, err error) error {
+		if strings.HasSuffix(path, "Mapper.xml") {
+			files = append(files, path)
+		}
+		return nil
+	})
+	return files
+}
+
 func (j *SqlIdentifierApp) sqlFiles(codeDir string) []string {
 	files := make([]string, 0)
 	_ = filepath.Walk(codeDir, func(path string, fi os.FileInfo, err error) error {

adapter/sql/SqlIdentifierListener.go

@@ -22,5 +22,21 @@ func (s *SqlIdentifierListener) EnterSelect_or_values(ctx *Select_or_valuesConte
 }
 
 func (s *SqlIdentifierListener) EnterSelect_core(ctx *Select_coreContext) {
-	fmt.Println(ctx.GetText())
+	columns := ctx.AllResult_column()
+	for _, col := range columns {
+		column := col.(*Result_columnContext)
+		column.GetText()
+	}
+	if ctx.K_FROM() != nil {
+		subqueries := ctx.AllTable_or_subquery()
+		for _, subquery := range subqueries {
+			subqueryCtx := subquery.(*Table_or_subqueryContext)
+			if subqueryCtx.Table_name() != nil {
+				fmt.Println(subqueryCtx.Table_name().GetText())
+			}
+			if subqueryCtx.Database_name() != nil {
+				fmt.Println(subqueryCtx.Database_name().GetText())
+			}
+		}
+	}
 }

adapter/sql/parse/CollStack.go

+package parse
+
+import (
+	l "container/list"
+	"sync"
+)
+
+type stack struct {
+	list *l.List
+	mu sync.Mutex
+}
+
+func NewStack() *stack {
+	list := l.New()
+	return &stack{list: list,}
+}
+
+func (s *stack) Push(t interface{}){
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.list.PushFront(t)
+}
+
+func  (s *stack) Pop() interface{} {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	ele := s.list.Front()
+	if nil != ele {
+		s.list.Remove(ele)
+		return ele.Value
+	}
+
+	return nil
+}
+
+func (s *stack) Peak() interface{} {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	ele := s.list.Front()
+	return ele.Value
+}
+
+func (s *stack) Len() int {
+	return s.list.Len()
+}
+
+func (s *stack) IsEmpty() bool {
+	return s.list.Len() == 0
+}

adapter/sql/parse/LICENSE

+                                     Apache License
+                               Version 2.0, January 2004
+                            http://www.apache.org/licenses/
+
+       TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+       1. Definitions.
+
+          "License" shall mean the terms and conditions for use, reproduction,
+          and distribution as defined by Sections 1 through 9 of this document.
+
+          "Licensor" shall mean the copyright owner or entity authorized by
+          the copyright owner that is granting the License.
+
+          "Legal Entity" shall mean the union of the acting entity and all
+          other entities that control, are controlled by, or are under common
+          control with that entity. For the purposes of this definition,
+          "control" means (i) the power, direct or indirect, to cause the
+          direction or management of such entity, whether by contract or
+          otherwise, or (ii) ownership of fifty percent (50%) or more of the
+          outstanding shares, or (iii) beneficial ownership of such entity.
+
+          "You" (or "Your") shall mean an individual or Legal Entity
+          exercising permissions granted by this License.
+
+          "Source" form shall mean the preferred form for making modifications,
+          including but not limited to software source code, documentation
+          source, and configuration files.
+
+          "Object" form shall mean any form resulting from mechanical
+          transformation or translation of a Source form, including but
+          not limited to compiled object code, generated documentation,
+          and conversions to other media types.
+
+          "Work" shall mean the work of authorship, whether in Source or
+          Object form, made available under the License, as indicated by a
+          copyright notice that is included in or attached to the work
+          (an example is provided in the Appendix below).
+
+          "Derivative Works" shall mean any work, whether in Source or Object
+          form, that is based on (or derived from) the Work and for which the
+          editorial revisions, annotations, elaborations, or other modifications
+          represent, as a whole, an original work of authorship. For the purposes
+          of this License, Derivative Works shall not include works that remain
+          separable from, or merely link (or bind by name) to the interfaces of,
+          the Work and Derivative Works thereof.
+
+          "Contribution" shall mean any work of authorship, including
+          the original version of the Work and any modifications or additions
+          to that Work or Derivative Works thereof, that is intentionally
+          submitted to Licensor for inclusion in the Work by the copyright owner
+          or by an individual or Legal Entity authorized to submit on behalf of
+          the copyright owner. For the purposes of this definition, "submitted"
+          means any form of electronic, verbal, or written communication sent
+          to the Licensor or its representatives, including but not limited to
+          communication on electronic mailing lists, source code control systems,
+          and issue tracking systems that are managed by, or on behalf of, the
+          Licensor for the purpose of discussing and improving the Work, but
+          excluding communication that is conspicuously marked or otherwise
+          designated in writing by the copyright owner as "Not a Contribution."
+
+          "Contributor" shall mean Licensor and any individual or Legal Entity
+          on behalf of whom a Contribution has been received by Licensor and
+          subsequently incorporated within the Work.
+
+       2. Grant of Copyright License. Subject to the terms and conditions of
+          this License, each Contributor hereby grants to You a perpetual,
+          worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+          copyright license to reproduce, prepare Derivative Works of,
+          publicly display, publicly perform, sublicense, and distribute the
+          Work and such Derivative Works in Source or Object form.
+
+       3. Grant of Patent License. Subject to the terms and conditions of
+          this License, each Contributor hereby grants to You a perpetual,
+          worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+          (except as stated in this section) patent license to make, have made,
+          use, offer to sell, sell, import, and otherwise transfer the Work,
+          where such license applies only to those patent claims licensable
+          by such Contributor that are necessarily infringed by their
+          Contribution(s) alone or by combination of their Contribution(s)
+          with the Work to which such Contribution(s) was submitted. If You
+          institute patent litigation against any entity (including a
+          cross-claim or counterclaim in a lawsuit) alleging that the Work
+          or a Contribution incorporated within the Work constitutes direct
+          or contributory patent infringement, then any patent licenses
+          granted to You under this License for that Work shall terminate
+          as of the date such litigation is filed.
+
+       4. Redistribution. You may reproduce and distribute copies of the
+          Work or Derivative Works thereof in any medium, with or without
+          modifications, and in Source or Object form, provided that You
+          meet the following conditions:
+
+          (a) You must give any other recipients of the Work or
+              Derivative Works a copy of this License; and
+
+          (b) You must cause any modified files to carry prominent notices
+              stating that You changed the files; and
+
+          (c) You must retain, in the Source form of any Derivative Works
+              that You distribute, all copyright, patent, trademark, and
+              attribution notices from the Source form of the Work,
+              excluding those notices that do not pertain to any part of
+              the Derivative Works; and
+
+          (d) If the Work includes a "NOTICE" text file as part of its
+              distribution, then any Derivative Works that You distribute must
+              include a readable copy of the attribution notices contained
+              within such NOTICE file, excluding those notices that do not
+              pertain to any part of the Derivative Works, in at least one
+              of the following places: within a NOTICE text file distributed
+              as part of the Derivative Works; within the Source form or
+              documentation, if provided along with the Derivative Works; or,
+              within a display generated by the Derivative Works, if and
+              wherever such third-party notices normally appear. The contents
+              of the NOTICE file are for informational purposes only and
+              do not modify the License. You may add Your own attribution
+              notices within Derivative Works that You distribute, alongside
+              or as an addendum to the NOTICE text from the Work, provided
+              that such additional attribution notices cannot be construed
+              as modifying the License.
+
+          You may add Your own copyright statement to Your modifications and
+          may provide additional or different license terms and conditions
+          for use, reproduction, or distribution of Your modifications, or
+          for any such Derivative Works as a whole, provided Your use,
+          reproduction, and distribution of the Work otherwise complies with
+          the conditions stated in this License.
+
+       5. Submission of Contributions. Unless You explicitly state otherwise,
+          any Contribution intentionally submitted for inclusion in the Work
+          by You to the Licensor shall be under the terms and conditions of
+          this License, without any additional terms or conditions.
+          Notwithstanding the above, nothing herein shall supersede or modify
+          the terms of any separate license agreement you may have executed
+          with Licensor regarding such Contributions.
+
+       6. Trademarks. This License does not grant permission to use the trade
+          names, trademarks, service marks, or product names of the Licensor,
+          except as required for reasonable and customary use in describing the
+          origin of the Work and reproducing the content of the NOTICE file.
+
+       7. Disclaimer of Warranty. Unless required by applicable law or
+          agreed to in writing, Licensor provides the Work (and each
+          Contributor provides its Contributions) on an "AS IS" BASIS,
+          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+          implied, including, without limitation, any warranties or conditions
+          of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+          PARTICULAR PURPOSE. You are solely responsible for determining the
+          appropriateness of using or redistributing the Work and assume any
+          risks associated with Your exercise of permissions under this License.
+
+       8. Limitation of Liability. In no event and under no legal theory,
+          whether in tort (including negligence), contract, or otherwise,
+          unless required by applicable law (such as deliberate and grossly
+          negligent acts) or agreed to in writing, shall any Contributor be
+          liable to You for damages, including any direct, indirect, special,
+          incidental, or consequential damages of any character arising as a
+          result of this License or out of the use or inability to use the
+          Work (including but not limited to damages for loss of goodwill,
+          work stoppage, computer failure or malfunction, or any and all
+          other commercial damages or losses), even if such Contributor
+          has been advised of the possibility of such damages.
+
+       9. Accepting Warranty or Additional Liability. While redistributing
+          the Work or Derivative Works thereof, You may choose to offer,
+          and charge a fee for, acceptance of support, warranty, indemnity,
+          or other liability obligations and/or rights consistent with this
+          License. However, in accepting such obligations, You may act only
+          on Your own behalf and on Your sole responsibility, not on behalf
+          of any other Contributor, and only if You agree to indemnify,
+          defend, and hold each Contributor harmless for any liability
+          incurred by, or claims asserted against, such Contributor by reason
+          of your accepting any such warranty or additional liability.
+
+       END OF TERMS AND CONDITIONS
+
+       APPENDIX: How to apply the Apache License to your work.
+
+          To apply the Apache License to your work, attach the following
+          boilerplate notice, with the fields enclosed by brackets "[]"
+          replaced with your own identifying information. (Don't include
+          the brackets!)  The text should be enclosed in the appropriate
+          comment syntax for the file format. We also recommend that a
+          file or class name and description of purpose be included on the
+          same "printed page" as the copyright notice for easier
+          identification within third-party archives.
+
+       Copyright [yyyy] [name of copyright owner]
+
+       Licensed under the Apache License, Version 2.0 (the "License");
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+
+           http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.

adapter/sql/parse/README.md

+Based On: https://github.com/wenj91/gobatis
+

adapter/sql/parse/XmlParser.go

+package parse
+
+import (
+	"encoding/xml"
+	"io"
+	"strings"
+)
+
+type ElemType string
+
+const (
+	eleTpText ElemType = "text" // 静态文本节点
+	eleTpNode ElemType = "node" // 节点子节点
+)
+
+type node struct {
+	Id       string
+	Name     string
+	Attrs    map[string]xml.Attr
+	Elements []element
+}
+
+type element struct {
+	ElementType ElemType
+	Val         interface{}
+}
+
+func ParseXml(r io.Reader) *node {
+	parser := xml.NewDecoder(r)
+	var root node
+
+	st := NewStack()
+	for {
+		token, err := parser.Token()
+		if err != nil {
+			break
+		}
+		switch t := token.(type) {
+		case xml.StartElement: //tag start
+			elmt := xml.StartElement(t)
+			name := elmt.Name.Local
+			attr := elmt.Attr
+			attrMap := make(map[string]xml.Attr)
+			for _, val := range attr {
+				attrMap[val.Name.Local] = val
+			}
+			node := node{
+				Name:     name,
+				Attrs:    attrMap,
+				Elements: make([]element, 0),
+			}
+			for _, val := range attr {
+				if val.Name.Local == "id" {
+					node.Id = val.Value
+				}
+			}
+			st.Push(node)
+
+		case xml.EndElement: //tag end
+			if st.Len() > 0 {
+				//cur node
+				n := st.Pop().(node)
+				if st.Len() > 0 { //if the root node then append to element
+					e := element{
+						ElementType: eleTpNode,
+						Val:         n,
+					}
+
+					pn := st.Pop().(node)
+					els := pn.Elements
+					els = append(els, e)
+					pn.Elements = els
+					st.Push(pn)
+				} else { //else root = n
+					root = n
+				}
+			}
+		case xml.CharData: //tag content
+			if st.Len() > 0 {
+				n := st.Pop().(node)
+
+				bytes := xml.CharData(t)
+				content := strings.TrimSpace(string(bytes))
+				if content != "" {
+					e := element{
+						ElementType: eleTpText,
+						Val:         content,
+					}
+					els := n.Elements
+					els = append(els, e)
+					n.Elements = els
+				}
+
+				st.Push(n)
+			}
+
+		case xml.Comment:
+		case xml.ProcInst:
+		case xml.Directive:
+		default:
+		}
+	}
+
+	if st.Len() != 0 {
+		panic("Parse xml error, there is tag no close, please check your xml config!")
+	}
+
+	return &root
+}

examples/api/mapper/BookMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.phodal.pholedge.mapper.BookMapper">
+    <select id="doSave" parameterType="com.phodal.pholedge.book.model.Book">
+        INSERT INTO book (id, isbn, name, createdAt) VALUES (#{id}, #{isbn}, #{name}, #{createdAt}) ON DUPLICATE KEY UPDATE isbn=#{isbn}, name=#{name}
+    </select>
+    <select id="list" resultType="com.phodal.pholedge.book.model.BookRepresentaion">
+        select * from book order by id
+    </select>
+    <select id="byId" resultType="com.phodal.pholedge.book.model.Book">
+        select * from book where id = #{id}
+    </select>
+</mapper>
\ No newline at end of file

examples/api/mapper/mybatis-3-mapper.dtd

+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+
+       Copyright 2009-2018 the original author or authors.
+
+       Licensed under the Apache License, Version 2.0 (the "License");
+       you may not use this file except in compliance with the License.
+       You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing, software
+       distributed under the License is distributed on an "AS IS" BASIS,
+       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+       See the License for the specific language governing permissions and
+       limitations under the License.
+
+-->
+<!ELEMENT mapper (cache-ref | cache | resultMap* | parameterMap* | sql* | insert* | update* | delete* | select* )+>
+<!ATTLIST mapper
+namespace CDATA #IMPLIED
+>
+
+<!ELEMENT cache-ref EMPTY>
+<!ATTLIST cache-ref
+namespace CDATA #REQUIRED
+>
+
+<!ELEMENT cache (property*)>
+<!ATTLIST cache
+type CDATA #IMPLIED
+eviction CDATA #IMPLIED
+flushInterval CDATA #IMPLIED
+size CDATA #IMPLIED
+readOnly CDATA #IMPLIED
+blocking CDATA #IMPLIED
+>
+
+<!ELEMENT parameterMap (parameter+)?>
+<!ATTLIST parameterMap
+id CDATA #REQUIRED
+type CDATA #REQUIRED
+>
+
+<!ELEMENT parameter EMPTY>
+<!ATTLIST parameter
+property CDATA #REQUIRED
+javaType CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+mode (IN | OUT | INOUT) #IMPLIED
+resultMap CDATA #IMPLIED
+scale CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+>
+
+<!ELEMENT resultMap (constructor?,id*,result*,association*,collection*, discriminator?)>
+<!ATTLIST resultMap
+id CDATA #REQUIRED
+type CDATA #REQUIRED
+extends CDATA #IMPLIED
+autoMapping (true|false) #IMPLIED
+>
+
+<!ELEMENT constructor (idArg*,arg*)>
+
+<!ELEMENT id EMPTY>
+<!ATTLIST id
+property CDATA #IMPLIED
+javaType CDATA #IMPLIED
+column CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+>
+
+<!ELEMENT result EMPTY>
+<!ATTLIST result
+property CDATA #IMPLIED
+javaType CDATA #IMPLIED
+column CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+>
+
+<!ELEMENT idArg EMPTY>
+<!ATTLIST idArg
+javaType CDATA #IMPLIED
+column CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+select CDATA #IMPLIED
+resultMap CDATA #IMPLIED
+name CDATA #IMPLIED
+columnPrefix CDATA #IMPLIED
+>
+
+<!ELEMENT arg EMPTY>
+<!ATTLIST arg
+javaType CDATA #IMPLIED
+column CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+select CDATA #IMPLIED
+resultMap CDATA #IMPLIED
+name CDATA #IMPLIED
+columnPrefix CDATA #IMPLIED
+>
+
+<!ELEMENT collection (constructor?,id*,result*,association*,collection*, discriminator?)>
+<!ATTLIST collection
+property CDATA #REQUIRED
+column CDATA #IMPLIED
+javaType CDATA #IMPLIED
+ofType CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+select CDATA #IMPLIED
+resultMap CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+notNullColumn CDATA #IMPLIED
+columnPrefix CDATA #IMPLIED
+resultSet CDATA #IMPLIED
+foreignColumn CDATA #IMPLIED
+autoMapping (true|false) #IMPLIED
+fetchType (lazy|eager) #IMPLIED
+>
+
+<!ELEMENT association (constructor?,id*,result*,association*,collection*, discriminator?)>
+<!ATTLIST association
+property CDATA #REQUIRED
+column CDATA #IMPLIED
+javaType CDATA #IMPLIED
+jdbcType CDATA #IMPLIED
+select CDATA #IMPLIED
+resultMap CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+notNullColumn CDATA #IMPLIED
+columnPrefix CDATA #IMPLIED
+resultSet CDATA #IMPLIED
+foreignColumn CDATA #IMPLIED
+autoMapping (true|false) #IMPLIED
+fetchType (lazy|eager) #IMPLIED
+>
+
+<!ELEMENT discriminator (case+)>
+<!ATTLIST discriminator
+column CDATA #IMPLIED
+javaType CDATA #REQUIRED
+jdbcType CDATA #IMPLIED
+typeHandler CDATA #IMPLIED
+>
+
+<!ELEMENT case (constructor?,id*,result*,association*,collection*, discriminator?)>
+<!ATTLIST case
+value CDATA #REQUIRED
+resultMap CDATA #IMPLIED
+resultType CDATA #IMPLIED
+>
+
+<!ELEMENT property EMPTY>
+<!ATTLIST property
+name CDATA #REQUIRED
+value CDATA #REQUIRED
+>
+
+<!ELEMENT typeAlias EMPTY>
+<!ATTLIST typeAlias
+alias CDATA #REQUIRED
+type CDATA #REQUIRED
+>
+
+<!ELEMENT select (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST select
+id CDATA #REQUIRED
+parameterMap CDATA #IMPLIED
+parameterType CDATA #IMPLIED
+resultMap CDATA #IMPLIED
+resultType CDATA #IMPLIED
+resultSetType (FORWARD_ONLY | SCROLL_INSENSITIVE | SCROLL_SENSITIVE | DEFAULT) #IMPLIED
+statementType (STATEMENT|PREPARED|CALLABLE) #IMPLIED
+fetchSize CDATA #IMPLIED
+timeout CDATA #IMPLIED
+flushCache (true|false) #IMPLIED
+useCache (true|false) #IMPLIED
+databaseId CDATA #IMPLIED
+lang CDATA #IMPLIED
+resultOrdered (true|false) #IMPLIED
+resultSets CDATA #IMPLIED 
+>
+
+<!ELEMENT insert (#PCDATA | selectKey | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST insert
+id CDATA #REQUIRED
+parameterMap CDATA #IMPLIED
+parameterType CDATA #IMPLIED
+timeout CDATA #IMPLIED
+flushCache (true|false) #IMPLIED
+statementType (STATEMENT|PREPARED|CALLABLE) #IMPLIED
+keyProperty CDATA #IMPLIED
+useGeneratedKeys (true|false) #IMPLIED
+keyColumn CDATA #IMPLIED
+databaseId CDATA #IMPLIED
+lang CDATA #IMPLIED
+>
+
+<!ELEMENT selectKey (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST selectKey
+resultType CDATA #IMPLIED
+statementType (STATEMENT|PREPARED|CALLABLE) #IMPLIED
+keyProperty CDATA #IMPLIED
+keyColumn CDATA #IMPLIED
+order (BEFORE|AFTER) #IMPLIED
+databaseId CDATA #IMPLIED
+>
+
+<!ELEMENT update (#PCDATA | selectKey | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST update
+id CDATA #REQUIRED
+parameterMap CDATA #IMPLIED
+parameterType CDATA #IMPLIED
+timeout CDATA #IMPLIED
+flushCache (true|false) #IMPLIED
+statementType (STATEMENT|PREPARED|CALLABLE) #IMPLIED
+keyProperty CDATA #IMPLIED
+useGeneratedKeys (true|false) #IMPLIED
+keyColumn CDATA #IMPLIED
+databaseId CDATA #IMPLIED
+lang CDATA #IMPLIED
+>
+
+<!ELEMENT delete (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST delete
+id CDATA #REQUIRED
+parameterMap CDATA #IMPLIED
+parameterType CDATA #IMPLIED
+timeout CDATA #IMPLIED
+flushCache (true|false) #IMPLIED
+statementType (STATEMENT|PREPARED|CALLABLE) #IMPLIED
+databaseId CDATA #IMPLIED
+lang CDATA #IMPLIED
+>
+
+<!-- Dynamic -->
+
+<!ELEMENT include (property+)?>
+<!ATTLIST include
+refid CDATA #REQUIRED
+>
+
+<!ELEMENT bind EMPTY>
+<!ATTLIST bind
+ name CDATA #REQUIRED
+ value CDATA #REQUIRED
+>
+
+<!ELEMENT sql (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST sql
+id CDATA #REQUIRED
+lang CDATA #IMPLIED
+databaseId CDATA #IMPLIED
+>
+
+<!ELEMENT trim (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST trim
+prefix CDATA #IMPLIED
+prefixOverrides CDATA #IMPLIED
+suffix CDATA #IMPLIED
+suffixOverrides CDATA #IMPLIED
+>
+<!ELEMENT where (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ELEMENT set (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+
+<!ELEMENT foreach (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST foreach
+collection CDATA #REQUIRED
+item CDATA #IMPLIED
+index CDATA #IMPLIED
+open CDATA #IMPLIED
+close CDATA #IMPLIED
+separator CDATA #IMPLIED
+>
+
+<!ELEMENT choose (when* , otherwise?)>
+<!ELEMENT when (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST when
+test CDATA #REQUIRED
+>
+<!ELEMENT otherwise (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+
+<!ELEMENT if (#PCDATA | include | trim | where | set | foreach | choose | if | bind)*>
+<!ATTLIST if
+test CDATA #REQUIRED
+>
+
+