diff --git a/examples/cli.rs b/examples/cli.rs
index f288fd138..77a0b5014 100644
--- a/examples/cli.rs
+++ b/examples/cli.rs
@@ -19,7 +19,7 @@ use simple_logger;
 use std::fs;
 
 use sqlparser::dialect::*;
-use sqlparser::sqlparser::Parser;
+use sqlparser::parser::Parser;
 
 fn main() {
     simple_logger::init().unwrap();
@@ -30,10 +30,10 @@ fn main() {
     );
 
     let dialect: Box<dyn Dialect> = match std::env::args().nth(2).unwrap_or_default().as_ref() {
-        "--ansi" => Box::new(AnsiSqlDialect {}),
+        "--ansi" => Box::new(AnsiDialect {}),
         "--postgres" => Box::new(PostgreSqlDialect {}),
         "--ms" => Box::new(MsSqlDialect {}),
-        "--generic" | "" => Box::new(GenericSqlDialect {}),
+        "--generic" | "" => Box::new(GenericDialect {}),
         s => panic!("Unexpected parameter: {}", s),
     };
 
diff --git a/examples/parse_select.rs b/examples/parse_select.rs
index d79ab26ed..539d91652 100644
--- a/examples/parse_select.rs
+++ b/examples/parse_select.rs
@@ -12,8 +12,8 @@
 
 #![warn(clippy::all)]
 
-use sqlparser::dialect::GenericSqlDialect;
-use sqlparser::sqlparser::*;
+use sqlparser::dialect::GenericDialect;
+use sqlparser::parser::*;
 
 fn main() {
     let sql = "SELECT a, b, 123, myfunc(b) \
@@ -21,7 +21,7 @@ fn main() {
                WHERE a > b AND b < 100 \
                ORDER BY a DESC, b";
 
-    let dialect = GenericSqlDialect {};
+    let dialect = GenericDialect {};
 
     let ast = Parser::parse_sql(&dialect, sql.to_string()).unwrap();
 
diff --git a/src/sqlast/sqltype.rs b/src/ast/data_type.rs
similarity index 58%
rename from src/sqlast/sqltype.rs
rename to src/ast/data_type.rs
index 5b63f1db4..4aede8590 100644
--- a/src/sqlast/sqltype.rs
+++ b/src/ast/data_type.rs
@@ -10,11 +10,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::SQLObjectName;
+use super::ObjectName;
 
 /// SQL data types
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLType {
+pub enum DataType {
     /// Fixed-length character type e.g. CHAR(10)
     Char(Option<u64>),
     /// Variable-length character type e.g. VARCHAR(10)
@@ -60,44 +60,44 @@ pub enum SQLType {
     /// Bytea
     Bytea,
     /// Custom type such as enums
-    Custom(SQLObjectName),
+    Custom(ObjectName),
     /// Arrays
-    Array(Box<SQLType>),
+    Array(Box<DataType>),
 }
 
-impl ToString for SQLType {
+impl ToString for DataType {
     fn to_string(&self) -> String {
         match self {
-            SQLType::Char(size) => format_type_with_optional_length("char", size),
-            SQLType::Varchar(size) => format_type_with_optional_length("character varying", size),
-            SQLType::Uuid => "uuid".to_string(),
-            SQLType::Clob(size) => format!("clob({})", size),
-            SQLType::Binary(size) => format!("binary({})", size),
-            SQLType::Varbinary(size) => format!("varbinary({})", size),
-            SQLType::Blob(size) => format!("blob({})", size),
-            SQLType::Decimal(precision, scale) => {
+            DataType::Char(size) => format_type_with_optional_length("char", size),
+            DataType::Varchar(size) => format_type_with_optional_length("character varying", size),
+            DataType::Uuid => "uuid".to_string(),
+            DataType::Clob(size) => format!("clob({})", size),
+            DataType::Binary(size) => format!("binary({})", size),
+            DataType::Varbinary(size) => format!("varbinary({})", size),
+            DataType::Blob(size) => format!("blob({})", size),
+            DataType::Decimal(precision, scale) => {
                 if let Some(scale) = scale {
                     format!("numeric({},{})", precision.unwrap(), scale)
                 } else {
                     format_type_with_optional_length("numeric", precision)
                 }
             }
-            SQLType::Float(size) => format_type_with_optional_length("float", size),
-            SQLType::SmallInt => "smallint".to_string(),
-            SQLType::Int => "int".to_string(),
-            SQLType::BigInt => "bigint".to_string(),
-            SQLType::Real => "real".to_string(),
-            SQLType::Double => "double".to_string(),
-            SQLType::Boolean => "boolean".to_string(),
-            SQLType::Date => "date".to_string(),
-            SQLType::Time => "time".to_string(),
-            SQLType::Timestamp => "timestamp".to_string(),
-            SQLType::Interval => "interval".to_string(),
-            SQLType::Regclass => "regclass".to_string(),
-            SQLType::Text => "text".to_string(),
-            SQLType::Bytea => "bytea".to_string(),
-            SQLType::Array(ty) => format!("{}[]", ty.to_string()),
-            SQLType::Custom(ty) => ty.to_string(),
+            DataType::Float(size) => format_type_with_optional_length("float", size),
+            DataType::SmallInt => "smallint".to_string(),
+            DataType::Int => "int".to_string(),
+            DataType::BigInt => "bigint".to_string(),
+            DataType::Real => "real".to_string(),
+            DataType::Double => "double".to_string(),
+            DataType::Boolean => "boolean".to_string(),
+            DataType::Date => "date".to_string(),
+            DataType::Time => "time".to_string(),
+            DataType::Timestamp => "timestamp".to_string(),
+            DataType::Interval => "interval".to_string(),
+            DataType::Regclass => "regclass".to_string(),
+            DataType::Text => "text".to_string(),
+            DataType::Bytea => "bytea".to_string(),
+            DataType::Array(ty) => format!("{}[]", ty.to_string()),
+            DataType::Custom(ty) => ty.to_string(),
         }
     }
 }
diff --git a/src/sqlast/ddl.rs b/src/ast/ddl.rs
similarity index 89%
rename from src/sqlast/ddl.rs
rename to src/ast/ddl.rs
index e39e533be..3f7c42819 100644
--- a/src/sqlast/ddl.rs
+++ b/src/ast/ddl.rs
@@ -1,6 +1,6 @@
 //! AST types specific to CREATE/ALTER variants of `SQLStatement`
 //! (commonly referred to as Data Definition Language, or DDL)
-use super::{Expr, SQLIdent, SQLObjectName, SQLType};
+use super::{DataType, Expr, Ident, ObjectName};
 
 /// An `ALTER TABLE` (`SQLStatement::SQLAlterTable`) operation
 #[derive(Debug, Clone, PartialEq, Hash)]
@@ -8,7 +8,7 @@ pub enum AlterTableOperation {
     /// `ADD <table_constraint>`
     AddConstraint(TableConstraint),
     /// TODO: implement `DROP CONSTRAINT <name>`
-    DropConstraint { name: SQLIdent },
+    DropConstraint { name: Ident },
 }
 
 impl ToString for AlterTableOperation {
@@ -26,22 +26,22 @@ impl ToString for AlterTableOperation {
 pub enum TableConstraint {
     /// `[ CONSTRAINT <name> ] { PRIMARY KEY | UNIQUE } (<columns>)`
     Unique {
-        name: Option<SQLIdent>,
-        columns: Vec<SQLIdent>,
+        name: Option<Ident>,
+        columns: Vec<Ident>,
         /// Whether this is a `PRIMARY KEY` or just a `UNIQUE` constraint
         is_primary: bool,
     },
     /// A referential integrity constraint (`[ CONSTRAINT <name> ] FOREIGN KEY (<columns>)
     /// REFERENCES <foreign_table> (<referred_columns>)`)
     ForeignKey {
-        name: Option<SQLIdent>,
-        columns: Vec<SQLIdent>,
-        foreign_table: SQLObjectName,
-        referred_columns: Vec<SQLIdent>,
+        name: Option<Ident>,
+        columns: Vec<Ident>,
+        foreign_table: ObjectName,
+        referred_columns: Vec<Ident>,
     },
     /// `[ CONSTRAINT <name> ] CHECK (<expr>)`
     Check {
-        name: Option<SQLIdent>,
+        name: Option<Ident>,
         expr: Box<Expr>,
     },
 }
@@ -82,14 +82,14 @@ impl ToString for TableConstraint {
 
 /// SQL column definition
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLColumnDef {
-    pub name: SQLIdent,
-    pub data_type: SQLType,
-    pub collation: Option<SQLObjectName>,
+pub struct ColumnDef {
+    pub name: Ident,
+    pub data_type: DataType,
+    pub collation: Option<ObjectName>,
     pub options: Vec<ColumnOptionDef>,
 }
 
-impl ToString for SQLColumnDef {
+impl ToString for ColumnDef {
     fn to_string(&self) -> String {
         format!(
             "{} {}{}",
@@ -122,7 +122,7 @@ impl ToString for SQLColumnDef {
 /// "column options," and we allow any column option to be named.
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub struct ColumnOptionDef {
-    pub name: Option<SQLIdent>,
+    pub name: Option<Ident>,
     pub option: ColumnOption,
 }
 
@@ -153,8 +153,8 @@ pub enum ColumnOption {
     /// A referential integrity constraint (`[FOREIGN KEY REFERENCES
     /// <foreign_table> (<referred_columns>)`).
     ForeignKey {
-        foreign_table: SQLObjectName,
-        referred_columns: Vec<SQLIdent>,
+        foreign_table: ObjectName,
+        referred_columns: Vec<Ident>,
     },
     // `CHECK (<expr>)`
     Check(Expr),
@@ -187,7 +187,7 @@ impl ToString for ColumnOption {
     }
 }
 
-fn format_constraint_name(name: &Option<SQLIdent>) -> String {
+fn format_constraint_name(name: &Option<Ident>) -> String {
     name.as_ref()
         .map(|name| format!("CONSTRAINT {} ", name))
         .unwrap_or_default()
diff --git a/src/sqlast/mod.rs b/src/ast/mod.rs
similarity index 76%
rename from src/sqlast/mod.rs
rename to src/ast/mod.rs
index 34efb0f4c..cac2ccffb 100644
--- a/src/sqlast/mod.rs
+++ b/src/ast/mod.rs
@@ -12,23 +12,23 @@
 
 //! SQL Abstract Syntax Tree (AST) types
 
+mod data_type;
 mod ddl;
+mod operator;
 mod query;
-mod sql_operator;
-mod sqltype;
 mod value;
 
 use std::ops::Deref;
 
+pub use self::data_type::DataType;
 pub use self::ddl::{
-    AlterTableOperation, ColumnOption, ColumnOptionDef, SQLColumnDef, TableConstraint,
+    AlterTableOperation, ColumnDef, ColumnOption, ColumnOptionDef, TableConstraint,
 };
+pub use self::operator::{BinaryOperator, UnaryOperator};
 pub use self::query::{
-    Cte, Fetch, Join, JoinConstraint, JoinOperator, SQLOrderByExpr, SQLQuery, SQLSelect,
-    SQLSelectItem, SQLSetExpr, SQLSetOperator, SQLValues, TableAlias, TableFactor, TableWithJoins,
+    Cte, Fetch, Join, JoinConstraint, JoinOperator, OrderByExpr, Query, Select, SelectItem,
+    SetExpr, SetOperator, TableAlias, TableFactor, TableWithJoins, Values,
 };
-pub use self::sql_operator::{SQLBinaryOperator, SQLUnaryOperator};
-pub use self::sqltype::SQLType;
 pub use self::value::{SQLDateTimeField, Value};
 
 /// Like `vec.join(", ")`, but for any types implementing ToString.
@@ -45,7 +45,7 @@ where
 }
 
 /// Identifier name, in the originally quoted form (e.g. `"id"`)
-pub type SQLIdent = String;
+pub type Ident = String;
 
 /// An SQL expression of any type.
 ///
@@ -55,76 +55,76 @@ pub type SQLIdent = String;
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub enum Expr {
     /// Identifier e.g. table name or column name
-    SQLIdentifier(SQLIdent),
+    Identifier(Ident),
     /// Unqualified wildcard (`*`). SQL allows this in limited contexts, such as:
     /// - right after `SELECT` (which is represented as a [SQLSelectItem::Wildcard] instead)
     /// - or as part of an aggregate function, e.g. `COUNT(*)`,
     ///
     /// ...but we currently also accept it in contexts where it doesn't make
     /// sense, such as `* + *`
-    SQLWildcard,
+    Wildcard,
     /// Qualified wildcard, e.g. `alias.*` or `schema.table.*`.
     /// (Same caveats apply to SQLQualifiedWildcard as to SQLWildcard.)
-    SQLQualifiedWildcard(Vec<SQLIdent>),
+    QualifiedWildcard(Vec<Ident>),
     /// Multi-part identifier, e.g. `table_alias.column` or `schema.table.col`
-    SQLCompoundIdentifier(Vec<SQLIdent>),
+    CompoundIdentifier(Vec<Ident>),
     /// `IS NULL` expression
-    SQLIsNull(Box<Expr>),
+    IsNull(Box<Expr>),
     /// `IS NOT NULL` expression
-    SQLIsNotNull(Box<Expr>),
+    IsNotNull(Box<Expr>),
     /// `[ NOT ] IN (val1, val2, ...)`
-    SQLInList {
+    InList {
         expr: Box<Expr>,
         list: Vec<Expr>,
         negated: bool,
     },
     /// `[ NOT ] IN (SELECT ...)`
-    SQLInSubquery {
+    InSubquery {
         expr: Box<Expr>,
-        subquery: Box<SQLQuery>,
+        subquery: Box<Query>,
         negated: bool,
     },
     /// `<expr> [ NOT ] BETWEEN <low> AND <high>`
-    SQLBetween {
+    Between {
         expr: Box<Expr>,
         negated: bool,
         low: Box<Expr>,
         high: Box<Expr>,
     },
     /// Binary operation e.g. `1 + 1` or `foo > bar`
-    SQLBinaryOp {
+    BinaryOp {
         left: Box<Expr>,
-        op: SQLBinaryOperator,
+        op: BinaryOperator,
         right: Box<Expr>,
     },
     /// Unary operation e.g. `NOT foo`
-    SQLUnaryOp {
-        op: SQLUnaryOperator,
+    UnaryOp { op: UnaryOperator, expr: Box<Expr> },
+    /// CAST an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
+    Cast {
         expr: Box<Expr>,
+        data_type: DataType,
     },
-    /// CAST an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
-    SQLCast { expr: Box<Expr>, data_type: SQLType },
-    SQLExtract {
+    Extract {
         field: SQLDateTimeField,
         expr: Box<Expr>,
     },
     /// `expr COLLATE collation`
-    SQLCollate {
+    Collate {
         expr: Box<Expr>,
-        collation: SQLObjectName,
+        collation: ObjectName,
     },
     /// Nested expression e.g. `(foo > bar)` or `(1)`
-    SQLNested(Box<Expr>),
+    Nested(Box<Expr>),
     /// SQLValue
-    SQLValue(Value),
+    Value(Value),
     /// Scalar function call e.g. `LEFT(foo, 5)`
-    SQLFunction(SQLFunction),
+    Function(Function),
     /// `CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END`
     ///
     /// Note we only recognize a complete single expression as `<condition>`,
     /// not `< 0` nor `1, 2, 3` as allowed in a `<simple when clause>` per
     /// <https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#simple-when-clause>
-    SQLCase {
+    Case {
         operand: Option<Box<Expr>>,
         conditions: Vec<Expr>,
         results: Vec<Expr>,
@@ -132,22 +132,22 @@ pub enum Expr {
     },
     /// An exists expression `EXISTS(SELECT ...)`, used in expressions like
     /// `WHERE EXISTS (SELECT ...)`.
-    SQLExists(Box<SQLQuery>),
+    Exists(Box<Query>),
     /// A parenthesized subquery `(SELECT ...)`, used in expression like
     /// `SELECT (subquery) AS x` or `WHERE (subquery) = x`
-    SQLSubquery(Box<SQLQuery>),
+    Subquery(Box<Query>),
 }
 
 impl ToString for Expr {
     fn to_string(&self) -> String {
         match self {
-            Expr::SQLIdentifier(s) => s.to_string(),
-            Expr::SQLWildcard => "*".to_string(),
-            Expr::SQLQualifiedWildcard(q) => q.join(".") + ".*",
-            Expr::SQLCompoundIdentifier(s) => s.join("."),
-            Expr::SQLIsNull(ast) => format!("{} IS NULL", ast.as_ref().to_string()),
-            Expr::SQLIsNotNull(ast) => format!("{} IS NOT NULL", ast.as_ref().to_string()),
-            Expr::SQLInList {
+            Expr::Identifier(s) => s.to_string(),
+            Expr::Wildcard => "*".to_string(),
+            Expr::QualifiedWildcard(q) => q.join(".") + ".*",
+            Expr::CompoundIdentifier(s) => s.join("."),
+            Expr::IsNull(ast) => format!("{} IS NULL", ast.as_ref().to_string()),
+            Expr::IsNotNull(ast) => format!("{} IS NOT NULL", ast.as_ref().to_string()),
+            Expr::InList {
                 expr,
                 list,
                 negated,
@@ -157,7 +157,7 @@ impl ToString for Expr {
                 if *negated { "NOT " } else { "" },
                 comma_separated_string(list)
             ),
-            Expr::SQLInSubquery {
+            Expr::InSubquery {
                 expr,
                 subquery,
                 negated,
@@ -167,7 +167,7 @@ impl ToString for Expr {
                 if *negated { "NOT " } else { "" },
                 subquery.to_string()
             ),
-            Expr::SQLBetween {
+            Expr::Between {
                 expr,
                 negated,
                 low,
@@ -179,32 +179,32 @@ impl ToString for Expr {
                 low.to_string(),
                 high.to_string()
             ),
-            Expr::SQLBinaryOp { left, op, right } => format!(
+            Expr::BinaryOp { left, op, right } => format!(
                 "{} {} {}",
                 left.as_ref().to_string(),
                 op.to_string(),
                 right.as_ref().to_string()
             ),
-            Expr::SQLUnaryOp { op, expr } => {
+            Expr::UnaryOp { op, expr } => {
                 format!("{} {}", op.to_string(), expr.as_ref().to_string())
             }
-            Expr::SQLCast { expr, data_type } => format!(
+            Expr::Cast { expr, data_type } => format!(
                 "CAST({} AS {})",
                 expr.as_ref().to_string(),
                 data_type.to_string()
             ),
-            Expr::SQLExtract { field, expr } => {
+            Expr::Extract { field, expr } => {
                 format!("EXTRACT({} FROM {})", field.to_string(), expr.to_string())
             }
-            Expr::SQLCollate { expr, collation } => format!(
+            Expr::Collate { expr, collation } => format!(
                 "{} COLLATE {}",
                 expr.as_ref().to_string(),
                 collation.to_string()
             ),
-            Expr::SQLNested(ast) => format!("({})", ast.as_ref().to_string()),
-            Expr::SQLValue(v) => v.to_string(),
-            Expr::SQLFunction(f) => f.to_string(),
-            Expr::SQLCase {
+            Expr::Nested(ast) => format!("({})", ast.as_ref().to_string()),
+            Expr::Value(v) => v.to_string(),
+            Expr::Function(f) => f.to_string(),
+            Expr::Case {
                 operand,
                 conditions,
                 results,
@@ -225,21 +225,21 @@ impl ToString for Expr {
                 }
                 s + " END"
             }
-            Expr::SQLExists(s) => format!("EXISTS ({})", s.to_string()),
-            Expr::SQLSubquery(s) => format!("({})", s.to_string()),
+            Expr::Exists(s) => format!("EXISTS ({})", s.to_string()),
+            Expr::Subquery(s) => format!("({})", s.to_string()),
         }
     }
 }
 
 /// A window specification (i.e. `OVER (PARTITION BY .. ORDER BY .. etc.)`)
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLWindowSpec {
+pub struct WindowSpec {
     pub partition_by: Vec<Expr>,
-    pub order_by: Vec<SQLOrderByExpr>,
-    pub window_frame: Option<SQLWindowFrame>,
+    pub order_by: Vec<OrderByExpr>,
+    pub window_frame: Option<WindowFrame>,
 }
 
-impl ToString for SQLWindowSpec {
+impl ToString for WindowSpec {
     fn to_string(&self) -> String {
         let mut clauses = vec![];
         if !self.partition_by.is_empty() {
@@ -277,39 +277,39 @@ impl ToString for SQLWindowSpec {
 /// Specifies the data processed by a window function, e.g.
 /// `RANGE UNBOUNDED PRECEDING` or `ROWS BETWEEN 5 PRECEDING AND CURRENT ROW`.
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLWindowFrame {
-    pub units: SQLWindowFrameUnits,
-    pub start_bound: SQLWindowFrameBound,
+pub struct WindowFrame {
+    pub units: WindowFrameUnits,
+    pub start_bound: WindowFrameBound,
     /// The right bound of the `BETWEEN .. AND` clause.
-    pub end_bound: Option<SQLWindowFrameBound>,
+    pub end_bound: Option<WindowFrameBound>,
     // TBD: EXCLUDE
 }
 
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLWindowFrameUnits {
+pub enum WindowFrameUnits {
     Rows,
     Range,
     Groups,
 }
 
-impl ToString for SQLWindowFrameUnits {
+impl ToString for WindowFrameUnits {
     fn to_string(&self) -> String {
         match self {
-            SQLWindowFrameUnits::Rows => "ROWS".to_string(),
-            SQLWindowFrameUnits::Range => "RANGE".to_string(),
-            SQLWindowFrameUnits::Groups => "GROUPS".to_string(),
+            WindowFrameUnits::Rows => "ROWS".to_string(),
+            WindowFrameUnits::Range => "RANGE".to_string(),
+            WindowFrameUnits::Groups => "GROUPS".to_string(),
         }
     }
 }
 
-impl FromStr for SQLWindowFrameUnits {
+impl FromStr for WindowFrameUnits {
     type Err = ParserError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "ROWS" => Ok(SQLWindowFrameUnits::Rows),
-            "RANGE" => Ok(SQLWindowFrameUnits::Range),
-            "GROUPS" => Ok(SQLWindowFrameUnits::Groups),
+            "ROWS" => Ok(WindowFrameUnits::Rows),
+            "RANGE" => Ok(WindowFrameUnits::Range),
+            "GROUPS" => Ok(WindowFrameUnits::Groups),
             _ => Err(ParserError::ParserError(format!(
                 "Expected ROWS, RANGE, or GROUPS, found: {}",
                 s
@@ -319,7 +319,7 @@ impl FromStr for SQLWindowFrameUnits {
 }
 
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLWindowFrameBound {
+pub enum WindowFrameBound {
     /// "CURRENT ROW"
     CurrentRow,
     /// "<N> PRECEDING" or "UNBOUNDED PRECEDING"
@@ -329,14 +329,14 @@ pub enum SQLWindowFrameBound {
     Following(Option<u64>),
 }
 
-impl ToString for SQLWindowFrameBound {
+impl ToString for WindowFrameBound {
     fn to_string(&self) -> String {
         match self {
-            SQLWindowFrameBound::CurrentRow => "CURRENT ROW".to_string(),
-            SQLWindowFrameBound::Preceding(None) => "UNBOUNDED PRECEDING".to_string(),
-            SQLWindowFrameBound::Following(None) => "UNBOUNDED FOLLOWING".to_string(),
-            SQLWindowFrameBound::Preceding(Some(n)) => format!("{} PRECEDING", n),
-            SQLWindowFrameBound::Following(Some(n)) => format!("{} FOLLOWING", n),
+            WindowFrameBound::CurrentRow => "CURRENT ROW".to_string(),
+            WindowFrameBound::Preceding(None) => "UNBOUNDED PRECEDING".to_string(),
+            WindowFrameBound::Following(None) => "UNBOUNDED FOLLOWING".to_string(),
+            WindowFrameBound::Preceding(Some(n)) => format!("{} PRECEDING", n),
+            WindowFrameBound::Following(Some(n)) => format!("{} FOLLOWING", n),
         }
     }
 }
@@ -344,91 +344,91 @@ impl ToString for SQLWindowFrameBound {
 /// A top-level statement (SELECT, INSERT, CREATE, etc.)
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLStatement {
+pub enum Statement {
     /// SELECT
-    SQLQuery(Box<SQLQuery>),
+    Query(Box<Query>),
     /// INSERT
-    SQLInsert {
+    Insert {
         /// TABLE
-        table_name: SQLObjectName,
+        table_name: ObjectName,
         /// COLUMNS
-        columns: Vec<SQLIdent>,
+        columns: Vec<Ident>,
         /// A SQL query that specifies what to insert
-        source: Box<SQLQuery>,
+        source: Box<Query>,
     },
-    SQLCopy {
+    Copy {
         /// TABLE
-        table_name: SQLObjectName,
+        table_name: ObjectName,
         /// COLUMNS
-        columns: Vec<SQLIdent>,
+        columns: Vec<Ident>,
         /// VALUES a vector of values to be copied
         values: Vec<Option<String>>,
     },
     /// UPDATE
-    SQLUpdate {
+    Update {
         /// TABLE
-        table_name: SQLObjectName,
+        table_name: ObjectName,
         /// Column assignments
-        assignments: Vec<SQLAssignment>,
+        assignments: Vec<Assignment>,
         /// WHERE
         selection: Option<Expr>,
     },
     /// DELETE
-    SQLDelete {
+    Delete {
         /// FROM
-        table_name: SQLObjectName,
+        table_name: ObjectName,
         /// WHERE
         selection: Option<Expr>,
     },
     /// CREATE VIEW
-    SQLCreateView {
+    CreateView {
         /// View name
-        name: SQLObjectName,
-        columns: Vec<SQLIdent>,
-        query: Box<SQLQuery>,
+        name: ObjectName,
+        columns: Vec<Ident>,
+        query: Box<Query>,
         materialized: bool,
-        with_options: Vec<SQLOption>,
+        with_options: Vec<SqlOption>,
     },
     /// CREATE TABLE
-    SQLCreateTable {
+    CreateTable {
         /// Table name
-        name: SQLObjectName,
+        name: ObjectName,
         /// Optional schema
-        columns: Vec<SQLColumnDef>,
+        columns: Vec<ColumnDef>,
         constraints: Vec<TableConstraint>,
-        with_options: Vec<SQLOption>,
+        with_options: Vec<SqlOption>,
         external: bool,
         file_format: Option<FileFormat>,
         location: Option<String>,
     },
     /// ALTER TABLE
-    SQLAlterTable {
+    AlterTable {
         /// Table name
-        name: SQLObjectName,
+        name: ObjectName,
         operation: AlterTableOperation,
     },
     /// DROP TABLE
-    SQLDrop {
-        object_type: SQLObjectType,
+    Drop {
+        object_type: ObjectType,
         if_exists: bool,
-        names: Vec<SQLObjectName>,
+        names: Vec<ObjectName>,
         cascade: bool,
     },
     /// `{ BEGIN [ TRANSACTION | WORK ] | START TRANSACTION } ...`
-    SQLStartTransaction { modes: Vec<TransactionMode> },
+    StartTransaction { modes: Vec<TransactionMode> },
     /// `SET TRANSACTION ...`
-    SQLSetTransaction { modes: Vec<TransactionMode> },
+    SetTransaction { modes: Vec<TransactionMode> },
     /// `COMMIT [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ]`
-    SQLCommit { chain: bool },
+    Commit { chain: bool },
     /// `ROLLBACK [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ]`
-    SQLRollback { chain: bool },
+    Rollback { chain: bool },
 }
 
-impl ToString for SQLStatement {
+impl ToString for Statement {
     fn to_string(&self) -> String {
         match self {
-            SQLStatement::SQLQuery(s) => s.to_string(),
-            SQLStatement::SQLInsert {
+            Statement::Query(s) => s.to_string(),
+            Statement::Insert {
                 table_name,
                 columns,
                 source,
@@ -440,7 +440,7 @@ impl ToString for SQLStatement {
                 s += &source.to_string();
                 s
             }
-            SQLStatement::SQLCopy {
+            Statement::Copy {
                 table_name,
                 columns,
                 values,
@@ -463,7 +463,7 @@ impl ToString for SQLStatement {
                 s += "\n\\.";
                 s
             }
-            SQLStatement::SQLUpdate {
+            Statement::Update {
                 table_name,
                 assignments,
                 selection,
@@ -478,7 +478,7 @@ impl ToString for SQLStatement {
                 }
                 s
             }
-            SQLStatement::SQLDelete {
+            Statement::Delete {
                 table_name,
                 selection,
             } => {
@@ -488,7 +488,7 @@ impl ToString for SQLStatement {
                 }
                 s
             }
-            SQLStatement::SQLCreateView {
+            Statement::CreateView {
                 name,
                 columns,
                 query,
@@ -515,7 +515,7 @@ impl ToString for SQLStatement {
                     query.to_string(),
                 )
             }
-            SQLStatement::SQLCreateTable {
+            Statement::CreateTable {
                 name,
                 columns,
                 constraints,
@@ -546,10 +546,10 @@ impl ToString for SQLStatement {
                 }
                 s
             }
-            SQLStatement::SQLAlterTable { name, operation } => {
+            Statement::AlterTable { name, operation } => {
                 format!("ALTER TABLE {} {}", name.to_string(), operation.to_string())
             }
-            SQLStatement::SQLDrop {
+            Statement::Drop {
                 object_type,
                 if_exists,
                 names,
@@ -561,7 +561,7 @@ impl ToString for SQLStatement {
                 comma_separated_string(names),
                 if *cascade { " CASCADE" } else { "" },
             ),
-            SQLStatement::SQLStartTransaction { modes } => format!(
+            Statement::StartTransaction { modes } => format!(
                 "START TRANSACTION{}",
                 if modes.is_empty() {
                     "".into()
@@ -569,7 +569,7 @@ impl ToString for SQLStatement {
                     format!(" {}", comma_separated_string(modes))
                 }
             ),
-            SQLStatement::SQLSetTransaction { modes } => format!(
+            Statement::SetTransaction { modes } => format!(
                 "SET TRANSACTION{}",
                 if modes.is_empty() {
                     "".into()
@@ -577,10 +577,10 @@ impl ToString for SQLStatement {
                     format!(" {}", comma_separated_string(modes))
                 }
             ),
-            SQLStatement::SQLCommit { chain } => {
+            Statement::Commit { chain } => {
                 format!("COMMIT{}", if *chain { " AND CHAIN" } else { "" },)
             }
-            SQLStatement::SQLRollback { chain } => {
+            Statement::Rollback { chain } => {
                 format!("ROLLBACK{}", if *chain { " AND CHAIN" } else { "" },)
             }
         }
@@ -589,9 +589,9 @@ impl ToString for SQLStatement {
 
 /// A name of a table, view, custom type, etc., possibly multi-part, i.e. db.schema.obj
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLObjectName(pub Vec<SQLIdent>);
+pub struct ObjectName(pub Vec<Ident>);
 
-impl ToString for SQLObjectName {
+impl ToString for ObjectName {
     fn to_string(&self) -> String {
         self.0.join(".")
     }
@@ -599,12 +599,12 @@ impl ToString for SQLObjectName {
 
 /// SQL assignment `foo = expr` as used in SQLUpdate
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLAssignment {
-    pub id: SQLIdent,
+pub struct Assignment {
+    pub id: Ident,
     pub value: Expr,
 }
 
-impl ToString for SQLAssignment {
+impl ToString for Assignment {
     fn to_string(&self) -> String {
         format!("{} = {}", self.id, self.value.to_string())
     }
@@ -612,15 +612,15 @@ impl ToString for SQLAssignment {
 
 /// SQL function
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLFunction {
-    pub name: SQLObjectName,
+pub struct Function {
+    pub name: ObjectName,
     pub args: Vec<Expr>,
-    pub over: Option<SQLWindowSpec>,
+    pub over: Option<WindowSpec>,
     // aggregate functions may specify eg `COUNT(DISTINCT x)`
     pub distinct: bool,
 }
 
-impl ToString for SQLFunction {
+impl ToString for Function {
     fn to_string(&self) -> String {
         let mut s = format!(
             "{}({}{})",
@@ -662,7 +662,7 @@ impl ToString for FileFormat {
     }
 }
 
-use crate::sqlparser::ParserError;
+use crate::parser::ParserError;
 use std::str::FromStr;
 impl FromStr for FileFormat {
     type Err = ParserError;
@@ -686,27 +686,27 @@ impl FromStr for FileFormat {
 }
 
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLObjectType {
+pub enum ObjectType {
     Table,
     View,
 }
 
-impl SQLObjectType {
+impl ObjectType {
     fn to_string(&self) -> String {
         match self {
-            SQLObjectType::Table => "TABLE".into(),
-            SQLObjectType::View => "VIEW".into(),
+            ObjectType::Table => "TABLE".into(),
+            ObjectType::View => "VIEW".into(),
         }
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLOption {
-    pub name: SQLIdent,
+pub struct SqlOption {
+    pub name: Ident,
     pub value: Value,
 }
 
-impl ToString for SQLOption {
+impl ToString for SqlOption {
     fn to_string(&self) -> String {
         format!("{} = {}", self.name.to_string(), self.value.to_string())
     }
diff --git a/src/ast/operator.rs b/src/ast/operator.rs
new file mode 100644
index 000000000..32626e4f1
--- /dev/null
+++ b/src/ast/operator.rs
@@ -0,0 +1,71 @@
+// 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.
+
+/// Unary operators
+#[derive(Debug, Clone, PartialEq, Hash)]
+pub enum UnaryOperator {
+    Plus,
+    Minus,
+    Not,
+}
+
+impl ToString for UnaryOperator {
+    fn to_string(&self) -> String {
+        match self {
+            UnaryOperator::Plus => "+".to_string(),
+            UnaryOperator::Minus => "-".to_string(),
+            UnaryOperator::Not => "NOT".to_string(),
+        }
+    }
+}
+
+/// Binary operators
+#[derive(Debug, Clone, PartialEq, Hash)]
+pub enum BinaryOperator {
+    Plus,
+    Minus,
+    Multiply,
+    Divide,
+    Modulus,
+    Gt,
+    Lt,
+    GtEq,
+    LtEq,
+    Eq,
+    NotEq,
+    And,
+    Or,
+    Like,
+    NotLike,
+}
+
+impl ToString for BinaryOperator {
+    fn to_string(&self) -> String {
+        match self {
+            BinaryOperator::Plus => "+".to_string(),
+            BinaryOperator::Minus => "-".to_string(),
+            BinaryOperator::Multiply => "*".to_string(),
+            BinaryOperator::Divide => "/".to_string(),
+            BinaryOperator::Modulus => "%".to_string(),
+            BinaryOperator::Gt => ">".to_string(),
+            BinaryOperator::Lt => "<".to_string(),
+            BinaryOperator::GtEq => ">=".to_string(),
+            BinaryOperator::LtEq => "<=".to_string(),
+            BinaryOperator::Eq => "=".to_string(),
+            BinaryOperator::NotEq => "<>".to_string(),
+            BinaryOperator::And => "AND".to_string(),
+            BinaryOperator::Or => "OR".to_string(),
+            BinaryOperator::Like => "LIKE".to_string(),
+            BinaryOperator::NotLike => "NOT LIKE".to_string(),
+        }
+    }
+}
diff --git a/src/sqlast/query.rs b/src/ast/query.rs
similarity index 87%
rename from src/sqlast/query.rs
rename to src/ast/query.rs
index e8d0cd08a..2d09d821c 100644
--- a/src/sqlast/query.rs
+++ b/src/ast/query.rs
@@ -15,13 +15,13 @@ use super::*;
 /// The most complete variant of a `SELECT` query expression, optionally
 /// including `WITH`, `UNION` / other set operations, and `ORDER BY`.
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLQuery {
+pub struct Query {
     /// WITH (common table expressions, or CTEs)
     pub ctes: Vec<Cte>,
     /// SELECT or UNION / EXCEPT / INTECEPT
-    pub body: SQLSetExpr,
+    pub body: SetExpr,
     /// ORDER BY
-    pub order_by: Vec<SQLOrderByExpr>,
+    pub order_by: Vec<OrderByExpr>,
     /// `LIMIT { <N> | ALL }`
     pub limit: Option<Expr>,
     /// `OFFSET <N> { ROW | ROWS }`
@@ -30,7 +30,7 @@ pub struct SQLQuery {
     pub fetch: Option<Fetch>,
 }
 
-impl ToString for SQLQuery {
+impl ToString for Query {
     fn to_string(&self) -> String {
         let mut s = String::new();
         if !self.ctes.is_empty() {
@@ -57,30 +57,30 @@ impl ToString for SQLQuery {
 /// A node in a tree, representing a "query body" expression, roughly:
 /// `SELECT ... [ {UNION|EXCEPT|INTERSECT} SELECT ...]`
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLSetExpr {
+pub enum SetExpr {
     /// Restricted SELECT .. FROM .. HAVING (no ORDER BY or set operations)
-    Select(Box<SQLSelect>),
+    Select(Box<Select>),
     /// Parenthesized SELECT subquery, which may include more set operations
     /// in its body and an optional ORDER BY / LIMIT.
-    Query(Box<SQLQuery>),
+    Query(Box<Query>),
     /// UNION/EXCEPT/INTERSECT of two queries
     SetOperation {
-        op: SQLSetOperator,
+        op: SetOperator,
         all: bool,
-        left: Box<SQLSetExpr>,
-        right: Box<SQLSetExpr>,
+        left: Box<SetExpr>,
+        right: Box<SetExpr>,
     },
-    Values(SQLValues),
+    Values(Values),
     // TODO: ANSI SQL supports `TABLE` here.
 }
 
-impl ToString for SQLSetExpr {
+impl ToString for SetExpr {
     fn to_string(&self) -> String {
         match self {
-            SQLSetExpr::Select(s) => s.to_string(),
-            SQLSetExpr::Query(q) => format!("({})", q.to_string()),
-            SQLSetExpr::Values(v) => v.to_string(),
-            SQLSetExpr::SetOperation {
+            SetExpr::Select(s) => s.to_string(),
+            SetExpr::Query(q) => format!("({})", q.to_string()),
+            SetExpr::Values(v) => v.to_string(),
+            SetExpr::SetOperation {
                 left,
                 right,
                 op,
@@ -100,18 +100,18 @@ impl ToString for SQLSetExpr {
 }
 
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLSetOperator {
+pub enum SetOperator {
     Union,
     Except,
     Intersect,
 }
 
-impl ToString for SQLSetOperator {
+impl ToString for SetOperator {
     fn to_string(&self) -> String {
         match self {
-            SQLSetOperator::Union => "UNION".to_string(),
-            SQLSetOperator::Except => "EXCEPT".to_string(),
-            SQLSetOperator::Intersect => "INTERSECT".to_string(),
+            SetOperator::Union => "UNION".to_string(),
+            SetOperator::Except => "EXCEPT".to_string(),
+            SetOperator::Intersect => "INTERSECT".to_string(),
         }
     }
 }
@@ -120,10 +120,10 @@ impl ToString for SQLSetOperator {
 /// appear either as the only body item of an `SQLQuery`, or as an operand
 /// to a set operation like `UNION`.
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLSelect {
+pub struct Select {
     pub distinct: bool,
     /// projection expressions
-    pub projection: Vec<SQLSelectItem>,
+    pub projection: Vec<SelectItem>,
     /// FROM
     pub from: Vec<TableWithJoins>,
     /// WHERE
@@ -134,7 +134,7 @@ pub struct SQLSelect {
     pub having: Option<Expr>,
 }
 
-impl ToString for SQLSelect {
+impl ToString for Select {
     fn to_string(&self) -> String {
         let mut s = format!(
             "SELECT{} {}",
@@ -164,7 +164,7 @@ impl ToString for SQLSelect {
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub struct Cte {
     pub alias: TableAlias,
-    pub query: SQLQuery,
+    pub query: Query,
 }
 
 impl ToString for Cte {
@@ -175,26 +175,26 @@ impl ToString for Cte {
 
 /// One item of the comma-separated list following `SELECT`
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLSelectItem {
+pub enum SelectItem {
     /// Any expression, not followed by `[ AS ] alias`
     UnnamedExpr(Expr),
     /// An expression, followed by `[ AS ] alias`
-    ExprWithAlias { expr: Expr, alias: SQLIdent },
+    ExprWithAlias { expr: Expr, alias: Ident },
     /// `alias.*` or even `schema.table.*`
-    QualifiedWildcard(SQLObjectName),
+    QualifiedWildcard(ObjectName),
     /// An unqualified `*`
     Wildcard,
 }
 
-impl ToString for SQLSelectItem {
+impl ToString for SelectItem {
     fn to_string(&self) -> String {
         match &self {
-            SQLSelectItem::UnnamedExpr(expr) => expr.to_string(),
-            SQLSelectItem::ExprWithAlias { expr, alias } => {
+            SelectItem::UnnamedExpr(expr) => expr.to_string(),
+            SelectItem::ExprWithAlias { expr, alias } => {
                 format!("{} AS {}", expr.to_string(), alias)
             }
-            SQLSelectItem::QualifiedWildcard(prefix) => format!("{}.*", prefix.to_string()),
-            SQLSelectItem::Wildcard => "*".to_string(),
+            SelectItem::QualifiedWildcard(prefix) => format!("{}.*", prefix.to_string()),
+            SelectItem::Wildcard => "*".to_string(),
         }
     }
 }
@@ -219,7 +219,7 @@ impl ToString for TableWithJoins {
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub enum TableFactor {
     Table {
-        name: SQLObjectName,
+        name: ObjectName,
         alias: Option<TableAlias>,
         /// Arguments of a table-valued function, as supported by Postgres
         /// and MSSQL. Note that deprecated MSSQL `FROM foo (NOLOCK)` syntax
@@ -230,7 +230,7 @@ pub enum TableFactor {
     },
     Derived {
         lateral: bool,
-        subquery: Box<SQLQuery>,
+        subquery: Box<Query>,
         alias: Option<TableAlias>,
     },
     /// Represents a parenthesized join expression, such as
@@ -285,8 +285,8 @@ impl ToString for TableFactor {
 
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub struct TableAlias {
-    pub name: SQLIdent,
-    pub columns: Vec<SQLIdent>,
+    pub name: Ident,
+    pub columns: Vec<Ident>,
 }
 
 impl ToString for TableAlias {
@@ -368,18 +368,18 @@ pub enum JoinOperator {
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub enum JoinConstraint {
     On(Expr),
-    Using(Vec<SQLIdent>),
+    Using(Vec<Ident>),
     Natural,
 }
 
 /// SQL ORDER BY expression
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLOrderByExpr {
+pub struct OrderByExpr {
     pub expr: Expr,
     pub asc: Option<bool>,
 }
 
-impl ToString for SQLOrderByExpr {
+impl ToString for OrderByExpr {
     fn to_string(&self) -> String {
         match self.asc {
             Some(true) => format!("{} ASC", self.expr.to_string()),
@@ -414,9 +414,9 @@ impl ToString for Fetch {
 }
 
 #[derive(Debug, Clone, PartialEq, Hash)]
-pub struct SQLValues(pub Vec<Vec<Expr>>);
+pub struct Values(pub Vec<Vec<Expr>>);
 
-impl ToString for SQLValues {
+impl ToString for Values {
     fn to_string(&self) -> String {
         let rows = self
             .0
diff --git a/src/sqlast/value.rs b/src/ast/value.rs
similarity index 100%
rename from src/sqlast/value.rs
rename to src/ast/value.rs
diff --git a/src/dialect/ansi_sql.rs b/src/dialect/ansi.rs
similarity index 93%
rename from src/dialect/ansi_sql.rs
rename to src/dialect/ansi.rs
index f537848b5..ca01fb751 100644
--- a/src/dialect/ansi_sql.rs
+++ b/src/dialect/ansi.rs
@@ -13,9 +13,9 @@
 use crate::dialect::Dialect;
 
 #[derive(Debug)]
-pub struct AnsiSqlDialect {}
+pub struct AnsiDialect {}
 
-impl Dialect for AnsiSqlDialect {
+impl Dialect for AnsiDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
         (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
     }
diff --git a/src/dialect/generic_sql.rs b/src/dialect/generic.rs
similarity index 93%
rename from src/dialect/generic_sql.rs
rename to src/dialect/generic.rs
index d6d7893a5..50054069e 100644
--- a/src/dialect/generic_sql.rs
+++ b/src/dialect/generic.rs
@@ -13,9 +13,9 @@
 use crate::dialect::Dialect;
 
 #[derive(Debug)]
-pub struct GenericSqlDialect {}
+pub struct GenericDialect {}
 
-impl Dialect for GenericSqlDialect {
+impl Dialect for GenericDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
         (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch == '#' || ch == '@'
     }
diff --git a/src/dialect/mod.rs b/src/dialect/mod.rs
index 83b93833b..d7b7f6746 100644
--- a/src/dialect/mod.rs
+++ b/src/dialect/mod.rs
@@ -10,16 +10,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod ansi_sql;
-mod generic_sql;
+mod ansi;
+mod generic;
 pub mod keywords;
 mod mssql;
 mod postgresql;
 
 use std::fmt::Debug;
 
-pub use self::ansi_sql::AnsiSqlDialect;
-pub use self::generic_sql::GenericSqlDialect;
+pub use self::ansi::AnsiDialect;
+pub use self::generic::GenericDialect;
 pub use self::mssql::MsSqlDialect;
 pub use self::postgresql::PostgreSqlDialect;
 
diff --git a/src/lib.rs b/src/lib.rs
index cd2331525..a6b0423ad 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,10 +18,10 @@
 //! Syntax Tree (AST).
 //!
 //! ```
-//! use sqlparser::dialect::GenericSqlDialect;
-//! use sqlparser::sqlparser::Parser;
+//! use sqlparser::dialect::GenericDialect;
+//! use sqlparser::parser::Parser;
 //!
-//! let dialect = GenericSqlDialect {}; // or AnsiSqlDialect
+//! let dialect = GenericDialect {}; // or AnsiSqlDialect
 //!
 //! let sql = "SELECT a, b, 123, myfunc(b) \
 //!            FROM table_1 \
@@ -34,10 +34,10 @@
 //! ```
 #![warn(clippy::all)]
 
+pub mod ast;
 pub mod dialect;
-pub mod sqlast;
-pub mod sqlparser;
-pub mod sqltokenizer;
+pub mod parser;
+pub mod tokenizer;
 
 #[doc(hidden)]
 // This is required to make utilities accessible by both the crate-internal
diff --git a/src/sqlparser.rs b/src/parser.rs
similarity index 85%
rename from src/sqlparser.rs
rename to src/parser.rs
index d02c6b717..4f3f0c5ab 100644
--- a/src/sqlparser.rs
+++ b/src/parser.rs
@@ -14,10 +14,10 @@
 
 use log::debug;
 
+use super::ast::*;
 use super::dialect::keywords;
 use super::dialect::Dialect;
-use super::sqlast::*;
-use super::sqltokenizer::*;
+use super::tokenizer::*;
 use std::error::Error;
 
 #[derive(Debug, Clone, PartialEq)]
@@ -81,7 +81,7 @@ impl Parser {
     }
 
     /// Parse a SQL statement and produce an Abstract Syntax Tree (AST)
-    pub fn parse_sql(dialect: &dyn Dialect, sql: String) -> Result<Vec<SQLStatement>, ParserError> {
+    pub fn parse_sql(dialect: &dyn Dialect, sql: String) -> Result<Vec<Statement>, ParserError> {
         let mut tokenizer = Tokenizer::new(dialect, &sql);
         let tokens = tokenizer.tokenize()?;
         let mut parser = Parser::new(tokens);
@@ -109,13 +109,13 @@ impl Parser {
 
     /// Parse a single top-level statement (such as SELECT, INSERT, CREATE, etc.),
     /// stopping before the statement separator, if any.
-    pub fn parse_statement(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_statement(&mut self) -> Result<Statement, ParserError> {
         match self.next_token() {
             Some(t) => match t {
-                Token::SQLWord(ref w) if w.keyword != "" => match w.keyword.as_ref() {
+                Token::Word(ref w) if w.keyword != "" => match w.keyword.as_ref() {
                     "SELECT" | "WITH" | "VALUES" => {
                         self.prev_token();
-                        Ok(SQLStatement::SQLQuery(Box::new(self.parse_query()?)))
+                        Ok(Statement::Query(Box::new(self.parse_query()?)))
                     }
                     "CREATE" => Ok(self.parse_create()?),
                     "DROP" => Ok(self.parse_drop()?),
@@ -139,7 +139,7 @@ impl Parser {
                 },
                 Token::LParen => {
                     self.prev_token();
-                    Ok(SQLStatement::SQLQuery(Box::new(self.parse_query()?)))
+                    Ok(Statement::Query(Box::new(self.parse_query()?)))
                 }
                 unexpected => self.expected(
                     "a keyword at the beginning of a statement",
@@ -178,34 +178,32 @@ impl Parser {
             .next_token()
             .ok_or_else(|| ParserError::ParserError("Unexpected EOF".to_string()))?;
         let expr = match tok {
-            Token::SQLWord(w) => match w.keyword.as_ref() {
+            Token::Word(w) => match w.keyword.as_ref() {
                 "TRUE" | "FALSE" | "NULL" => {
                     self.prev_token();
-                    self.parse_sql_value()
+                    Ok(Expr::Value(self.parse_value()?))
                 }
                 "CASE" => self.parse_case_expr(),
                 "CAST" => self.parse_cast_expr(),
-                "DATE" => Ok(Expr::SQLValue(Value::Date(self.parse_literal_string()?))),
+                "DATE" => Ok(Expr::Value(Value::Date(self.parse_literal_string()?))),
                 "EXISTS" => self.parse_exists_expr(),
                 "EXTRACT" => self.parse_extract_expr(),
                 "INTERVAL" => self.parse_literal_interval(),
-                "NOT" => Ok(Expr::SQLUnaryOp {
-                    op: SQLUnaryOperator::Not,
+                "NOT" => Ok(Expr::UnaryOp {
+                    op: UnaryOperator::Not,
                     expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
                 }),
-                "TIME" => Ok(Expr::SQLValue(Value::Time(self.parse_literal_string()?))),
-                "TIMESTAMP" => Ok(Expr::SQLValue(Value::Timestamp(
-                    self.parse_literal_string()?,
-                ))),
+                "TIME" => Ok(Expr::Value(Value::Time(self.parse_literal_string()?))),
+                "TIMESTAMP" => Ok(Expr::Value(Value::Timestamp(self.parse_literal_string()?))),
                 // Here `w` is a word, check if it's a part of a multi-part
                 // identifier, a function call, or a simple identifier:
                 _ => match self.peek_token() {
                     Some(Token::LParen) | Some(Token::Period) => {
-                        let mut id_parts: Vec<SQLIdent> = vec![w.as_sql_ident()];
+                        let mut id_parts: Vec<Ident> = vec![w.as_ident()];
                         let mut ends_with_wildcard = false;
                         while self.consume_token(&Token::Period) {
                             match self.next_token() {
-                                Some(Token::SQLWord(w)) => id_parts.push(w.as_sql_ident()),
+                                Some(Token::Word(w)) => id_parts.push(w.as_ident()),
                                 Some(Token::Mult) => {
                                     ends_with_wildcard = true;
                                     break;
@@ -217,25 +215,25 @@ impl Parser {
                             }
                         }
                         if ends_with_wildcard {
-                            Ok(Expr::SQLQualifiedWildcard(id_parts))
+                            Ok(Expr::QualifiedWildcard(id_parts))
                         } else if self.consume_token(&Token::LParen) {
                             self.prev_token();
-                            self.parse_function(SQLObjectName(id_parts))
+                            self.parse_function(ObjectName(id_parts))
                         } else {
-                            Ok(Expr::SQLCompoundIdentifier(id_parts))
+                            Ok(Expr::CompoundIdentifier(id_parts))
                         }
                     }
-                    _ => Ok(Expr::SQLIdentifier(w.as_sql_ident())),
+                    _ => Ok(Expr::Identifier(w.as_ident())),
                 },
             }, // End of Token::SQLWord
-            Token::Mult => Ok(Expr::SQLWildcard),
+            Token::Mult => Ok(Expr::Wildcard),
             tok @ Token::Minus | tok @ Token::Plus => {
                 let op = if tok == Token::Plus {
-                    SQLUnaryOperator::Plus
+                    UnaryOperator::Plus
                 } else {
-                    SQLUnaryOperator::Minus
+                    UnaryOperator::Minus
                 };
-                Ok(Expr::SQLUnaryOp {
+                Ok(Expr::UnaryOp {
                     op,
                     expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),
                 })
@@ -245,14 +243,14 @@ impl Parser {
             | Token::NationalStringLiteral(_)
             | Token::HexStringLiteral(_) => {
                 self.prev_token();
-                self.parse_sql_value()
+                Ok(Expr::Value(self.parse_value()?))
             }
             Token::LParen => {
                 let expr = if self.parse_keyword("SELECT") || self.parse_keyword("WITH") {
                     self.prev_token();
-                    Expr::SQLSubquery(Box::new(self.parse_query()?))
+                    Expr::Subquery(Box::new(self.parse_query()?))
                 } else {
-                    Expr::SQLNested(Box::new(self.parse_expr()?))
+                    Expr::Nested(Box::new(self.parse_expr()?))
                 };
                 self.expect_token(&Token::RParen)?;
                 Ok(expr)
@@ -261,7 +259,7 @@ impl Parser {
         }?;
 
         if self.parse_keyword("COLLATE") {
-            Ok(Expr::SQLCollate {
+            Ok(Expr::Collate {
                 expr: Box::new(expr),
                 collation: self.parse_object_name()?,
             })
@@ -270,7 +268,7 @@ impl Parser {
         }
     }
 
-    pub fn parse_function(&mut self, name: SQLObjectName) -> Result<Expr, ParserError> {
+    pub fn parse_function(&mut self, name: ObjectName) -> Result<Expr, ParserError> {
         self.expect_token(&Token::LParen)?;
         let all = self.parse_keyword("ALL");
         let distinct = self.parse_keyword("DISTINCT");
@@ -297,7 +295,7 @@ impl Parser {
             };
             let window_frame = self.parse_window_frame()?;
 
-            Some(SQLWindowSpec {
+            Some(WindowSpec {
                 partition_by,
                 order_by,
                 window_frame,
@@ -306,7 +304,7 @@ impl Parser {
             None
         };
 
-        Ok(Expr::SQLFunction(SQLFunction {
+        Ok(Expr::Function(Function {
             name,
             args,
             over,
@@ -314,16 +312,16 @@ impl Parser {
         }))
     }
 
-    pub fn parse_window_frame(&mut self) -> Result<Option<SQLWindowFrame>, ParserError> {
+    pub fn parse_window_frame(&mut self) -> Result<Option<WindowFrame>, ParserError> {
         let window_frame = match self.peek_token() {
-            Some(Token::SQLWord(w)) => {
-                let units = w.keyword.parse::<SQLWindowFrameUnits>()?;
+            Some(Token::Word(w)) => {
+                let units = w.keyword.parse::<WindowFrameUnits>()?;
                 self.next_token();
                 if self.parse_keyword("BETWEEN") {
                     let start_bound = self.parse_window_frame_bound()?;
                     self.expect_keyword("AND")?;
                     let end_bound = Some(self.parse_window_frame_bound()?);
-                    Some(SQLWindowFrame {
+                    Some(WindowFrame {
                         units,
                         start_bound,
                         end_bound,
@@ -331,7 +329,7 @@ impl Parser {
                 } else {
                     let start_bound = self.parse_window_frame_bound()?;
                     let end_bound = None;
-                    Some(SQLWindowFrame {
+                    Some(WindowFrame {
                         units,
                         start_bound,
                         end_bound,
@@ -346,9 +344,9 @@ impl Parser {
     }
 
     /// "CURRENT ROW" | ( (<positive number> | "UNBOUNDED") ("PRECEDING" | FOLLOWING) )
-    pub fn parse_window_frame_bound(&mut self) -> Result<SQLWindowFrameBound, ParserError> {
+    pub fn parse_window_frame_bound(&mut self) -> Result<WindowFrameBound, ParserError> {
         if self.parse_keywords(vec!["CURRENT", "ROW"]) {
-            Ok(SQLWindowFrameBound::CurrentRow)
+            Ok(WindowFrameBound::CurrentRow)
         } else {
             let rows = if self.parse_keyword("UNBOUNDED") {
                 None
@@ -357,9 +355,9 @@ impl Parser {
                 Some(rows)
             };
             if self.parse_keyword("PRECEDING") {
-                Ok(SQLWindowFrameBound::Preceding(rows))
+                Ok(WindowFrameBound::Preceding(rows))
             } else if self.parse_keyword("FOLLOWING") {
-                Ok(SQLWindowFrameBound::Following(rows))
+                Ok(WindowFrameBound::Following(rows))
             } else {
                 self.expected("PRECEDING or FOLLOWING", self.peek_token())
             }
@@ -388,7 +386,7 @@ impl Parser {
             None
         };
         self.expect_keyword("END")?;
-        Ok(Expr::SQLCase {
+        Ok(Expr::Case {
             operand,
             conditions,
             results,
@@ -403,7 +401,7 @@ impl Parser {
         self.expect_keyword("AS")?;
         let data_type = self.parse_data_type()?;
         self.expect_token(&Token::RParen)?;
-        Ok(Expr::SQLCast {
+        Ok(Expr::Cast {
             expr: Box::new(expr),
             data_type,
         })
@@ -412,7 +410,7 @@ impl Parser {
     /// Parse a SQL EXISTS expression e.g. `WHERE EXISTS(SELECT ...)`.
     pub fn parse_exists_expr(&mut self) -> Result<Expr, ParserError> {
         self.expect_token(&Token::LParen)?;
-        let exists_node = Expr::SQLExists(Box::new(self.parse_query()?));
+        let exists_node = Expr::Exists(Box::new(self.parse_query()?));
         self.expect_token(&Token::RParen)?;
         Ok(exists_node)
     }
@@ -423,7 +421,7 @@ impl Parser {
         self.expect_keyword("FROM")?;
         let expr = self.parse_expr()?;
         self.expect_token(&Token::RParen)?;
-        Ok(Expr::SQLExtract {
+        Ok(Expr::Extract {
             field,
             expr: Box::new(expr),
         })
@@ -435,7 +433,7 @@ impl Parser {
     // be split in two.
     pub fn parse_date_time_field(&mut self) -> Result<SQLDateTimeField, ParserError> {
         let tok = self.next_token();
-        if let Some(Token::SQLWord(ref k)) = tok {
+        if let Some(Token::Word(ref k)) = tok {
             match k.keyword.as_ref() {
                 "YEAR" => Ok(SQLDateTimeField::Year),
                 "MONTH" => Ok(SQLDateTimeField::Month),
@@ -504,7 +502,7 @@ impl Parser {
                 }
             };
 
-        Ok(Expr::SQLValue(Value::Interval {
+        Ok(Expr::Value(Value::Interval {
             value,
             leading_field,
             leading_precision,
@@ -519,24 +517,24 @@ impl Parser {
         let tok = self.next_token().unwrap(); // safe as EOF's precedence is the lowest
 
         let regular_binary_operator = match tok {
-            Token::Eq => Some(SQLBinaryOperator::Eq),
-            Token::Neq => Some(SQLBinaryOperator::NotEq),
-            Token::Gt => Some(SQLBinaryOperator::Gt),
-            Token::GtEq => Some(SQLBinaryOperator::GtEq),
-            Token::Lt => Some(SQLBinaryOperator::Lt),
-            Token::LtEq => Some(SQLBinaryOperator::LtEq),
-            Token::Plus => Some(SQLBinaryOperator::Plus),
-            Token::Minus => Some(SQLBinaryOperator::Minus),
-            Token::Mult => Some(SQLBinaryOperator::Multiply),
-            Token::Mod => Some(SQLBinaryOperator::Modulus),
-            Token::Div => Some(SQLBinaryOperator::Divide),
-            Token::SQLWord(ref k) => match k.keyword.as_ref() {
-                "AND" => Some(SQLBinaryOperator::And),
-                "OR" => Some(SQLBinaryOperator::Or),
-                "LIKE" => Some(SQLBinaryOperator::Like),
+            Token::Eq => Some(BinaryOperator::Eq),
+            Token::Neq => Some(BinaryOperator::NotEq),
+            Token::Gt => Some(BinaryOperator::Gt),
+            Token::GtEq => Some(BinaryOperator::GtEq),
+            Token::Lt => Some(BinaryOperator::Lt),
+            Token::LtEq => Some(BinaryOperator::LtEq),
+            Token::Plus => Some(BinaryOperator::Plus),
+            Token::Minus => Some(BinaryOperator::Minus),
+            Token::Mult => Some(BinaryOperator::Multiply),
+            Token::Mod => Some(BinaryOperator::Modulus),
+            Token::Div => Some(BinaryOperator::Divide),
+            Token::Word(ref k) => match k.keyword.as_ref() {
+                "AND" => Some(BinaryOperator::And),
+                "OR" => Some(BinaryOperator::Or),
+                "LIKE" => Some(BinaryOperator::Like),
                 "NOT" => {
                     if self.parse_keyword("LIKE") {
-                        Some(SQLBinaryOperator::NotLike)
+                        Some(BinaryOperator::NotLike)
                     } else {
                         None
                     }
@@ -547,18 +545,18 @@ impl Parser {
         };
 
         if let Some(op) = regular_binary_operator {
-            Ok(Expr::SQLBinaryOp {
+            Ok(Expr::BinaryOp {
                 left: Box::new(expr),
                 op,
                 right: Box::new(self.parse_subexpr(precedence)?),
             })
-        } else if let Token::SQLWord(ref k) = tok {
+        } else if let Token::Word(ref k) = tok {
             match k.keyword.as_ref() {
                 "IS" => {
                     if self.parse_keyword("NULL") {
-                        Ok(Expr::SQLIsNull(Box::new(expr)))
+                        Ok(Expr::IsNull(Box::new(expr)))
                     } else if self.parse_keywords(vec!["NOT", "NULL"]) {
-                        Ok(Expr::SQLIsNotNull(Box::new(expr)))
+                        Ok(Expr::IsNotNull(Box::new(expr)))
                     } else {
                         self.expected("NULL or NOT NULL after IS", self.peek_token())
                     }
@@ -590,13 +588,13 @@ impl Parser {
         self.expect_token(&Token::LParen)?;
         let in_op = if self.parse_keyword("SELECT") || self.parse_keyword("WITH") {
             self.prev_token();
-            Expr::SQLInSubquery {
+            Expr::InSubquery {
                 expr: Box::new(expr),
                 subquery: Box::new(self.parse_query()?),
                 negated,
             }
         } else {
-            Expr::SQLInList {
+            Expr::InList {
                 expr: Box::new(expr),
                 list: self.parse_expr_list()?,
                 negated,
@@ -613,7 +611,7 @@ impl Parser {
         let low = self.parse_subexpr(Self::BETWEEN_PREC)?;
         self.expect_keyword("AND")?;
         let high = self.parse_subexpr(Self::BETWEEN_PREC)?;
-        Ok(Expr::SQLBetween {
+        Ok(Expr::Between {
             expr: Box::new(expr),
             negated,
             low: Box::new(low),
@@ -623,7 +621,7 @@ impl Parser {
 
     /// Parse a postgresql casting style which is in the form of `expr::datatype`
     pub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError> {
-        Ok(Expr::SQLCast {
+        Ok(Expr::Cast {
             expr: Box::new(expr),
             data_type: self.parse_data_type()?,
         })
@@ -639,23 +637,23 @@ impl Parser {
             debug!("get_next_precedence() {:?}", token);
 
             match &token {
-                Token::SQLWord(k) if k.keyword == "OR" => Ok(5),
-                Token::SQLWord(k) if k.keyword == "AND" => Ok(10),
-                Token::SQLWord(k) if k.keyword == "NOT" => match &self.peek_nth_token(1) {
+                Token::Word(k) if k.keyword == "OR" => Ok(5),
+                Token::Word(k) if k.keyword == "AND" => Ok(10),
+                Token::Word(k) if k.keyword == "NOT" => match &self.peek_nth_token(1) {
                     // The precedence of NOT varies depending on keyword that
                     // follows it. If it is followed by IN, BETWEEN, or LIKE,
                     // it takes on the precedence of those tokens. Otherwise it
                     // is not an infix operator, and therefore has zero
                     // precedence.
-                    Some(Token::SQLWord(k)) if k.keyword == "IN" => Ok(Self::BETWEEN_PREC),
-                    Some(Token::SQLWord(k)) if k.keyword == "BETWEEN" => Ok(Self::BETWEEN_PREC),
-                    Some(Token::SQLWord(k)) if k.keyword == "LIKE" => Ok(Self::BETWEEN_PREC),
+                    Some(Token::Word(k)) if k.keyword == "IN" => Ok(Self::BETWEEN_PREC),
+                    Some(Token::Word(k)) if k.keyword == "BETWEEN" => Ok(Self::BETWEEN_PREC),
+                    Some(Token::Word(k)) if k.keyword == "LIKE" => Ok(Self::BETWEEN_PREC),
                     _ => Ok(0),
                 },
-                Token::SQLWord(k) if k.keyword == "IS" => Ok(17),
-                Token::SQLWord(k) if k.keyword == "IN" => Ok(Self::BETWEEN_PREC),
-                Token::SQLWord(k) if k.keyword == "BETWEEN" => Ok(Self::BETWEEN_PREC),
-                Token::SQLWord(k) if k.keyword == "LIKE" => Ok(Self::BETWEEN_PREC),
+                Token::Word(k) if k.keyword == "IS" => Ok(17),
+                Token::Word(k) if k.keyword == "IN" => Ok(Self::BETWEEN_PREC),
+                Token::Word(k) if k.keyword == "BETWEEN" => Ok(Self::BETWEEN_PREC),
+                Token::Word(k) if k.keyword == "LIKE" => Ok(Self::BETWEEN_PREC),
                 Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq => {
                     Ok(20)
                 }
@@ -743,7 +741,7 @@ impl Parser {
         // the string actually represents a known keyword...
         assert!(keywords::ALL_KEYWORDS.contains(&expected));
         match self.peek_token() {
-            Some(Token::SQLWord(ref k)) if expected.eq_ignore_ascii_case(&k.keyword) => {
+            Some(Token::Word(ref k)) if expected.eq_ignore_ascii_case(&k.keyword) => {
                 self.next_token();
                 true
             }
@@ -773,7 +771,7 @@ impl Parser {
             assert!(keywords::ALL_KEYWORDS.contains(keyword));
         }
         match self.peek_token() {
-            Some(Token::SQLWord(ref k)) => keywords
+            Some(Token::Word(ref k)) => keywords
                 .iter()
                 .find(|keyword| keyword.eq_ignore_ascii_case(&k.keyword))
                 .map(|keyword| {
@@ -831,7 +829,7 @@ impl Parser {
     }
 
     /// Parse a SQL CREATE statement
-    pub fn parse_create(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_create(&mut self) -> Result<Statement, ParserError> {
         if self.parse_keyword("TABLE") {
             self.parse_create_table()
         } else if self.parse_keyword("MATERIALIZED") || self.parse_keyword("VIEW") {
@@ -844,7 +842,7 @@ impl Parser {
         }
     }
 
-    pub fn parse_create_external_table(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_create_external_table(&mut self) -> Result<Statement, ParserError> {
         self.expect_keyword("TABLE")?;
         let table_name = self.parse_object_name()?;
         let (columns, constraints) = self.parse_columns()?;
@@ -855,7 +853,7 @@ impl Parser {
         self.expect_keyword("LOCATION")?;
         let location = self.parse_literal_string()?;
 
-        Ok(SQLStatement::SQLCreateTable {
+        Ok(Statement::CreateTable {
             name: table_name,
             columns,
             constraints,
@@ -866,7 +864,7 @@ impl Parser {
         })
     }
 
-    pub fn parse_create_view(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_create_view(&mut self) -> Result<Statement, ParserError> {
         let materialized = self.parse_keyword("MATERIALIZED");
         self.expect_keyword("VIEW")?;
         // Many dialects support `OR REPLACE` | `OR ALTER` right after `CREATE`, but we don't (yet).
@@ -881,7 +879,7 @@ impl Parser {
         self.expect_keyword("AS")?;
         let query = Box::new(self.parse_query()?);
         // Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here.
-        Ok(SQLStatement::SQLCreateView {
+        Ok(Statement::CreateView {
             name,
             columns,
             query,
@@ -890,11 +888,11 @@ impl Parser {
         })
     }
 
-    pub fn parse_drop(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_drop(&mut self) -> Result<Statement, ParserError> {
         let object_type = if self.parse_keyword("TABLE") {
-            SQLObjectType::Table
+            ObjectType::Table
         } else if self.parse_keyword("VIEW") {
-            SQLObjectType::View
+            ObjectType::View
         } else {
             return self.expected("TABLE or VIEW after DROP", self.peek_token());
         };
@@ -911,7 +909,7 @@ impl Parser {
         if cascade && restrict {
             return parser_err!("Cannot specify both CASCADE and RESTRICT in DROP");
         }
-        Ok(SQLStatement::SQLDrop {
+        Ok(Statement::Drop {
             object_type,
             if_exists,
             names,
@@ -919,7 +917,7 @@ impl Parser {
         })
     }
 
-    pub fn parse_create_table(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_create_table(&mut self) -> Result<Statement, ParserError> {
         let table_name = self.parse_object_name()?;
         // parse optional column list (schema)
         let (columns, constraints) = self.parse_columns()?;
@@ -930,7 +928,7 @@ impl Parser {
             vec![]
         };
 
-        Ok(SQLStatement::SQLCreateTable {
+        Ok(Statement::CreateTable {
             name: table_name,
             columns,
             constraints,
@@ -941,7 +939,7 @@ impl Parser {
         })
     }
 
-    fn parse_columns(&mut self) -> Result<(Vec<SQLColumnDef>, Vec<TableConstraint>), ParserError> {
+    fn parse_columns(&mut self) -> Result<(Vec<ColumnDef>, Vec<TableConstraint>), ParserError> {
         let mut columns = vec![];
         let mut constraints = vec![];
         if !self.consume_token(&Token::LParen) || self.consume_token(&Token::RParen) {
@@ -951,7 +949,7 @@ impl Parser {
         loop {
             if let Some(constraint) = self.parse_optional_table_constraint()? {
                 constraints.push(constraint);
-            } else if let Some(Token::SQLWord(column_name)) = self.peek_token() {
+            } else if let Some(Token::Word(column_name)) = self.peek_token() {
                 self.next_token();
                 let data_type = self.parse_data_type()?;
                 let collation = if self.parse_keyword("COLLATE") {
@@ -967,8 +965,8 @@ impl Parser {
                     }
                 }
 
-                columns.push(SQLColumnDef {
-                    name: column_name.as_sql_ident(),
+                columns.push(ColumnDef {
+                    name: column_name.as_ident(),
                     data_type,
                     collation,
                     options,
@@ -1033,7 +1031,7 @@ impl Parser {
             None
         };
         match self.next_token() {
-            Some(Token::SQLWord(ref k)) if k.keyword == "PRIMARY" || k.keyword == "UNIQUE" => {
+            Some(Token::Word(ref k)) if k.keyword == "PRIMARY" || k.keyword == "UNIQUE" => {
                 let is_primary = k.keyword == "PRIMARY";
                 if is_primary {
                     self.expect_keyword("KEY")?;
@@ -1045,7 +1043,7 @@ impl Parser {
                     is_primary,
                 }))
             }
-            Some(Token::SQLWord(ref k)) if k.keyword == "FOREIGN" => {
+            Some(Token::Word(ref k)) if k.keyword == "FOREIGN" => {
                 self.expect_keyword("KEY")?;
                 let columns = self.parse_parenthesized_column_list(Mandatory)?;
                 self.expect_keyword("REFERENCES")?;
@@ -1058,7 +1056,7 @@ impl Parser {
                     referred_columns,
                 }))
             }
-            Some(Token::SQLWord(ref k)) if k.keyword == "CHECK" => {
+            Some(Token::Word(ref k)) if k.keyword == "CHECK" => {
                 self.expect_token(&Token::LParen)?;
                 let expr = Box::new(self.parse_expr()?);
                 self.expect_token(&Token::RParen)?;
@@ -1075,14 +1073,14 @@ impl Parser {
         }
     }
 
-    pub fn parse_with_options(&mut self) -> Result<Vec<SQLOption>, ParserError> {
+    pub fn parse_with_options(&mut self) -> Result<Vec<SqlOption>, ParserError> {
         self.expect_token(&Token::LParen)?;
         let mut options = vec![];
         loop {
             let name = self.parse_identifier()?;
             self.expect_token(&Token::Eq)?;
             let value = self.parse_value()?;
-            options.push(SQLOption { name, value });
+            options.push(SqlOption { name, value });
             if !self.consume_token(&Token::Comma) {
                 break;
             }
@@ -1091,7 +1089,7 @@ impl Parser {
         Ok(options)
     }
 
-    pub fn parse_alter(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_alter(&mut self) -> Result<Statement, ParserError> {
         self.expect_keyword("TABLE")?;
         let _ = self.parse_keyword("ONLY");
         let table_name = self.parse_object_name()?;
@@ -1104,21 +1102,21 @@ impl Parser {
         } else {
             return self.expected("ADD after ALTER TABLE", self.peek_token());
         };
-        Ok(SQLStatement::SQLAlterTable {
+        Ok(Statement::AlterTable {
             name: table_name,
             operation,
         })
     }
 
     /// Parse a copy statement
-    pub fn parse_copy(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_copy(&mut self) -> Result<Statement, ParserError> {
         let table_name = self.parse_object_name()?;
         let columns = self.parse_parenthesized_column_list(Optional)?;
         self.expect_keyword("FROM")?;
         self.expect_keyword("STDIN")?;
         self.expect_token(&Token::SemiColon)?;
         let values = self.parse_tsv()?;
-        Ok(SQLStatement::SQLCopy {
+        Ok(Statement::Copy {
             table_name,
             columns,
             values,
@@ -1132,10 +1130,6 @@ impl Parser {
         Ok(values)
     }
 
-    fn parse_sql_value(&mut self) -> Result<Expr, ParserError> {
-        Ok(Expr::SQLValue(self.parse_value()?))
-    }
-
     fn parse_tab_value(&mut self) -> Result<Vec<Option<String>>, ParserError> {
         let mut values = vec![];
         let mut content = String::from("");
@@ -1154,7 +1148,7 @@ impl Parser {
                         return Ok(values);
                     }
                     if let Some(token) = self.next_token() {
-                        if let Token::SQLWord(SQLWord { value: v, .. }) = token {
+                        if let Token::Word(Word { value: v, .. }) = token {
                             if v == "N" {
                                 values.push(None);
                             }
@@ -1175,7 +1169,7 @@ impl Parser {
     fn parse_value(&mut self) -> Result<Value, ParserError> {
         match self.next_token() {
             Some(t) => match t {
-                Token::SQLWord(k) => match k.keyword.as_ref() {
+                Token::Word(k) => match k.keyword.as_ref() {
                     "TRUE" => Ok(Value::Boolean(true)),
                     "FALSE" => Ok(Value::Boolean(false)),
                     "NULL" => Ok(Value::Null),
@@ -1221,36 +1215,36 @@ impl Parser {
     }
 
     /// Parse a SQL datatype (in the context of a CREATE TABLE statement for example)
-    pub fn parse_data_type(&mut self) -> Result<SQLType, ParserError> {
+    pub fn parse_data_type(&mut self) -> Result<DataType, ParserError> {
         match self.next_token() {
-            Some(Token::SQLWord(k)) => match k.keyword.as_ref() {
-                "BOOLEAN" => Ok(SQLType::Boolean),
-                "FLOAT" => Ok(SQLType::Float(self.parse_optional_precision()?)),
-                "REAL" => Ok(SQLType::Real),
+            Some(Token::Word(k)) => match k.keyword.as_ref() {
+                "BOOLEAN" => Ok(DataType::Boolean),
+                "FLOAT" => Ok(DataType::Float(self.parse_optional_precision()?)),
+                "REAL" => Ok(DataType::Real),
                 "DOUBLE" => {
                     let _ = self.parse_keyword("PRECISION");
-                    Ok(SQLType::Double)
+                    Ok(DataType::Double)
                 }
-                "SMALLINT" => Ok(SQLType::SmallInt),
-                "INT" | "INTEGER" => Ok(SQLType::Int),
-                "BIGINT" => Ok(SQLType::BigInt),
-                "VARCHAR" => Ok(SQLType::Varchar(self.parse_optional_precision()?)),
+                "SMALLINT" => Ok(DataType::SmallInt),
+                "INT" | "INTEGER" => Ok(DataType::Int),
+                "BIGINT" => Ok(DataType::BigInt),
+                "VARCHAR" => Ok(DataType::Varchar(self.parse_optional_precision()?)),
                 "CHAR" | "CHARACTER" => {
                     if self.parse_keyword("VARYING") {
-                        Ok(SQLType::Varchar(self.parse_optional_precision()?))
+                        Ok(DataType::Varchar(self.parse_optional_precision()?))
                     } else {
-                        Ok(SQLType::Char(self.parse_optional_precision()?))
+                        Ok(DataType::Char(self.parse_optional_precision()?))
                     }
                 }
-                "UUID" => Ok(SQLType::Uuid),
-                "DATE" => Ok(SQLType::Date),
+                "UUID" => Ok(DataType::Uuid),
+                "DATE" => Ok(DataType::Date),
                 "TIMESTAMP" => {
                     // TBD: we throw away "with/without timezone" information
                     if self.parse_keyword("WITH") || self.parse_keyword("WITHOUT") {
                         self.expect_keyword("TIME")?;
                         self.expect_keyword("ZONE")?;
                     }
-                    Ok(SQLType::Timestamp)
+                    Ok(DataType::Timestamp)
                 }
                 "TIME" => {
                     // TBD: we throw away "with/without timezone" information
@@ -1258,31 +1252,31 @@ impl Parser {
                         self.expect_keyword("TIME")?;
                         self.expect_keyword("ZONE")?;
                     }
-                    Ok(SQLType::Time)
+                    Ok(DataType::Time)
                 }
                 // Interval types can be followed by a complicated interval
                 // qualifier that we don't currently support. See
                 // parse_interval_literal for a taste.
-                "INTERVAL" => Ok(SQLType::Interval),
-                "REGCLASS" => Ok(SQLType::Regclass),
+                "INTERVAL" => Ok(DataType::Interval),
+                "REGCLASS" => Ok(DataType::Regclass),
                 "TEXT" => {
                     if self.consume_token(&Token::LBracket) {
                         // Note: this is postgresql-specific
                         self.expect_token(&Token::RBracket)?;
-                        Ok(SQLType::Array(Box::new(SQLType::Text)))
+                        Ok(DataType::Array(Box::new(DataType::Text)))
                     } else {
-                        Ok(SQLType::Text)
+                        Ok(DataType::Text)
                     }
                 }
-                "BYTEA" => Ok(SQLType::Bytea),
+                "BYTEA" => Ok(DataType::Bytea),
                 "NUMERIC" | "DECIMAL" | "DEC" => {
                     let (precision, scale) = self.parse_optional_precision_scale()?;
-                    Ok(SQLType::Decimal(precision, scale))
+                    Ok(DataType::Decimal(precision, scale))
                 }
                 _ => {
                     self.prev_token();
                     let type_name = self.parse_object_name()?;
-                    Ok(SQLType::Custom(type_name))
+                    Ok(DataType::Custom(type_name))
                 }
             },
             other => self.expected("a data type name", other),
@@ -1295,7 +1289,7 @@ impl Parser {
     pub fn parse_optional_alias(
         &mut self,
         reserved_kwds: &[&str],
-    ) -> Result<Option<SQLIdent>, ParserError> {
+    ) -> Result<Option<Ident>, ParserError> {
         let after_as = self.parse_keyword("AS");
         match self.next_token() {
             // Accept any identifier after `AS` (though many dialects have restrictions on
@@ -1303,10 +1297,10 @@ impl Parser {
             // which may start a construct allowed in this position, to be parsed as aliases.
             // (For example, in `FROM t1 JOIN` the `JOIN` will always be parsed as a keyword,
             // not an alias.)
-            Some(Token::SQLWord(ref w))
+            Some(Token::Word(ref w))
                 if after_as || !reserved_kwds.contains(&w.keyword.as_str()) =>
             {
-                Ok(Some(w.as_sql_ident()))
+                Ok(Some(w.as_ident()))
             }
             // MSSQL supports single-quoted strings as aliases for columns
             // We accept them as table aliases too, although MSSQL does not.
@@ -1339,7 +1333,7 @@ impl Parser {
     }
 
     /// Parse one or more identifiers with the specified separator between them
-    pub fn parse_list_of_ids(&mut self, separator: &Token) -> Result<Vec<SQLIdent>, ParserError> {
+    pub fn parse_list_of_ids(&mut self, separator: &Token) -> Result<Vec<Ident>, ParserError> {
         let mut idents = vec![];
         loop {
             idents.push(self.parse_identifier()?);
@@ -1352,14 +1346,14 @@ impl Parser {
 
     /// Parse a possibly qualified, possibly quoted identifier, e.g.
     /// `foo` or `myschema."table"`
-    pub fn parse_object_name(&mut self) -> Result<SQLObjectName, ParserError> {
-        Ok(SQLObjectName(self.parse_list_of_ids(&Token::Period)?))
+    pub fn parse_object_name(&mut self) -> Result<ObjectName, ParserError> {
+        Ok(ObjectName(self.parse_list_of_ids(&Token::Period)?))
     }
 
     /// Parse a simple one-word identifier (possibly quoted, possibly a keyword)
-    pub fn parse_identifier(&mut self) -> Result<SQLIdent, ParserError> {
+    pub fn parse_identifier(&mut self) -> Result<Ident, ParserError> {
         match self.next_token() {
-            Some(Token::SQLWord(w)) => Ok(w.as_sql_ident()),
+            Some(Token::Word(w)) => Ok(w.as_ident()),
             unexpected => self.expected("identifier", unexpected),
         }
     }
@@ -1368,7 +1362,7 @@ impl Parser {
     pub fn parse_parenthesized_column_list(
         &mut self,
         optional: IsOptional,
-    ) -> Result<Vec<SQLIdent>, ParserError> {
+    ) -> Result<Vec<Ident>, ParserError> {
         if self.consume_token(&Token::LParen) {
             let cols = self.parse_list_of_ids(&Token::Comma)?;
             self.expect_token(&Token::RParen)?;
@@ -1407,7 +1401,7 @@ impl Parser {
         }
     }
 
-    pub fn parse_delete(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_delete(&mut self) -> Result<Statement, ParserError> {
         self.expect_keyword("FROM")?;
         let table_name = self.parse_object_name()?;
         let selection = if self.parse_keyword("WHERE") {
@@ -1416,7 +1410,7 @@ impl Parser {
             None
         };
 
-        Ok(SQLStatement::SQLDelete {
+        Ok(Statement::Delete {
             table_name,
             selection,
         })
@@ -1426,7 +1420,7 @@ impl Parser {
     /// preceeded with some `WITH` CTE declarations and optionally followed
     /// by `ORDER BY`. Unlike some other parse_... methods, this one doesn't
     /// expect the initial keyword to be already consumed
-    pub fn parse_query(&mut self) -> Result<SQLQuery, ParserError> {
+    pub fn parse_query(&mut self) -> Result<Query, ParserError> {
         let ctes = if self.parse_keyword("WITH") {
             // TODO: optional RECURSIVE
             self.parse_cte_list()?
@@ -1460,7 +1454,7 @@ impl Parser {
             None
         };
 
-        Ok(SQLQuery {
+        Ok(Query {
             ctes,
             body,
             limit,
@@ -1501,18 +1495,18 @@ impl Parser {
     ///   subquery ::= query_body [ order_by_limit ]
     ///   set_operation ::= query_body { 'UNION' | 'EXCEPT' | 'INTERSECT' } [ 'ALL' ] query_body
     /// ```
-    fn parse_query_body(&mut self, precedence: u8) -> Result<SQLSetExpr, ParserError> {
+    fn parse_query_body(&mut self, precedence: u8) -> Result<SetExpr, ParserError> {
         // We parse the expression using a Pratt parser, as in `parse_expr()`.
         // Start by parsing a restricted SELECT or a `(subquery)`:
         let mut expr = if self.parse_keyword("SELECT") {
-            SQLSetExpr::Select(Box::new(self.parse_select()?))
+            SetExpr::Select(Box::new(self.parse_select()?))
         } else if self.consume_token(&Token::LParen) {
             // CTEs are not allowed here, but the parser currently accepts them
             let subquery = self.parse_query()?;
             self.expect_token(&Token::RParen)?;
-            SQLSetExpr::Query(Box::new(subquery))
+            SetExpr::Query(Box::new(subquery))
         } else if self.parse_keyword("VALUES") {
-            SQLSetExpr::Values(self.parse_values()?)
+            SetExpr::Values(self.parse_values()?)
         } else {
             return self.expected(
                 "SELECT, VALUES, or a subquery in the query body",
@@ -1526,9 +1520,9 @@ impl Parser {
             let op = self.parse_set_operator(&next_token);
             let next_precedence = match op {
                 // UNION and EXCEPT have the same binding power and evaluate left-to-right
-                Some(SQLSetOperator::Union) | Some(SQLSetOperator::Except) => 10,
+                Some(SetOperator::Union) | Some(SetOperator::Except) => 10,
                 // INTERSECT has higher precedence than UNION/EXCEPT
-                Some(SQLSetOperator::Intersect) => 20,
+                Some(SetOperator::Intersect) => 20,
                 // Unexpected token or EOF => stop parsing the query body
                 None => break,
             };
@@ -1536,7 +1530,7 @@ impl Parser {
                 break;
             }
             self.next_token(); // skip past the set operator
-            expr = SQLSetExpr::SetOperation {
+            expr = SetExpr::SetOperation {
                 left: Box::new(expr),
                 op: op.unwrap(),
                 all: self.parse_keyword("ALL"),
@@ -1547,18 +1541,18 @@ impl Parser {
         Ok(expr)
     }
 
-    fn parse_set_operator(&mut self, token: &Option<Token>) -> Option<SQLSetOperator> {
+    fn parse_set_operator(&mut self, token: &Option<Token>) -> Option<SetOperator> {
         match token {
-            Some(Token::SQLWord(w)) if w.keyword == "UNION" => Some(SQLSetOperator::Union),
-            Some(Token::SQLWord(w)) if w.keyword == "EXCEPT" => Some(SQLSetOperator::Except),
-            Some(Token::SQLWord(w)) if w.keyword == "INTERSECT" => Some(SQLSetOperator::Intersect),
+            Some(Token::Word(w)) if w.keyword == "UNION" => Some(SetOperator::Union),
+            Some(Token::Word(w)) if w.keyword == "EXCEPT" => Some(SetOperator::Except),
+            Some(Token::Word(w)) if w.keyword == "INTERSECT" => Some(SetOperator::Intersect),
             _ => None,
         }
     }
 
     /// Parse a restricted `SELECT` statement (no CTEs / `UNION` / `ORDER BY`),
     /// assuming the initial `SELECT` was already consumed
-    pub fn parse_select(&mut self) -> Result<SQLSelect, ParserError> {
+    pub fn parse_select(&mut self) -> Result<Select, ParserError> {
         let all = self.parse_keyword("ALL");
         let distinct = self.parse_keyword("DISTINCT");
         if all && distinct {
@@ -1599,7 +1593,7 @@ impl Parser {
             None
         };
 
-        Ok(SQLSelect {
+        Ok(Select {
             distinct,
             projection,
             from,
@@ -1639,7 +1633,7 @@ impl Parser {
                 }
             } else {
                 let natural = self.parse_keyword("NATURAL");
-                let peek_keyword = if let Some(Token::SQLWord(kw)) = self.peek_token() {
+                let peek_keyword = if let Some(Token::Word(kw)) = self.peek_token() {
                     kw.keyword
                 } else {
                     String::default()
@@ -1802,19 +1796,19 @@ impl Parser {
     }
 
     /// Parse an INSERT statement
-    pub fn parse_insert(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_insert(&mut self) -> Result<Statement, ParserError> {
         self.expect_keyword("INTO")?;
         let table_name = self.parse_object_name()?;
         let columns = self.parse_parenthesized_column_list(Optional)?;
         let source = Box::new(self.parse_query()?);
-        Ok(SQLStatement::SQLInsert {
+        Ok(Statement::Insert {
             table_name,
             columns,
             source,
         })
     }
 
-    pub fn parse_update(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_update(&mut self) -> Result<Statement, ParserError> {
         let table_name = self.parse_object_name()?;
         self.expect_keyword("SET")?;
         let mut assignments = vec![];
@@ -1822,7 +1816,7 @@ impl Parser {
             let id = self.parse_identifier()?;
             self.expect_token(&Token::Eq)?;
             let value = self.parse_expr()?;
-            assignments.push(SQLAssignment { id, value });
+            assignments.push(Assignment { id, value });
             if !self.consume_token(&Token::Comma) {
                 break;
             }
@@ -1832,7 +1826,7 @@ impl Parser {
         } else {
             None
         };
-        Ok(SQLStatement::SQLUpdate {
+        Ok(Statement::Update {
             table_name,
             assignments,
             selection,
@@ -1862,22 +1856,22 @@ impl Parser {
     }
 
     /// Parse a comma-delimited list of projections after SELECT
-    pub fn parse_select_list(&mut self) -> Result<Vec<SQLSelectItem>, ParserError> {
-        let mut projections: Vec<SQLSelectItem> = vec![];
+    pub fn parse_select_list(&mut self) -> Result<Vec<SelectItem>, ParserError> {
+        let mut projections: Vec<SelectItem> = vec![];
         loop {
             let expr = self.parse_expr()?;
-            if let Expr::SQLWildcard = expr {
-                projections.push(SQLSelectItem::Wildcard);
-            } else if let Expr::SQLQualifiedWildcard(prefix) = expr {
-                projections.push(SQLSelectItem::QualifiedWildcard(SQLObjectName(prefix)));
+            if let Expr::Wildcard = expr {
+                projections.push(SelectItem::Wildcard);
+            } else if let Expr::QualifiedWildcard(prefix) = expr {
+                projections.push(SelectItem::QualifiedWildcard(ObjectName(prefix)));
             } else {
                 // `expr` is a regular SQL expression and can be followed by an alias
                 if let Some(alias) =
                     self.parse_optional_alias(keywords::RESERVED_FOR_COLUMN_ALIAS)?
                 {
-                    projections.push(SQLSelectItem::ExprWithAlias { expr, alias });
+                    projections.push(SelectItem::ExprWithAlias { expr, alias });
                 } else {
-                    projections.push(SQLSelectItem::UnnamedExpr(expr));
+                    projections.push(SelectItem::UnnamedExpr(expr));
                 }
             }
 
@@ -1889,8 +1883,8 @@ impl Parser {
     }
 
     /// Parse a comma-delimited list of SQL ORDER BY expressions
-    pub fn parse_order_by_expr_list(&mut self) -> Result<Vec<SQLOrderByExpr>, ParserError> {
-        let mut expr_list: Vec<SQLOrderByExpr> = vec![];
+    pub fn parse_order_by_expr_list(&mut self) -> Result<Vec<OrderByExpr>, ParserError> {
+        let mut expr_list: Vec<OrderByExpr> = vec![];
         loop {
             let expr = self.parse_expr()?;
 
@@ -1902,7 +1896,7 @@ impl Parser {
                 None
             };
 
-            expr_list.push(SQLOrderByExpr { expr, asc });
+            expr_list.push(OrderByExpr { expr, asc });
             if !self.consume_token(&Token::Comma) {
                 break;
             }
@@ -1916,7 +1910,7 @@ impl Parser {
             Ok(None)
         } else {
             self.parse_literal_uint()
-                .map(|n| Some(Expr::SQLValue(Value::Long(n))))
+                .map(|n| Some(Expr::Value(Value::Long(n))))
         }
     }
 
@@ -1924,7 +1918,7 @@ impl Parser {
     pub fn parse_offset(&mut self) -> Result<Expr, ParserError> {
         let value = self
             .parse_literal_uint()
-            .map(|n| Expr::SQLValue(Value::Long(n)))?;
+            .map(|n| Expr::Value(Value::Long(n)))?;
         self.expect_one_of_keywords(&["ROW", "ROWS"])?;
         Ok(value)
     }
@@ -1935,7 +1929,7 @@ impl Parser {
         let (quantity, percent) = if self.parse_one_of_keywords(&["ROW", "ROWS"]).is_some() {
             (None, false)
         } else {
-            let quantity = self.parse_sql_value()?;
+            let quantity = Expr::Value(self.parse_value()?);
             let percent = self.parse_keyword("PERCENT");
             self.expect_one_of_keywords(&["ROW", "ROWS"])?;
             (Some(quantity), percent)
@@ -1954,7 +1948,7 @@ impl Parser {
         })
     }
 
-    pub fn parse_values(&mut self) -> Result<SQLValues, ParserError> {
+    pub fn parse_values(&mut self) -> Result<Values, ParserError> {
         let mut values = vec![];
         loop {
             self.expect_token(&Token::LParen)?;
@@ -1964,26 +1958,26 @@ impl Parser {
                 break;
             }
         }
-        Ok(SQLValues(values))
+        Ok(Values(values))
     }
 
-    pub fn parse_start_transaction(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_start_transaction(&mut self) -> Result<Statement, ParserError> {
         self.expect_keyword("TRANSACTION")?;
-        Ok(SQLStatement::SQLStartTransaction {
+        Ok(Statement::StartTransaction {
             modes: self.parse_transaction_modes()?,
         })
     }
 
-    pub fn parse_begin(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_begin(&mut self) -> Result<Statement, ParserError> {
         let _ = self.parse_one_of_keywords(&["TRANSACTION", "WORK"]);
-        Ok(SQLStatement::SQLStartTransaction {
+        Ok(Statement::StartTransaction {
             modes: self.parse_transaction_modes()?,
         })
     }
 
-    pub fn parse_set_transaction(&mut self) -> Result<SQLStatement, ParserError> {
+    pub fn parse_set_transaction(&mut self) -> Result<Statement, ParserError> {
         self.expect_keyword("TRANSACTION")?;
-        Ok(SQLStatement::SQLSetTransaction {
+        Ok(Statement::SetTransaction {
             modes: self.parse_transaction_modes()?,
         })
     }
@@ -2024,14 +2018,14 @@ impl Parser {
         Ok(modes)
     }
 
-    pub fn parse_commit(&mut self) -> Result<SQLStatement, ParserError> {
-        Ok(SQLStatement::SQLCommit {
+    pub fn parse_commit(&mut self) -> Result<Statement, ParserError> {
+        Ok(Statement::Commit {
             chain: self.parse_commit_rollback_chain()?,
         })
     }
 
-    pub fn parse_rollback(&mut self) -> Result<SQLStatement, ParserError> {
-        Ok(SQLStatement::SQLRollback {
+    pub fn parse_rollback(&mut self) -> Result<Statement, ParserError> {
+        Ok(Statement::Rollback {
             chain: self.parse_commit_rollback_chain()?,
         })
     }
@@ -2048,8 +2042,8 @@ impl Parser {
     }
 }
 
-impl SQLWord {
-    pub fn as_sql_ident(&self) -> SQLIdent {
+impl Word {
+    pub fn as_ident(&self) -> Ident {
         self.to_string()
     }
 }
diff --git a/src/sqlast/sql_operator.rs b/src/sqlast/sql_operator.rs
deleted file mode 100644
index 4845d0623..000000000
--- a/src/sqlast/sql_operator.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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.
-
-/// Unary operators
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLUnaryOperator {
-    Plus,
-    Minus,
-    Not,
-}
-
-impl ToString for SQLUnaryOperator {
-    fn to_string(&self) -> String {
-        match self {
-            SQLUnaryOperator::Plus => "+".to_string(),
-            SQLUnaryOperator::Minus => "-".to_string(),
-            SQLUnaryOperator::Not => "NOT".to_string(),
-        }
-    }
-}
-
-/// Binary operators
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub enum SQLBinaryOperator {
-    Plus,
-    Minus,
-    Multiply,
-    Divide,
-    Modulus,
-    Gt,
-    Lt,
-    GtEq,
-    LtEq,
-    Eq,
-    NotEq,
-    And,
-    Or,
-    Like,
-    NotLike,
-}
-
-impl ToString for SQLBinaryOperator {
-    fn to_string(&self) -> String {
-        match self {
-            SQLBinaryOperator::Plus => "+".to_string(),
-            SQLBinaryOperator::Minus => "-".to_string(),
-            SQLBinaryOperator::Multiply => "*".to_string(),
-            SQLBinaryOperator::Divide => "/".to_string(),
-            SQLBinaryOperator::Modulus => "%".to_string(),
-            SQLBinaryOperator::Gt => ">".to_string(),
-            SQLBinaryOperator::Lt => "<".to_string(),
-            SQLBinaryOperator::GtEq => ">=".to_string(),
-            SQLBinaryOperator::LtEq => "<=".to_string(),
-            SQLBinaryOperator::Eq => "=".to_string(),
-            SQLBinaryOperator::NotEq => "<>".to_string(),
-            SQLBinaryOperator::And => "AND".to_string(),
-            SQLBinaryOperator::Or => "OR".to_string(),
-            SQLBinaryOperator::Like => "LIKE".to_string(),
-            SQLBinaryOperator::NotLike => "NOT LIKE".to_string(),
-        }
-    }
-}
diff --git a/src/test_utils.rs b/src/test_utils.rs
index 5f738d4f2..547c6d366 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -12,10 +12,10 @@
 
 use std::fmt::Debug;
 
+use super::ast::*;
 use super::dialect::*;
-use super::sqlast::*;
-use super::sqlparser::{Parser, ParserError};
-use super::sqltokenizer::Tokenizer;
+use super::parser::{Parser, ParserError};
+use super::tokenizer::Tokenizer;
 
 /// Tests use the methods on this struct to invoke the parser on one or
 /// multiple dialects.
@@ -57,7 +57,7 @@ impl TestedDialects {
         })
     }
 
-    pub fn parse_sql_statements(&self, sql: &str) -> Result<Vec<SQLStatement>, ParserError> {
+    pub fn parse_sql_statements(&self, sql: &str) -> Result<Vec<Statement>, ParserError> {
         self.one_of_identical_results(|dialect| Parser::parse_sql(dialect, sql.to_string()))
         // To fail the `ensure_multiple_dialects_are_tested` test:
         // Parser::parse_sql(&**self.dialects.first().unwrap(), sql.to_string())
@@ -66,7 +66,7 @@ impl TestedDialects {
     /// Ensures that `sql` parses as a single statement, optionally checking
     /// that converting AST back to string equals to `canonical` (unless an
     /// empty canonical string is provided).
-    pub fn one_statement_parses_to(&self, sql: &str, canonical: &str) -> SQLStatement {
+    pub fn one_statement_parses_to(&self, sql: &str, canonical: &str) -> Statement {
         let mut statements = self.parse_sql_statements(&sql).unwrap();
         assert_eq!(statements.len(), 1);
 
@@ -79,24 +79,24 @@ impl TestedDialects {
 
     /// Ensures that `sql` parses as a single SQLStatement, and is not modified
     /// after a serialization round-trip.
-    pub fn verified_stmt(&self, query: &str) -> SQLStatement {
+    pub fn verified_stmt(&self, query: &str) -> Statement {
         self.one_statement_parses_to(query, query)
     }
 
     /// Ensures that `sql` parses as a single SQLQuery, and is not modified
     /// after a serialization round-trip.
-    pub fn verified_query(&self, sql: &str) -> SQLQuery {
+    pub fn verified_query(&self, sql: &str) -> Query {
         match self.verified_stmt(sql) {
-            SQLStatement::SQLQuery(query) => *query,
+            Statement::Query(query) => *query,
             _ => panic!("Expected SQLQuery"),
         }
     }
 
     /// Ensures that `sql` parses as a single SQLSelect, and is not modified
     /// after a serialization round-trip.
-    pub fn verified_only_select(&self, query: &str) -> SQLSelect {
+    pub fn verified_only_select(&self, query: &str) -> Select {
         match self.verified_query(query).body {
-            SQLSetExpr::Select(s) => *s,
+            SetExpr::Select(s) => *s,
             _ => panic!("Expected SQLSetExpr::Select"),
         }
     }
@@ -113,10 +113,10 @@ impl TestedDialects {
 pub fn all_dialects() -> TestedDialects {
     TestedDialects {
         dialects: vec![
-            Box::new(GenericSqlDialect {}),
+            Box::new(GenericDialect {}),
             Box::new(PostgreSqlDialect {}),
             Box::new(MsSqlDialect {}),
-            Box::new(AnsiSqlDialect {}),
+            Box::new(AnsiDialect {}),
         ],
     }
 }
@@ -130,9 +130,9 @@ pub fn only<T>(v: impl IntoIterator<Item = T>) -> T {
     }
 }
 
-pub fn expr_from_projection(item: &SQLSelectItem) -> &Expr {
+pub fn expr_from_projection(item: &SelectItem) -> &Expr {
     match item {
-        SQLSelectItem::UnnamedExpr(expr) => expr,
+        SelectItem::UnnamedExpr(expr) => expr,
         _ => panic!("Expected UnnamedExpr"),
     }
 }
diff --git a/src/sqltokenizer.rs b/src/tokenizer.rs
similarity index 96%
rename from src/sqltokenizer.rs
rename to src/tokenizer.rs
index 287396b95..d68390d93 100644
--- a/src/sqltokenizer.rs
+++ b/src/tokenizer.rs
@@ -26,7 +26,7 @@ use super::dialect::Dialect;
 #[derive(Debug, Clone, PartialEq)]
 pub enum Token {
     /// A keyword (like SELECT) or an optionally quoted SQL identifier
-    SQLWord(SQLWord),
+    Word(Word),
     /// An unsigned numeric literal
     Number(String),
     /// A character that could not be tokenized
@@ -92,7 +92,7 @@ pub enum Token {
 impl ToString for Token {
     fn to_string(&self) -> String {
         match self {
-            Token::SQLWord(ref w) => w.to_string(),
+            Token::Word(ref w) => w.to_string(),
             Token::Number(ref n) => n.to_string(),
             Token::Char(ref c) => c.to_string(),
             Token::SingleQuotedString(ref s) => format!("'{}'", s),
@@ -137,7 +137,7 @@ impl Token {
         // not fast but I want the simplicity for now while I experiment with pluggable
         // dialects
         let is_keyword = quote_style == None && ALL_KEYWORDS.contains(&word_uppercase.as_str());
-        Token::SQLWord(SQLWord {
+        Token::Word(Word {
             value: word.to_string(),
             quote_style,
             keyword: if is_keyword {
@@ -151,7 +151,7 @@ impl Token {
 
 /// A keyword (like SELECT) or an optionally quoted SQL identifier
 #[derive(Debug, Clone, PartialEq)]
-pub struct SQLWord {
+pub struct Word {
     /// The value of the token, without the enclosing quotes, and with the
     /// escape sequences (if any) processed (TODO: escapes are not handled)
     pub value: String,
@@ -164,18 +164,18 @@ pub struct SQLWord {
     pub keyword: String,
 }
 
-impl ToString for SQLWord {
+impl ToString for Word {
     fn to_string(&self) -> String {
         match self.quote_style {
             Some(s) if s == '"' || s == '[' || s == '`' => {
-                format!("{}{}{}", s, self.value, SQLWord::matching_end_quote(s))
+                format!("{}{}{}", s, self.value, Word::matching_end_quote(s))
             }
             None => self.value.clone(),
             _ => panic!("Unexpected quote_style!"),
         }
     }
 }
-impl SQLWord {
+impl Word {
     fn matching_end_quote(ch: char) -> char {
         match ch {
             '"' => '"', // ANSI and most dialects
@@ -244,8 +244,8 @@ impl<'a> Tokenizer<'a> {
                 }
 
                 Token::Whitespace(Whitespace::Tab) => self.col += 4,
-                Token::SQLWord(w) if w.quote_style == None => self.col += w.value.len() as u64,
-                Token::SQLWord(w) if w.quote_style != None => self.col += w.value.len() as u64 + 2,
+                Token::Word(w) if w.quote_style == None => self.col += w.value.len() as u64,
+                Token::Word(w) if w.quote_style != None => self.col += w.value.len() as u64 + 2,
                 Token::Number(s) => self.col += s.len() as u64,
                 Token::SingleQuotedString(s) => self.col += s.len() as u64,
                 _ => self.col += 1,
@@ -318,7 +318,7 @@ impl<'a> Tokenizer<'a> {
                 // delimited (quoted) identifier
                 quote_start if self.dialect.is_delimited_identifier_start(quote_start) => {
                     chars.next(); // consume the opening quote
-                    let quote_end = SQLWord::matching_end_quote(quote_start);
+                    let quote_end = Word::matching_end_quote(quote_start);
                     let s = peeking_take_while(chars, |ch| ch != quote_end);
                     if chars.next() == Some(quote_end) {
                         Ok(Some(Token::make_word(&s, Some(quote_start))))
@@ -520,13 +520,13 @@ fn peeking_take_while(
 
 #[cfg(test)]
 mod tests {
-    use super::super::dialect::GenericSqlDialect;
+    use super::super::dialect::GenericDialect;
     use super::*;
 
     #[test]
     fn tokenize_select_1() {
         let sql = String::from("SELECT 1");
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
 
@@ -542,7 +542,7 @@ mod tests {
     #[test]
     fn tokenize_scalar_function() {
         let sql = String::from("SELECT sqrt(1)");
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
 
@@ -561,7 +561,7 @@ mod tests {
     #[test]
     fn tokenize_simple_select() {
         let sql = String::from("SELECT * FROM customer WHERE id = 1 LIMIT 5");
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
 
@@ -593,7 +593,7 @@ mod tests {
     #[test]
     fn tokenize_string_predicate() {
         let sql = String::from("SELECT * FROM customer WHERE salary != 'Not Provided'");
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
 
@@ -622,7 +622,7 @@ mod tests {
     fn tokenize_invalid_string() {
         let sql = String::from("\nمصطفىh");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         println!("tokens: {:#?}", tokens);
@@ -642,7 +642,7 @@ mod tests {
     fn tokenize_invalid_string_cols() {
         let sql = String::from("\n\nSELECT * FROM table\tمصطفىh");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         println!("tokens: {:#?}", tokens);
@@ -670,7 +670,7 @@ mod tests {
     #[test]
     fn tokenize_is_null() {
         let sql = String::from("a IS NULL");
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
 
@@ -689,7 +689,7 @@ mod tests {
     fn tokenize_comment() {
         let sql = String::from("0--this is a comment\n1");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         let expected = vec![
@@ -706,7 +706,7 @@ mod tests {
     fn tokenize_comment_at_eof() {
         let sql = String::from("--this is a comment");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         let expected = vec![Token::Whitespace(Whitespace::SingleLineComment(
@@ -719,7 +719,7 @@ mod tests {
     fn tokenize_multiline_comment() {
         let sql = String::from("0/*multi-line\n* /comment*/1");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         let expected = vec![
@@ -736,7 +736,7 @@ mod tests {
     fn tokenize_multiline_comment_with_even_asterisks() {
         let sql = String::from("\n/** Comment **/\n");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         let expected = vec![
@@ -751,7 +751,7 @@ mod tests {
     fn tokenize_mismatched_quotes() {
         let sql = String::from("\"foo");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         assert_eq!(
             tokenizer.tokenize(),
@@ -765,7 +765,7 @@ mod tests {
     fn tokenize_newlines() {
         let sql = String::from("line1\nline2\rline3\r\nline4\r");
 
-        let dialect = GenericSqlDialect {};
+        let dialect = GenericDialect {};
         let mut tokenizer = Tokenizer::new(&dialect, &sql);
         let tokens = tokenizer.tokenize().unwrap();
         let expected = vec![
diff --git a/tests/sqlparser_common.rs b/tests/sqlparser_common.rs
index 542358706..441153978 100644
--- a/tests/sqlparser_common.rs
+++ b/tests/sqlparser_common.rs
@@ -20,16 +20,16 @@
 
 use matches::assert_matches;
 
-use sqlparser::sqlast::*;
-use sqlparser::sqlparser::*;
+use sqlparser::ast::*;
+use sqlparser::parser::*;
 use sqlparser::test_utils::{all_dialects, expr_from_projection, only};
 
 #[test]
 fn parse_insert_values() {
     let row = vec![
-        Expr::SQLValue(Value::Long(1)),
-        Expr::SQLValue(Value::Long(2)),
-        Expr::SQLValue(Value::Long(3)),
+        Expr::Value(Value::Long(1)),
+        Expr::Value(Value::Long(2)),
+        Expr::Value(Value::Long(3)),
     ];
     let rows1 = vec![row.clone()];
     let rows2 = vec![row.clone(), row];
@@ -61,7 +61,7 @@ fn parse_insert_values() {
         expected_rows: &[Vec<Expr>],
     ) {
         match verified_stmt(sql) {
-            SQLStatement::SQLInsert {
+            Statement::Insert {
                 table_name,
                 columns,
                 source,
@@ -70,9 +70,7 @@ fn parse_insert_values() {
                 assert_eq!(table_name.to_string(), expected_table_name);
                 assert_eq!(columns, expected_columns);
                 match &source.body {
-                    SQLSetExpr::Values(SQLValues(values)) => {
-                        assert_eq!(values.as_slice(), expected_rows)
-                    }
+                    SetExpr::Values(Values(values)) => assert_eq!(values.as_slice(), expected_rows),
                     _ => unreachable!(),
                 }
             }
@@ -97,7 +95,7 @@ fn parse_insert_invalid() {
 fn parse_update() {
     let sql = "UPDATE t SET a = 1, b = 2, c = 3 WHERE d";
     match verified_stmt(sql) {
-        SQLStatement::SQLUpdate {
+        Statement::Update {
             table_name,
             assignments,
             selection,
@@ -107,21 +105,21 @@ fn parse_update() {
             assert_eq!(
                 assignments,
                 vec![
-                    SQLAssignment {
+                    Assignment {
                         id: "a".into(),
-                        value: Expr::SQLValue(Value::Long(1)),
+                        value: Expr::Value(Value::Long(1)),
                     },
-                    SQLAssignment {
+                    Assignment {
                         id: "b".into(),
-                        value: Expr::SQLValue(Value::Long(2)),
+                        value: Expr::Value(Value::Long(2)),
                     },
-                    SQLAssignment {
+                    Assignment {
                         id: "c".into(),
-                        value: Expr::SQLValue(Value::Long(3)),
+                        value: Expr::Value(Value::Long(3)),
                     },
                 ]
             );
-            assert_eq!(selection.unwrap(), Expr::SQLIdentifier("d".into()));
+            assert_eq!(selection.unwrap(), Expr::Identifier("d".into()));
         }
         _ => unreachable!(),
     }
@@ -159,8 +157,8 @@ fn parse_no_table_name() {
 fn parse_delete_statement() {
     let sql = "DELETE FROM \"table\"";
     match verified_stmt(sql) {
-        SQLStatement::SQLDelete { table_name, .. } => {
-            assert_eq!(SQLObjectName(vec!["\"table\"".to_string()]), table_name);
+        Statement::Delete { table_name, .. } => {
+            assert_eq!(ObjectName(vec!["\"table\"".to_string()]), table_name);
         }
         _ => unreachable!(),
     }
@@ -168,23 +166,22 @@ fn parse_delete_statement() {
 
 #[test]
 fn parse_where_delete_statement() {
-    use self::Expr::*;
-    use self::SQLBinaryOperator::*;
+    use self::BinaryOperator::*;
 
     let sql = "DELETE FROM foo WHERE name = 5";
     match verified_stmt(sql) {
-        SQLStatement::SQLDelete {
+        Statement::Delete {
             table_name,
             selection,
             ..
         } => {
-            assert_eq!(SQLObjectName(vec!["foo".to_string()]), table_name);
+            assert_eq!(ObjectName(vec!["foo".to_string()]), table_name);
 
             assert_eq!(
-                SQLBinaryOp {
-                    left: Box::new(SQLIdentifier("name".to_string())),
+                Expr::BinaryOp {
+                    left: Box::new(Expr::Identifier("name".to_string())),
                     op: Eq,
-                    right: Box::new(SQLValue(Value::Long(5))),
+                    right: Box::new(Expr::Value(Value::Long(5))),
                 },
                 selection.unwrap(),
             );
@@ -208,17 +205,17 @@ fn parse_simple_select() {
     assert_eq!(false, select.distinct);
     assert_eq!(3, select.projection.len());
     let select = verified_query(sql);
-    assert_eq!(Some(Expr::SQLValue(Value::Long(5))), select.limit);
+    assert_eq!(Some(Expr::Value(Value::Long(5))), select.limit);
 }
 
 #[test]
 fn parse_limit_is_not_an_alias() {
     // In dialects supporting LIMIT it shouldn't be parsed as a table alias
     let ast = verified_query("SELECT id FROM customer LIMIT 1");
-    assert_eq!(Some(Expr::SQLValue(Value::Long(1))), ast.limit);
+    assert_eq!(Some(Expr::Value(Value::Long(1))), ast.limit);
 
     let ast = verified_query("SELECT 1 LIMIT 5");
-    assert_eq!(Some(Expr::SQLValue(Value::Long(5))), ast.limit);
+    assert_eq!(Some(Expr::Value(Value::Long(5))), ast.limit);
 }
 
 #[test]
@@ -227,7 +224,7 @@ fn parse_select_distinct() {
     let select = verified_only_select(sql);
     assert_eq!(true, select.distinct);
     assert_eq!(
-        &SQLSelectItem::UnnamedExpr(Expr::SQLIdentifier("name".to_string())),
+        &SelectItem::UnnamedExpr(Expr::Identifier("name".to_string())),
         only(&select.projection)
     );
 }
@@ -250,19 +247,19 @@ fn parse_select_all_distinct() {
 fn parse_select_wildcard() {
     let sql = "SELECT * FROM foo";
     let select = verified_only_select(sql);
-    assert_eq!(&SQLSelectItem::Wildcard, only(&select.projection));
+    assert_eq!(&SelectItem::Wildcard, only(&select.projection));
 
     let sql = "SELECT foo.* FROM foo";
     let select = verified_only_select(sql);
     assert_eq!(
-        &SQLSelectItem::QualifiedWildcard(SQLObjectName(vec!["foo".to_string()])),
+        &SelectItem::QualifiedWildcard(ObjectName(vec!["foo".to_string()])),
         only(&select.projection)
     );
 
     let sql = "SELECT myschema.mytable.* FROM myschema.mytable";
     let select = verified_only_select(sql);
     assert_eq!(
-        &SQLSelectItem::QualifiedWildcard(SQLObjectName(vec![
+        &SelectItem::QualifiedWildcard(ObjectName(vec![
             "myschema".to_string(),
             "mytable".to_string(),
         ])),
@@ -281,15 +278,15 @@ fn parse_count_wildcard() {
 fn parse_column_aliases() {
     let sql = "SELECT a.col + 1 AS newname FROM foo AS a";
     let select = verified_only_select(sql);
-    if let SQLSelectItem::ExprWithAlias {
-        expr: Expr::SQLBinaryOp {
+    if let SelectItem::ExprWithAlias {
+        expr: Expr::BinaryOp {
             ref op, ref right, ..
         },
         ref alias,
     } = only(&select.projection)
     {
-        assert_eq!(&SQLBinaryOperator::Plus, op);
-        assert_eq!(&Expr::SQLValue(Value::Long(1)), right.as_ref());
+        assert_eq!(&BinaryOperator::Plus, op);
+        assert_eq!(&Expr::Value(Value::Long(1)), right.as_ref());
         assert_eq!("newname", alias);
     } else {
         panic!("Expected ExprWithAlias")
@@ -319,9 +316,9 @@ fn parse_select_count_wildcard() {
     let sql = "SELECT COUNT(*) FROM customer";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLFunction(SQLFunction {
-            name: SQLObjectName(vec!["COUNT".to_string()]),
-            args: vec![Expr::SQLWildcard],
+        &Expr::Function(Function {
+            name: ObjectName(vec!["COUNT".to_string()]),
+            args: vec![Expr::Wildcard],
             over: None,
             distinct: false,
         }),
@@ -334,11 +331,11 @@ fn parse_select_count_distinct() {
     let sql = "SELECT COUNT(DISTINCT + x) FROM customer";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLFunction(SQLFunction {
-            name: SQLObjectName(vec!["COUNT".to_string()]),
-            args: vec![Expr::SQLUnaryOp {
-                op: SQLUnaryOperator::Plus,
-                expr: Box::new(Expr::SQLIdentifier("x".to_string()))
+        &Expr::Function(Function {
+            name: ObjectName(vec!["COUNT".to_string()]),
+            args: vec![Expr::UnaryOp {
+                op: UnaryOperator::Plus,
+                expr: Box::new(Expr::Identifier("x".to_string()))
             }],
             over: None,
             distinct: true,
@@ -382,7 +379,7 @@ fn parse_collate() {
     let sql = "SELECT name COLLATE \"de_DE\" FROM customer";
     assert_matches!(
         only(&all_dialects().verified_only_select(sql).projection),
-        SQLSelectItem::UnnamedExpr(Expr::SQLCollate { .. })
+        SelectItem::UnnamedExpr(Expr::Collate { .. })
     );
 }
 
@@ -406,23 +403,22 @@ fn parse_null_in_select() {
     let sql = "SELECT NULL";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Null),
+        &Expr::Value(Value::Null),
         expr_from_projection(only(&select.projection)),
     );
 }
 
 #[test]
 fn parse_escaped_single_quote_string_predicate() {
-    use self::Expr::*;
-    use self::SQLBinaryOperator::*;
+    use self::BinaryOperator::*;
     let sql = "SELECT id, fname, lname FROM customer \
                WHERE salary <> 'Jim''s salary'";
     let ast = verified_only_select(sql);
     assert_eq!(
-        Some(SQLBinaryOp {
-            left: Box::new(SQLIdentifier("salary".to_string())),
+        Some(Expr::BinaryOp {
+            left: Box::new(Expr::Identifier("salary".to_string())),
             op: NotEq,
-            right: Box::new(SQLValue(Value::SingleQuotedString(
+            right: Box::new(Expr::Value(Value::SingleQuotedString(
                 "Jim's salary".to_string()
             )))
         }),
@@ -432,17 +428,17 @@ fn parse_escaped_single_quote_string_predicate() {
 
 #[test]
 fn parse_compound_expr_1() {
+    use self::BinaryOperator::*;
     use self::Expr::*;
-    use self::SQLBinaryOperator::*;
     let sql = "a + b * c";
     assert_eq!(
-        SQLBinaryOp {
-            left: Box::new(SQLIdentifier("a".to_string())),
+        BinaryOp {
+            left: Box::new(Identifier("a".to_string())),
             op: Plus,
-            right: Box::new(SQLBinaryOp {
-                left: Box::new(SQLIdentifier("b".to_string())),
+            right: Box::new(BinaryOp {
+                left: Box::new(Identifier("b".to_string())),
                 op: Multiply,
-                right: Box::new(SQLIdentifier("c".to_string()))
+                right: Box::new(Identifier("c".to_string()))
             })
         },
         verified_expr(sql)
@@ -451,18 +447,18 @@ fn parse_compound_expr_1() {
 
 #[test]
 fn parse_compound_expr_2() {
+    use self::BinaryOperator::*;
     use self::Expr::*;
-    use self::SQLBinaryOperator::*;
     let sql = "a * b + c";
     assert_eq!(
-        SQLBinaryOp {
-            left: Box::new(SQLBinaryOp {
-                left: Box::new(SQLIdentifier("a".to_string())),
+        BinaryOp {
+            left: Box::new(BinaryOp {
+                left: Box::new(Identifier("a".to_string())),
                 op: Multiply,
-                right: Box::new(SQLIdentifier("b".to_string()))
+                right: Box::new(Identifier("b".to_string()))
             }),
             op: Plus,
-            right: Box::new(SQLIdentifier("c".to_string()))
+            right: Box::new(Identifier("c".to_string()))
         },
         verified_expr(sql)
     );
@@ -473,15 +469,15 @@ fn parse_unary_math() {
     use self::Expr::*;
     let sql = "- a + - b";
     assert_eq!(
-        SQLBinaryOp {
-            left: Box::new(SQLUnaryOp {
-                op: SQLUnaryOperator::Minus,
-                expr: Box::new(SQLIdentifier("a".to_string())),
+        BinaryOp {
+            left: Box::new(UnaryOp {
+                op: UnaryOperator::Minus,
+                expr: Box::new(Identifier("a".to_string())),
             }),
-            op: SQLBinaryOperator::Plus,
-            right: Box::new(SQLUnaryOp {
-                op: SQLUnaryOperator::Minus,
-                expr: Box::new(SQLIdentifier("b".to_string())),
+            op: BinaryOperator::Plus,
+            right: Box::new(UnaryOp {
+                op: UnaryOperator::Minus,
+                expr: Box::new(Identifier("b".to_string())),
             }),
         },
         verified_expr(sql)
@@ -493,7 +489,7 @@ fn parse_is_null() {
     use self::Expr::*;
     let sql = "a IS NULL";
     assert_eq!(
-        SQLIsNull(Box::new(SQLIdentifier("a".to_string()))),
+        IsNull(Box::new(Identifier("a".to_string()))),
         verified_expr(sql)
     );
 }
@@ -503,25 +499,24 @@ fn parse_is_not_null() {
     use self::Expr::*;
     let sql = "a IS NOT NULL";
     assert_eq!(
-        SQLIsNotNull(Box::new(SQLIdentifier("a".to_string()))),
+        IsNotNull(Box::new(Identifier("a".to_string()))),
         verified_expr(sql)
     );
 }
 
 #[test]
 fn parse_not_precedence() {
-    use self::Expr::*;
     // NOT has higher precedence than OR/AND, so the following must parse as (NOT true) OR true
     let sql = "NOT true OR true";
-    assert_matches!(verified_expr(sql), SQLBinaryOp {
-        op: SQLBinaryOperator::Or,
+    assert_matches!(verified_expr(sql), Expr::BinaryOp {
+        op: BinaryOperator::Or,
         ..
     });
 
     // But NOT has lower precedence than comparison operators, so the following parses as NOT (a IS NULL)
     let sql = "NOT a IS NULL";
-    assert_matches!(verified_expr(sql), SQLUnaryOp {
-        op: SQLUnaryOperator::Not,
+    assert_matches!(verified_expr(sql), Expr::UnaryOp {
+        op: UnaryOperator::Not,
         ..
     });
 
@@ -529,12 +524,12 @@ fn parse_not_precedence() {
     let sql = "NOT 1 NOT BETWEEN 1 AND 2";
     assert_eq!(
         verified_expr(sql),
-        SQLUnaryOp {
-            op: SQLUnaryOperator::Not,
-            expr: Box::new(SQLBetween {
-                expr: Box::new(SQLValue(Value::Long(1))),
-                low: Box::new(SQLValue(Value::Long(1))),
-                high: Box::new(SQLValue(Value::Long(2))),
+        Expr::UnaryOp {
+            op: UnaryOperator::Not,
+            expr: Box::new(Expr::Between {
+                expr: Box::new(Expr::Value(Value::Long(1))),
+                low: Box::new(Expr::Value(Value::Long(1))),
+                high: Box::new(Expr::Value(Value::Long(2))),
                 negated: true,
             }),
         },
@@ -544,12 +539,12 @@ fn parse_not_precedence() {
     let sql = "NOT 'a' NOT LIKE 'b'";
     assert_eq!(
         verified_expr(sql),
-        SQLUnaryOp {
-            op: SQLUnaryOperator::Not,
-            expr: Box::new(SQLBinaryOp {
-                left: Box::new(SQLValue(Value::SingleQuotedString("a".into()))),
-                op: SQLBinaryOperator::NotLike,
-                right: Box::new(SQLValue(Value::SingleQuotedString("b".into()))),
+        Expr::UnaryOp {
+            op: UnaryOperator::Not,
+            expr: Box::new(Expr::BinaryOp {
+                left: Box::new(Expr::Value(Value::SingleQuotedString("a".into()))),
+                op: BinaryOperator::NotLike,
+                right: Box::new(Expr::Value(Value::SingleQuotedString("b".into()))),
             }),
         },
     );
@@ -558,11 +553,11 @@ fn parse_not_precedence() {
     let sql = "NOT a NOT IN ('a')";
     assert_eq!(
         verified_expr(sql),
-        SQLUnaryOp {
-            op: SQLUnaryOperator::Not,
-            expr: Box::new(SQLInList {
-                expr: Box::new(SQLIdentifier("a".into())),
-                list: vec![SQLValue(Value::SingleQuotedString("a".into()))],
+        Expr::UnaryOp {
+            op: UnaryOperator::Not,
+            expr: Box::new(Expr::InList {
+                expr: Box::new(Expr::Identifier("a".into())),
+                list: vec![Expr::Value(Value::SingleQuotedString("a".into()))],
                 negated: true,
             }),
         },
@@ -578,14 +573,14 @@ fn parse_like() {
         );
         let select = verified_only_select(sql);
         assert_eq!(
-            Expr::SQLBinaryOp {
-                left: Box::new(Expr::SQLIdentifier("name".to_string())),
+            Expr::BinaryOp {
+                left: Box::new(Expr::Identifier("name".to_string())),
                 op: if negated {
-                    SQLBinaryOperator::NotLike
+                    BinaryOperator::NotLike
                 } else {
-                    SQLBinaryOperator::Like
+                    BinaryOperator::Like
                 },
-                right: Box::new(Expr::SQLValue(Value::SingleQuotedString("%a".to_string()))),
+                right: Box::new(Expr::Value(Value::SingleQuotedString("%a".to_string()))),
             },
             select.selection.unwrap()
         );
@@ -598,14 +593,14 @@ fn parse_like() {
         );
         let select = verified_only_select(sql);
         assert_eq!(
-            Expr::SQLIsNull(Box::new(Expr::SQLBinaryOp {
-                left: Box::new(Expr::SQLIdentifier("name".to_string())),
+            Expr::IsNull(Box::new(Expr::BinaryOp {
+                left: Box::new(Expr::Identifier("name".to_string())),
                 op: if negated {
-                    SQLBinaryOperator::NotLike
+                    BinaryOperator::NotLike
                 } else {
-                    SQLBinaryOperator::Like
+                    BinaryOperator::Like
                 },
-                right: Box::new(Expr::SQLValue(Value::SingleQuotedString("%a".to_string()))),
+                right: Box::new(Expr::Value(Value::SingleQuotedString("%a".to_string()))),
             })),
             select.selection.unwrap()
         );
@@ -623,11 +618,11 @@ fn parse_in_list() {
         );
         let select = verified_only_select(sql);
         assert_eq!(
-            Expr::SQLInList {
-                expr: Box::new(Expr::SQLIdentifier("segment".to_string())),
+            Expr::InList {
+                expr: Box::new(Expr::Identifier("segment".to_string())),
                 list: vec![
-                    Expr::SQLValue(Value::SingleQuotedString("HIGH".to_string())),
-                    Expr::SQLValue(Value::SingleQuotedString("MED".to_string())),
+                    Expr::Value(Value::SingleQuotedString("HIGH".to_string())),
+                    Expr::Value(Value::SingleQuotedString("MED".to_string())),
                 ],
                 negated,
             },
@@ -643,8 +638,8 @@ fn parse_in_subquery() {
     let sql = "SELECT * FROM customers WHERE segment IN (SELECT segm FROM bar)";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::SQLInSubquery {
-            expr: Box::new(Expr::SQLIdentifier("segment".to_string())),
+        Expr::InSubquery {
+            expr: Box::new(Expr::Identifier("segment".to_string())),
             subquery: Box::new(verified_query("SELECT segm FROM bar")),
             negated: false,
         },
@@ -661,10 +656,10 @@ fn parse_between() {
         );
         let select = verified_only_select(sql);
         assert_eq!(
-            Expr::SQLBetween {
-                expr: Box::new(Expr::SQLIdentifier("age".to_string())),
-                low: Box::new(Expr::SQLValue(Value::Long(25))),
-                high: Box::new(Expr::SQLValue(Value::Long(32))),
+            Expr::Between {
+                expr: Box::new(Expr::Identifier("age".to_string())),
+                low: Box::new(Expr::Value(Value::Long(25))),
+                high: Box::new(Expr::Value(Value::Long(32))),
                 negated,
             },
             select.selection.unwrap()
@@ -676,22 +671,21 @@ fn parse_between() {
 
 #[test]
 fn parse_between_with_expr() {
-    use self::Expr::*;
-    use self::SQLBinaryOperator::*;
+    use self::BinaryOperator::*;
     let sql = "SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NULL";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::SQLIsNull(Box::new(Expr::SQLBetween {
-            expr: Box::new(Expr::SQLValue(Value::Long(1))),
-            low: Box::new(SQLBinaryOp {
-                left: Box::new(Expr::SQLValue(Value::Long(1))),
+        Expr::IsNull(Box::new(Expr::Between {
+            expr: Box::new(Expr::Value(Value::Long(1))),
+            low: Box::new(Expr::BinaryOp {
+                left: Box::new(Expr::Value(Value::Long(1))),
                 op: Plus,
-                right: Box::new(Expr::SQLValue(Value::Long(2))),
+                right: Box::new(Expr::Value(Value::Long(2))),
             }),
-            high: Box::new(SQLBinaryOp {
-                left: Box::new(Expr::SQLValue(Value::Long(3))),
+            high: Box::new(Expr::BinaryOp {
+                left: Box::new(Expr::Value(Value::Long(3))),
                 op: Plus,
-                right: Box::new(Expr::SQLValue(Value::Long(4))),
+                right: Box::new(Expr::Value(Value::Long(4))),
             }),
             negated: false,
         })),
@@ -701,21 +695,21 @@ fn parse_between_with_expr() {
     let sql = "SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::SQLBinaryOp {
-            left: Box::new(Expr::SQLBinaryOp {
-                left: Box::new(Expr::SQLValue(Value::Long(1))),
-                op: SQLBinaryOperator::Eq,
-                right: Box::new(Expr::SQLValue(Value::Long(1))),
+        Expr::BinaryOp {
+            left: Box::new(Expr::BinaryOp {
+                left: Box::new(Expr::Value(Value::Long(1))),
+                op: BinaryOperator::Eq,
+                right: Box::new(Expr::Value(Value::Long(1))),
             }),
-            op: SQLBinaryOperator::And,
-            right: Box::new(Expr::SQLBetween {
-                expr: Box::new(Expr::SQLBinaryOp {
-                    left: Box::new(Expr::SQLValue(Value::Long(1))),
-                    op: SQLBinaryOperator::Plus,
-                    right: Box::new(Expr::SQLIdentifier("x".to_string())),
+            op: BinaryOperator::And,
+            right: Box::new(Expr::Between {
+                expr: Box::new(Expr::BinaryOp {
+                    left: Box::new(Expr::Value(Value::Long(1))),
+                    op: BinaryOperator::Plus,
+                    right: Box::new(Expr::Identifier("x".to_string())),
                 }),
-                low: Box::new(Expr::SQLValue(Value::Long(1))),
-                high: Box::new(Expr::SQLValue(Value::Long(2))),
+                low: Box::new(Expr::Value(Value::Long(1))),
+                high: Box::new(Expr::Value(Value::Long(2))),
                 negated: false,
             }),
         },
@@ -729,16 +723,16 @@ fn parse_select_order_by() {
         let select = verified_query(sql);
         assert_eq!(
             vec![
-                SQLOrderByExpr {
-                    expr: Expr::SQLIdentifier("lname".to_string()),
+                OrderByExpr {
+                    expr: Expr::Identifier("lname".to_string()),
                     asc: Some(true),
                 },
-                SQLOrderByExpr {
-                    expr: Expr::SQLIdentifier("fname".to_string()),
+                OrderByExpr {
+                    expr: Expr::Identifier("fname".to_string()),
                     asc: Some(false),
                 },
-                SQLOrderByExpr {
-                    expr: Expr::SQLIdentifier("id".to_string()),
+                OrderByExpr {
+                    expr: Expr::Identifier("id".to_string()),
                     asc: None,
                 },
             ],
@@ -758,18 +752,18 @@ fn parse_select_order_by_limit() {
     let select = verified_query(sql);
     assert_eq!(
         vec![
-            SQLOrderByExpr {
-                expr: Expr::SQLIdentifier("lname".to_string()),
+            OrderByExpr {
+                expr: Expr::Identifier("lname".to_string()),
                 asc: Some(true),
             },
-            SQLOrderByExpr {
-                expr: Expr::SQLIdentifier("fname".to_string()),
+            OrderByExpr {
+                expr: Expr::Identifier("fname".to_string()),
                 asc: Some(false),
             },
         ],
         select.order_by
     );
-    assert_eq!(Some(Expr::SQLValue(Value::Long(2))), select.limit);
+    assert_eq!(Some(Expr::Value(Value::Long(2))), select.limit);
 }
 
 #[test]
@@ -778,8 +772,8 @@ fn parse_select_group_by() {
     let select = verified_only_select(sql);
     assert_eq!(
         vec![
-            Expr::SQLIdentifier("lname".to_string()),
-            Expr::SQLIdentifier("fname".to_string()),
+            Expr::Identifier("lname".to_string()),
+            Expr::Identifier("fname".to_string()),
         ],
         select.group_by
     );
@@ -790,15 +784,15 @@ fn parse_select_having() {
     let sql = "SELECT foo FROM bar GROUP BY foo HAVING COUNT(*) > 1";
     let select = verified_only_select(sql);
     assert_eq!(
-        Some(Expr::SQLBinaryOp {
-            left: Box::new(Expr::SQLFunction(SQLFunction {
-                name: SQLObjectName(vec!["COUNT".to_string()]),
-                args: vec![Expr::SQLWildcard],
+        Some(Expr::BinaryOp {
+            left: Box::new(Expr::Function(Function {
+                name: ObjectName(vec!["COUNT".to_string()]),
+                args: vec![Expr::Wildcard],
                 over: None,
                 distinct: false
             })),
-            op: SQLBinaryOperator::Gt,
-            right: Box::new(Expr::SQLValue(Value::Long(1)))
+            op: BinaryOperator::Gt,
+            right: Box::new(Expr::Value(Value::Long(1)))
         }),
         select.having
     );
@@ -821,9 +815,9 @@ fn parse_cast() {
     let sql = "SELECT CAST(id AS bigint) FROM customer";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLCast {
-            expr: Box::new(Expr::SQLIdentifier("id".to_string())),
-            data_type: SQLType::BigInt
+        &Expr::Cast {
+            expr: Box::new(Expr::Identifier("id".to_string())),
+            data_type: DataType::BigInt
         },
         expr_from_projection(only(&select.projection))
     );
@@ -850,9 +844,9 @@ fn parse_extract() {
     let sql = "SELECT EXTRACT(YEAR FROM d)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLExtract {
+        &Expr::Extract {
             field: SQLDateTimeField::Year,
-            expr: Box::new(Expr::SQLIdentifier("d".to_string())),
+            expr: Box::new(Expr::Identifier("d".to_string())),
         },
         expr_from_projection(only(&select.projection)),
     );
@@ -890,7 +884,7 @@ fn parse_create_table() {
          ref int REFERENCES othertable (a, b))",
     );
     match ast {
-        SQLStatement::SQLCreateTable {
+        Statement::CreateTable {
             name,
             columns,
             constraints,
@@ -903,33 +897,33 @@ fn parse_create_table() {
             assert_eq!(
                 columns,
                 vec![
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "name".into(),
-                        data_type: SQLType::Varchar(Some(100)),
+                        data_type: DataType::Varchar(Some(100)),
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::NotNull
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "lat".into(),
-                        data_type: SQLType::Double,
+                        data_type: DataType::Double,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Null
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "lng".into(),
-                        data_type: SQLType::Double,
+                        data_type: DataType::Double,
                         collation: None,
                         options: vec![],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "constrained".into(),
-                        data_type: SQLType::Int,
+                        data_type: DataType::Int,
                         collation: None,
                         options: vec![
                             ColumnOptionDef {
@@ -954,14 +948,14 @@ fn parse_create_table() {
                             }
                         ],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "ref".into(),
-                        data_type: SQLType::Int,
+                        data_type: DataType::Int,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::ForeignKey {
-                                foreign_table: SQLObjectName(vec!["othertable".into()]),
+                                foreign_table: ObjectName(vec!["othertable".into()]),
                                 referred_columns: vec!["a".into(), "b".into(),],
                             }
                         }]
@@ -985,14 +979,14 @@ fn parse_create_table() {
 fn parse_create_table_with_options() {
     let sql = "CREATE TABLE t (c int) WITH (foo = 'bar', a = 123)";
     match verified_stmt(sql) {
-        SQLStatement::SQLCreateTable { with_options, .. } => {
+        Statement::CreateTable { with_options, .. } => {
             assert_eq!(
                 vec![
-                    SQLOption {
+                    SqlOption {
                         name: "foo".into(),
                         value: Value::SingleQuotedString("bar".into())
                     },
-                    SQLOption {
+                    SqlOption {
                         name: "a".into(),
                         value: Value::Long(123)
                     },
@@ -1026,7 +1020,7 @@ fn parse_create_external_table() {
          STORED AS TEXTFILE LOCATION '/tmp/example.csv'",
     );
     match ast {
-        SQLStatement::SQLCreateTable {
+        Statement::CreateTable {
             name,
             columns,
             constraints,
@@ -1039,27 +1033,27 @@ fn parse_create_external_table() {
             assert_eq!(
                 columns,
                 vec![
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "name".into(),
-                        data_type: SQLType::Varchar(Some(100)),
+                        data_type: DataType::Varchar(Some(100)),
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::NotNull
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "lat".into(),
-                        data_type: SQLType::Double,
+                        data_type: DataType::Double,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::Null
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "lng".into(),
-                        data_type: SQLType::Double,
+                        data_type: DataType::Double,
                         collation: None,
                         options: vec![],
                     },
@@ -1100,7 +1094,7 @@ fn parse_alter_table_constraints() {
 
     fn check_one(constraint_text: &str) {
         match verified_stmt(&format!("ALTER TABLE tab ADD {}", constraint_text)) {
-            SQLStatement::SQLAlterTable {
+            Statement::AlterTable {
                 name,
                 operation: AlterTableOperation::AddConstraint(constraint),
             } => {
@@ -1137,9 +1131,9 @@ fn parse_scalar_function_in_projection() {
     let sql = "SELECT sqrt(id) FROM foo";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLFunction(SQLFunction {
-            name: SQLObjectName(vec!["sqrt".to_string()]),
-            args: vec![Expr::SQLIdentifier("id".to_string())],
+        &Expr::Function(Function {
+            name: ObjectName(vec!["sqrt".to_string()]),
+            args: vec![Expr::Identifier("id".to_string())],
             over: None,
             distinct: false,
         }),
@@ -1160,13 +1154,13 @@ fn parse_window_functions() {
     let select = verified_only_select(sql);
     assert_eq!(4, select.projection.len());
     assert_eq!(
-        &Expr::SQLFunction(SQLFunction {
-            name: SQLObjectName(vec!["row_number".to_string()]),
+        &Expr::Function(Function {
+            name: ObjectName(vec!["row_number".to_string()]),
             args: vec![],
-            over: Some(SQLWindowSpec {
+            over: Some(WindowSpec {
                 partition_by: vec![],
-                order_by: vec![SQLOrderByExpr {
-                    expr: Expr::SQLIdentifier("dt".to_string()),
+                order_by: vec![OrderByExpr {
+                    expr: Expr::Identifier("dt".to_string()),
                     asc: Some(false)
                 }],
                 window_frame: None,
@@ -1190,15 +1184,15 @@ fn parse_literal_string() {
     let select = verified_only_select(sql);
     assert_eq!(3, select.projection.len());
     assert_eq!(
-        &Expr::SQLValue(Value::SingleQuotedString("one".to_string())),
+        &Expr::Value(Value::SingleQuotedString("one".to_string())),
         expr_from_projection(&select.projection[0])
     );
     assert_eq!(
-        &Expr::SQLValue(Value::NationalStringLiteral("national string".to_string())),
+        &Expr::Value(Value::NationalStringLiteral("national string".to_string())),
         expr_from_projection(&select.projection[1])
     );
     assert_eq!(
-        &Expr::SQLValue(Value::HexStringLiteral("deadBEEF".to_string())),
+        &Expr::Value(Value::HexStringLiteral("deadBEEF".to_string())),
         expr_from_projection(&select.projection[2])
     );
 
@@ -1210,7 +1204,7 @@ fn parse_literal_date() {
     let sql = "SELECT DATE '1999-01-01'";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Date("1999-01-01".into())),
+        &Expr::Value(Value::Date("1999-01-01".into())),
         expr_from_projection(only(&select.projection)),
     );
 }
@@ -1220,7 +1214,7 @@ fn parse_literal_time() {
     let sql = "SELECT TIME '01:23:34'";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Time("01:23:34".into())),
+        &Expr::Value(Value::Time("01:23:34".into())),
         expr_from_projection(only(&select.projection)),
     );
 }
@@ -1230,7 +1224,7 @@ fn parse_literal_timestamp() {
     let sql = "SELECT TIMESTAMP '1999-01-01 01:23:34'";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Timestamp("1999-01-01 01:23:34".into())),
+        &Expr::Value(Value::Timestamp("1999-01-01 01:23:34".into())),
         expr_from_projection(only(&select.projection)),
     );
 }
@@ -1240,7 +1234,7 @@ fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '1-1' YEAR TO MONTH";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Interval {
+        &Expr::Value(Value::Interval {
             value: "1-1".into(),
             leading_field: SQLDateTimeField::Year,
             leading_precision: None,
@@ -1253,7 +1247,7 @@ fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '01:01.01' MINUTE (5) TO SECOND (5)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Interval {
+        &Expr::Value(Value::Interval {
             value: "01:01.01".into(),
             leading_field: SQLDateTimeField::Minute,
             leading_precision: Some(5),
@@ -1266,7 +1260,7 @@ fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '1' SECOND (5, 4)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Interval {
+        &Expr::Value(Value::Interval {
             value: "1".into(),
             leading_field: SQLDateTimeField::Second,
             leading_precision: Some(5),
@@ -1279,7 +1273,7 @@ fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '10' HOUR";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Interval {
+        &Expr::Value(Value::Interval {
             value: "10".into(),
             leading_field: SQLDateTimeField::Hour,
             leading_precision: None,
@@ -1292,7 +1286,7 @@ fn parse_literal_interval() {
     let sql = "SELECT INTERVAL '10' HOUR (1)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLValue(Value::Interval {
+        &Expr::Value(Value::Interval {
             value: "10".into(),
             leading_field: SQLDateTimeField::Hour,
             leading_precision: Some(1),
@@ -1365,12 +1359,12 @@ fn parse_delimited_identifiers() {
     // check SELECT
     assert_eq!(3, select.projection.len());
     assert_eq!(
-        &Expr::SQLCompoundIdentifier(vec![r#""alias""#.to_string(), r#""bar baz""#.to_string()]),
+        &Expr::CompoundIdentifier(vec![r#""alias""#.to_string(), r#""bar baz""#.to_string()]),
         expr_from_projection(&select.projection[0]),
     );
     assert_eq!(
-        &Expr::SQLFunction(SQLFunction {
-            name: SQLObjectName(vec![r#""myfun""#.to_string()]),
+        &Expr::Function(Function {
+            name: ObjectName(vec![r#""myfun""#.to_string()]),
             args: vec![],
             over: None,
             distinct: false,
@@ -1378,8 +1372,8 @@ fn parse_delimited_identifiers() {
         expr_from_projection(&select.projection[1]),
     );
     match &select.projection[2] {
-        SQLSelectItem::ExprWithAlias { expr, alias } => {
-            assert_eq!(&Expr::SQLIdentifier(r#""simple id""#.to_string()), expr);
+        SelectItem::ExprWithAlias { expr, alias } => {
+            assert_eq!(&Expr::Identifier(r#""simple id""#.to_string()), expr);
             assert_eq!(r#""column alias""#, alias);
         }
         _ => panic!("Expected ExprWithAlias"),
@@ -1392,21 +1386,21 @@ fn parse_delimited_identifiers() {
 
 #[test]
 fn parse_parens() {
+    use self::BinaryOperator::*;
     use self::Expr::*;
-    use self::SQLBinaryOperator::*;
     let sql = "(a + b) - (c + d)";
     assert_eq!(
-        SQLBinaryOp {
-            left: Box::new(SQLNested(Box::new(SQLBinaryOp {
-                left: Box::new(SQLIdentifier("a".to_string())),
+        BinaryOp {
+            left: Box::new(Nested(Box::new(BinaryOp {
+                left: Box::new(Identifier("a".to_string())),
                 op: Plus,
-                right: Box::new(SQLIdentifier("b".to_string()))
+                right: Box::new(Identifier("b".to_string()))
             }))),
             op: Minus,
-            right: Box::new(SQLNested(Box::new(SQLBinaryOp {
-                left: Box::new(SQLIdentifier("c".to_string())),
+            right: Box::new(Nested(Box::new(BinaryOp {
+                left: Box::new(Identifier("c".to_string())),
                 op: Plus,
-                right: Box::new(SQLIdentifier("d".to_string()))
+                right: Box::new(Identifier("d".to_string()))
             })))
         },
         verified_expr(sql)
@@ -1416,31 +1410,31 @@ fn parse_parens() {
 #[test]
 fn parse_searched_case_expr() {
     let sql = "SELECT CASE WHEN bar IS NULL THEN 'null' WHEN bar = 0 THEN '=0' WHEN bar >= 0 THEN '>=0' ELSE '<0' END FROM foo";
-    use self::Expr::{SQLBinaryOp, SQLCase, SQLIdentifier, SQLIsNull, SQLValue};
-    use self::SQLBinaryOperator::*;
+    use self::BinaryOperator::*;
+    use self::Expr::{BinaryOp, Case, Identifier, IsNull};
     let select = verified_only_select(sql);
     assert_eq!(
-        &SQLCase {
+        &Case {
             operand: None,
             conditions: vec![
-                SQLIsNull(Box::new(SQLIdentifier("bar".to_string()))),
-                SQLBinaryOp {
-                    left: Box::new(SQLIdentifier("bar".to_string())),
+                IsNull(Box::new(Identifier("bar".to_string()))),
+                BinaryOp {
+                    left: Box::new(Identifier("bar".to_string())),
                     op: Eq,
-                    right: Box::new(SQLValue(Value::Long(0)))
+                    right: Box::new(Expr::Value(Value::Long(0)))
                 },
-                SQLBinaryOp {
-                    left: Box::new(SQLIdentifier("bar".to_string())),
+                BinaryOp {
+                    left: Box::new(Identifier("bar".to_string())),
                     op: GtEq,
-                    right: Box::new(SQLValue(Value::Long(0)))
+                    right: Box::new(Expr::Value(Value::Long(0)))
                 }
             ],
             results: vec![
-                SQLValue(Value::SingleQuotedString("null".to_string())),
-                SQLValue(Value::SingleQuotedString("=0".to_string())),
-                SQLValue(Value::SingleQuotedString(">=0".to_string()))
+                Expr::Value(Value::SingleQuotedString("null".to_string())),
+                Expr::Value(Value::SingleQuotedString("=0".to_string())),
+                Expr::Value(Value::SingleQuotedString(">=0".to_string()))
             ],
-            else_result: Some(Box::new(SQLValue(Value::SingleQuotedString(
+            else_result: Some(Box::new(Expr::Value(Value::SingleQuotedString(
                 "<0".to_string()
             ))))
         },
@@ -1453,13 +1447,13 @@ fn parse_simple_case_expr() {
     // ANSI calls a CASE expression with an operand "<simple case>"
     let sql = "SELECT CASE foo WHEN 1 THEN 'Y' ELSE 'N' END";
     let select = verified_only_select(sql);
-    use self::Expr::{SQLCase, SQLIdentifier, SQLValue};
+    use self::Expr::{Case, Identifier};
     assert_eq!(
-        &SQLCase {
-            operand: Some(Box::new(SQLIdentifier("foo".to_string()))),
-            conditions: vec![SQLValue(Value::Long(1))],
-            results: vec![SQLValue(Value::SingleQuotedString("Y".to_string())),],
-            else_result: Some(Box::new(SQLValue(Value::SingleQuotedString(
+        &Case {
+            operand: Some(Box::new(Identifier("foo".to_string()))),
+            conditions: vec![Expr::Value(Value::Long(1))],
+            results: vec![Expr::Value(Value::SingleQuotedString("Y".to_string())),],
+            else_result: Some(Box::new(Expr::Value(Value::SingleQuotedString(
                 "N".to_string()
             ))))
         },
@@ -1481,7 +1475,7 @@ fn parse_implicit_join() {
         vec![
             TableWithJoins {
                 relation: TableFactor::Table {
-                    name: SQLObjectName(vec!["t1".into()]),
+                    name: ObjectName(vec!["t1".into()]),
                     alias: None,
                     args: vec![],
                     with_hints: vec![],
@@ -1490,7 +1484,7 @@ fn parse_implicit_join() {
             },
             TableWithJoins {
                 relation: TableFactor::Table {
-                    name: SQLObjectName(vec!["t2".into()]),
+                    name: ObjectName(vec!["t2".into()]),
                     alias: None,
                     args: vec![],
                     with_hints: vec![],
@@ -1507,14 +1501,14 @@ fn parse_implicit_join() {
         vec![
             TableWithJoins {
                 relation: TableFactor::Table {
-                    name: SQLObjectName(vec!["t1a".into()]),
+                    name: ObjectName(vec!["t1a".into()]),
                     alias: None,
                     args: vec![],
                     with_hints: vec![],
                 },
                 joins: vec![Join {
                     relation: TableFactor::Table {
-                        name: SQLObjectName(vec!["t1b".into()]),
+                        name: ObjectName(vec!["t1b".into()]),
                         alias: None,
                         args: vec![],
                         with_hints: vec![],
@@ -1524,14 +1518,14 @@ fn parse_implicit_join() {
             },
             TableWithJoins {
                 relation: TableFactor::Table {
-                    name: SQLObjectName(vec!["t2a".into()]),
+                    name: ObjectName(vec!["t2a".into()]),
                     alias: None,
                     args: vec![],
                     with_hints: vec![],
                 },
                 joins: vec![Join {
                     relation: TableFactor::Table {
-                        name: SQLObjectName(vec!["t2b".into()]),
+                        name: ObjectName(vec!["t2b".into()]),
                         alias: None,
                         args: vec![],
                         with_hints: vec![],
@@ -1551,7 +1545,7 @@ fn parse_cross_join() {
     assert_eq!(
         Join {
             relation: TableFactor::Table {
-                name: SQLObjectName(vec!["t2".to_string()]),
+                name: ObjectName(vec!["t2".to_string()]),
                 alias: None,
                 args: vec![],
                 with_hints: vec![],
@@ -1578,15 +1572,15 @@ fn parse_joins_on() {
     ) -> Join {
         Join {
             relation: TableFactor::Table {
-                name: SQLObjectName(vec![relation.into()]),
+                name: ObjectName(vec![relation.into()]),
                 alias,
                 args: vec![],
                 with_hints: vec![],
             },
-            join_operator: f(JoinConstraint::On(Expr::SQLBinaryOp {
-                left: Box::new(Expr::SQLIdentifier("c1".into())),
-                op: SQLBinaryOperator::Eq,
-                right: Box::new(Expr::SQLIdentifier("c2".into())),
+            join_operator: f(JoinConstraint::On(Expr::BinaryOp {
+                left: Box::new(Expr::Identifier("c1".into())),
+                op: BinaryOperator::Eq,
+                right: Box::new(Expr::Identifier("c2".into())),
             })),
         }
     }
@@ -1631,7 +1625,7 @@ fn parse_joins_using() {
     ) -> Join {
         Join {
             relation: TableFactor::Table {
-                name: SQLObjectName(vec![relation.into()]),
+                name: ObjectName(vec![relation.into()]),
                 alias,
                 args: vec![],
                 with_hints: vec![],
@@ -1676,7 +1670,7 @@ fn parse_natural_join() {
     fn natural_join(f: impl Fn(JoinConstraint) -> JoinOperator) -> Join {
         Join {
             relation: TableFactor::Table {
-                name: SQLObjectName(vec!["t2".to_string()]),
+                name: ObjectName(vec!["t2".to_string()]),
                 alias: None,
                 args: vec![],
                 with_hints: vec![],
@@ -1718,7 +1712,7 @@ fn parse_complex_join() {
 fn parse_join_nesting() {
     fn table(name: impl Into<String>) -> TableFactor {
         TableFactor::Table {
-            name: SQLObjectName(vec![name.into()]),
+            name: ObjectName(vec![name.into()]),
             alias: None,
             args: vec![],
             with_hints: vec![],
@@ -1813,7 +1807,7 @@ fn parse_ctes() {
         cte_sqls[0], cte_sqls[1]
     );
 
-    fn assert_ctes_in_select(expected: &[&str], sel: &SQLQuery) {
+    fn assert_ctes_in_select(expected: &[&str], sel: &Query) {
         let mut i = 0;
         for exp in expected {
             let Cte { alias, query } = &sel.ctes[i];
@@ -1830,7 +1824,7 @@ fn parse_ctes() {
     let sql = &format!("SELECT ({})", with);
     let select = verified_only_select(sql);
     match expr_from_projection(only(&select.projection)) {
-        Expr::SQLSubquery(ref subquery) => {
+        Expr::Subquery(ref subquery) => {
             assert_ctes_in_select(&cte_sqls, subquery.as_ref());
         }
         _ => panic!("Expected subquery"),
@@ -1847,7 +1841,7 @@ fn parse_ctes() {
     // CTE in a view
     let sql = &format!("CREATE VIEW v AS {}", with);
     match verified_stmt(sql) {
-        SQLStatement::SQLCreateView { query, .. } => assert_ctes_in_select(&cte_sqls, &query),
+        Statement::CreateView { query, .. } => assert_ctes_in_select(&cte_sqls, &query),
         _ => panic!("Expected CREATE VIEW"),
     }
     // CTE in a CTE...
@@ -1902,7 +1896,7 @@ fn parse_derived_tables() {
             },
             joins: vec![Join {
                 relation: TableFactor::Table {
-                    name: SQLObjectName(vec!["t2".into()]),
+                    name: ObjectName(vec!["t2".into()]),
                     alias: None,
                     args: vec![],
                     with_hints: vec![],
@@ -1987,12 +1981,11 @@ fn parse_multiple_statements() {
 
 #[test]
 fn parse_scalar_subqueries() {
-    use self::Expr::*;
     let sql = "(SELECT 1) + (SELECT 2)";
-    assert_matches!(verified_expr(sql), SQLBinaryOp {
-        op: SQLBinaryOperator::Plus, ..
-        //left: box SQLSubquery { .. },
-        //right: box SQLSubquery { .. },
+    assert_matches!(verified_expr(sql), Expr::BinaryOp {
+        op: BinaryOperator::Plus, ..
+        //left: box Subquery { .. },
+        //right: box Subquery { .. },
     });
 }
 
@@ -2002,16 +1995,16 @@ fn parse_exists_subquery() {
     let sql = "SELECT * FROM t WHERE EXISTS (SELECT 1)";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::SQLExists(Box::new(expected_inner.clone())),
+        Expr::Exists(Box::new(expected_inner.clone())),
         select.selection.unwrap(),
     );
 
     let sql = "SELECT * FROM t WHERE NOT EXISTS (SELECT 1)";
     let select = verified_only_select(sql);
     assert_eq!(
-        Expr::SQLUnaryOp {
-            op: SQLUnaryOperator::Not,
-            expr: Box::new(Expr::SQLExists(Box::new(expected_inner))),
+        Expr::UnaryOp {
+            op: UnaryOperator::Not,
+            expr: Box::new(Expr::Exists(Box::new(expected_inner))),
         },
         select.selection.unwrap(),
     );
@@ -2040,7 +2033,7 @@ fn parse_exists_subquery() {
 fn parse_create_view() {
     let sql = "CREATE VIEW myschema.myview AS SELECT foo FROM bar";
     match verified_stmt(sql) {
-        SQLStatement::SQLCreateView {
+        Statement::CreateView {
             name,
             columns,
             query,
@@ -2048,7 +2041,7 @@ fn parse_create_view() {
             with_options,
         } => {
             assert_eq!("myschema.myview", name.to_string());
-            assert_eq!(Vec::<SQLIdent>::new(), columns);
+            assert_eq!(Vec::<Ident>::new(), columns);
             assert_eq!("SELECT foo FROM bar", query.to_string());
             assert!(!materialized);
             assert_eq!(with_options, vec![]);
@@ -2061,14 +2054,14 @@ fn parse_create_view() {
 fn parse_create_view_with_options() {
     let sql = "CREATE VIEW v WITH (foo = 'bar', a = 123) AS SELECT 1";
     match verified_stmt(sql) {
-        SQLStatement::SQLCreateView { with_options, .. } => {
+        Statement::CreateView { with_options, .. } => {
             assert_eq!(
                 vec![
-                    SQLOption {
+                    SqlOption {
                         name: "foo".into(),
                         value: Value::SingleQuotedString("bar".into())
                     },
-                    SQLOption {
+                    SqlOption {
                         name: "a".into(),
                         value: Value::Long(123)
                     },
@@ -2084,7 +2077,7 @@ fn parse_create_view_with_options() {
 fn parse_create_view_with_columns() {
     let sql = "CREATE VIEW v (has, cols) AS SELECT 1, 2";
     match verified_stmt(sql) {
-        SQLStatement::SQLCreateView {
+        Statement::CreateView {
             name,
             columns,
             with_options,
@@ -2105,7 +2098,7 @@ fn parse_create_view_with_columns() {
 fn parse_create_materialized_view() {
     let sql = "CREATE MATERIALIZED VIEW myschema.myview AS SELECT foo FROM bar";
     match verified_stmt(sql) {
-        SQLStatement::SQLCreateView {
+        Statement::CreateView {
             name,
             columns,
             query,
@@ -2113,7 +2106,7 @@ fn parse_create_materialized_view() {
             with_options,
         } => {
             assert_eq!("myschema.myview", name.to_string());
-            assert_eq!(Vec::<SQLIdent>::new(), columns);
+            assert_eq!(Vec::<Ident>::new(), columns);
             assert_eq!("SELECT foo FROM bar", query.to_string());
             assert!(materialized);
             assert_eq!(with_options, vec![]);
@@ -2126,14 +2119,14 @@ fn parse_create_materialized_view() {
 fn parse_drop_table() {
     let sql = "DROP TABLE foo";
     match verified_stmt(sql) {
-        SQLStatement::SQLDrop {
+        Statement::Drop {
             object_type,
             if_exists,
             names,
             cascade,
         } => {
             assert_eq!(false, if_exists);
-            assert_eq!(SQLObjectType::Table, object_type);
+            assert_eq!(ObjectType::Table, object_type);
             assert_eq!(
                 vec!["foo"],
                 names.iter().map(ToString::to_string).collect::<Vec<_>>()
@@ -2145,14 +2138,14 @@ fn parse_drop_table() {
 
     let sql = "DROP TABLE IF EXISTS foo, bar CASCADE";
     match verified_stmt(sql) {
-        SQLStatement::SQLDrop {
+        Statement::Drop {
             object_type,
             if_exists,
             names,
             cascade,
         } => {
             assert_eq!(true, if_exists);
-            assert_eq!(SQLObjectType::Table, object_type);
+            assert_eq!(ObjectType::Table, object_type);
             assert_eq!(
                 vec!["foo", "bar"],
                 names.iter().map(ToString::to_string).collect::<Vec<_>>()
@@ -2179,14 +2172,14 @@ fn parse_drop_table() {
 fn parse_drop_view() {
     let sql = "DROP VIEW myschema.myview";
     match verified_stmt(sql) {
-        SQLStatement::SQLDrop {
+        Statement::Drop {
             names, object_type, ..
         } => {
             assert_eq!(
                 vec!["myschema.myview"],
                 names.iter().map(ToString::to_string).collect::<Vec<_>>()
             );
-            assert_eq!(SQLObjectType::View, object_type);
+            assert_eq!(ObjectType::View, object_type);
         }
         _ => unreachable!(),
     }
@@ -2204,26 +2197,26 @@ fn parse_invalid_subquery_without_parens() {
 #[test]
 fn parse_offset() {
     let ast = verified_query("SELECT foo FROM bar OFFSET 2 ROWS");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     let ast = verified_query("SELECT foo FROM bar WHERE foo = 4 OFFSET 2 ROWS");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     let ast = verified_query("SELECT foo FROM bar ORDER BY baz OFFSET 2 ROWS");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     let ast = verified_query("SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     let ast = verified_query("SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS) OFFSET 2 ROWS");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     match ast.body {
-        SQLSetExpr::Select(s) => match only(s.from).relation {
+        SetExpr::Select(s) => match only(s.from).relation {
             TableFactor::Derived { subquery, .. } => {
-                assert_eq!(subquery.offset, Some(Expr::SQLValue(Value::Long(2))));
+                assert_eq!(subquery.offset, Some(Expr::Value(Value::Long(2))));
             }
             _ => panic!("Test broke"),
         },
         _ => panic!("Test broke"),
     }
     let ast = verified_query("SELECT 'foo' OFFSET 0 ROWS");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(0))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(0))));
 }
 
 #[test]
@@ -2239,7 +2232,7 @@ fn parse_fetch() {
     const FETCH_FIRST_TWO_ROWS_ONLY: Fetch = Fetch {
         with_ties: false,
         percent: false,
-        quantity: Some(Expr::SQLValue(Value::Long(2))),
+        quantity: Some(Expr::Value(Value::Long(2))),
     };
     let ast = verified_query("SELECT foo FROM bar FETCH FIRST 2 ROWS ONLY");
     assert_eq!(ast.fetch, Some(FETCH_FIRST_TWO_ROWS_ONLY));
@@ -2266,7 +2259,7 @@ fn parse_fetch() {
         Some(Fetch {
             with_ties: true,
             percent: false,
-            quantity: Some(Expr::SQLValue(Value::Long(2))),
+            quantity: Some(Expr::Value(Value::Long(2))),
         })
     );
     let ast = verified_query("SELECT foo FROM bar FETCH FIRST 50 PERCENT ROWS ONLY");
@@ -2275,20 +2268,20 @@ fn parse_fetch() {
         Some(Fetch {
             with_ties: false,
             percent: true,
-            quantity: Some(Expr::SQLValue(Value::Long(50))),
+            quantity: Some(Expr::Value(Value::Long(50))),
         })
     );
     let ast = verified_query(
         "SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY",
     );
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     assert_eq!(ast.fetch, Some(FETCH_FIRST_TWO_ROWS_ONLY));
     let ast = verified_query(
         "SELECT foo FROM (SELECT * FROM bar FETCH FIRST 2 ROWS ONLY) FETCH FIRST 2 ROWS ONLY",
     );
     assert_eq!(ast.fetch, Some(FETCH_FIRST_TWO_ROWS_ONLY));
     match ast.body {
-        SQLSetExpr::Select(s) => match only(s.from).relation {
+        SetExpr::Select(s) => match only(s.from).relation {
             TableFactor::Derived { subquery, .. } => {
                 assert_eq!(subquery.fetch, Some(FETCH_FIRST_TWO_ROWS_ONLY));
             }
@@ -2297,12 +2290,12 @@ fn parse_fetch() {
         _ => panic!("Test broke"),
     }
     let ast = verified_query("SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY) OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY");
-    assert_eq!(ast.offset, Some(Expr::SQLValue(Value::Long(2))));
+    assert_eq!(ast.offset, Some(Expr::Value(Value::Long(2))));
     assert_eq!(ast.fetch, Some(FETCH_FIRST_TWO_ROWS_ONLY));
     match ast.body {
-        SQLSetExpr::Select(s) => match only(s.from).relation {
+        SetExpr::Select(s) => match only(s.from).relation {
             TableFactor::Derived { subquery, .. } => {
-                assert_eq!(subquery.offset, Some(Expr::SQLValue(Value::Long(2))));
+                assert_eq!(subquery.offset, Some(Expr::Value(Value::Long(2))));
                 assert_eq!(subquery.fetch, Some(FETCH_FIRST_TWO_ROWS_ONLY));
             }
             _ => panic!("Test broke"),
@@ -2350,7 +2343,7 @@ fn lateral_derived() {
         let join = &from.joins[0];
         assert_eq!(
             join.join_operator,
-            JoinOperator::LeftOuter(JoinConstraint::On(Expr::SQLValue(Value::Boolean(true))))
+            JoinOperator::LeftOuter(JoinConstraint::On(Expr::Value(Value::Boolean(true))))
         );
         if let TableFactor::Derived {
             lateral,
@@ -2393,7 +2386,7 @@ fn lateral_derived() {
 #[test]
 fn parse_start_transaction() {
     match verified_stmt("START TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE") {
-        SQLStatement::SQLStartTransaction { modes } => assert_eq!(
+        Statement::StartTransaction { modes } => assert_eq!(
             modes,
             vec![
                 TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
@@ -2410,7 +2403,7 @@ fn parse_start_transaction() {
         "START TRANSACTION READ ONLY READ WRITE ISOLATION LEVEL SERIALIZABLE",
         "START TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE",
     ) {
-        SQLStatement::SQLStartTransaction { modes } => assert_eq!(
+        Statement::StartTransaction { modes } => assert_eq!(
             modes,
             vec![
                 TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
@@ -2456,7 +2449,7 @@ fn parse_set_transaction() {
     // TRANSACTION, so no need to duplicate the tests here. We just do a quick
     // sanity check.
     match verified_stmt("SET TRANSACTION READ ONLY, READ WRITE, ISOLATION LEVEL SERIALIZABLE") {
-        SQLStatement::SQLSetTransaction { modes } => assert_eq!(
+        Statement::SetTransaction { modes } => assert_eq!(
             modes,
             vec![
                 TransactionMode::AccessMode(TransactionAccessMode::ReadOnly),
@@ -2471,12 +2464,12 @@ fn parse_set_transaction() {
 #[test]
 fn parse_commit() {
     match verified_stmt("COMMIT") {
-        SQLStatement::SQLCommit { chain: false } => (),
+        Statement::Commit { chain: false } => (),
         _ => unreachable!(),
     }
 
     match verified_stmt("COMMIT AND CHAIN") {
-        SQLStatement::SQLCommit { chain: true } => (),
+        Statement::Commit { chain: true } => (),
         _ => unreachable!(),
     }
 
@@ -2492,12 +2485,12 @@ fn parse_commit() {
 #[test]
 fn parse_rollback() {
     match verified_stmt("ROLLBACK") {
-        SQLStatement::SQLRollback { chain: false } => (),
+        Statement::Rollback { chain: false } => (),
         _ => unreachable!(),
     }
 
     match verified_stmt("ROLLBACK AND CHAIN") {
-        SQLStatement::SQLRollback { chain: true } => (),
+        Statement::Rollback { chain: true } => (),
         _ => unreachable!(),
     }
 
@@ -2511,9 +2504,7 @@ fn parse_rollback() {
 }
 
 #[test]
-#[should_panic(
-    expected = "Parse results with GenericSqlDialect are different from PostgreSqlDialect"
-)]
+#[should_panic(expected = "Parse results with GenericDialect are different from PostgreSqlDialect")]
 fn ensure_multiple_dialects_are_tested() {
     // The SQL here must be parsed differently by different dialects.
     // At the time of writing, `@foo` is accepted as a valid identifier
@@ -2521,23 +2512,23 @@ fn ensure_multiple_dialects_are_tested() {
     let _ = parse_sql_statements("SELECT @foo");
 }
 
-fn parse_sql_statements(sql: &str) -> Result<Vec<SQLStatement>, ParserError> {
+fn parse_sql_statements(sql: &str) -> Result<Vec<Statement>, ParserError> {
     all_dialects().parse_sql_statements(sql)
 }
 
-fn one_statement_parses_to(sql: &str, canonical: &str) -> SQLStatement {
+fn one_statement_parses_to(sql: &str, canonical: &str) -> Statement {
     all_dialects().one_statement_parses_to(sql, canonical)
 }
 
-fn verified_stmt(query: &str) -> SQLStatement {
+fn verified_stmt(query: &str) -> Statement {
     all_dialects().verified_stmt(query)
 }
 
-fn verified_query(query: &str) -> SQLQuery {
+fn verified_query(query: &str) -> Query {
     all_dialects().verified_query(query)
 }
 
-fn verified_only_select(query: &str) -> SQLSelect {
+fn verified_only_select(query: &str) -> Select {
     all_dialects().verified_only_select(query)
 }
 
diff --git a/tests/sqlparser_mssql.rs b/tests/sqlparser_mssql.rs
index 5f878b714..9825e66fe 100644
--- a/tests/sqlparser_mssql.rs
+++ b/tests/sqlparser_mssql.rs
@@ -14,8 +14,8 @@
 //! Test SQL syntax specific to Microsoft's T-SQL. The parser based on the
 //! generic dialect is also tested (on the inputs it can handle).
 
-use sqlparser::dialect::{GenericSqlDialect, MsSqlDialect};
-use sqlparser::sqlast::*;
+use sqlparser::ast::*;
+use sqlparser::dialect::{GenericDialect, MsSqlDialect};
 use sqlparser::test_utils::*;
 
 #[test]
@@ -23,11 +23,11 @@ fn parse_mssql_identifiers() {
     let sql = "SELECT @@version, _foo$123 FROM ##temp";
     let select = ms_and_generic().verified_only_select(sql);
     assert_eq!(
-        &Expr::SQLIdentifier("@@version".to_string()),
+        &Expr::Identifier("@@version".to_string()),
         expr_from_projection(&select.projection[0]),
     );
     assert_eq!(
-        &Expr::SQLIdentifier("_foo$123".to_string()),
+        &Expr::Identifier("_foo$123".to_string()),
         expr_from_projection(&select.projection[1]),
     );
     assert_eq!(2, select.projection.len());
@@ -75,6 +75,6 @@ fn ms() -> TestedDialects {
 }
 fn ms_and_generic() -> TestedDialects {
     TestedDialects {
-        dialects: vec![Box::new(MsSqlDialect {}), Box::new(GenericSqlDialect {})],
+        dialects: vec![Box::new(MsSqlDialect {}), Box::new(GenericDialect {})],
     }
 }
diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs
index a772f3c0d..42f6519d5 100644
--- a/tests/sqlparser_postgres.rs
+++ b/tests/sqlparser_postgres.rs
@@ -14,8 +14,8 @@
 //! Test SQL syntax specific to PostgreSQL. The parser based on the
 //! generic dialect is also tested (on the inputs it can handle).
 
-use sqlparser::dialect::{GenericSqlDialect, PostgreSqlDialect};
-use sqlparser::sqlast::*;
+use sqlparser::ast::*;
+use sqlparser::dialect::{GenericDialect, PostgreSqlDialect};
 use sqlparser::test_utils::*;
 
 #[test]
@@ -33,7 +33,7 @@ fn parse_create_table_with_defaults() {
             active integer NOT NULL
     ) WITH (fillfactor = 20, user_catalog_table = true, autovacuum_vacuum_threshold = 100)";
     match pg_and_generic().one_statement_parses_to(sql, "") {
-        SQLStatement::SQLCreateTable {
+        Statement::CreateTable {
             name,
             columns,
             constraints,
@@ -46,9 +46,9 @@ fn parse_create_table_with_defaults() {
             assert_eq!(
                 columns,
                 vec![
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "customer_id".into(),
-                        data_type: SQLType::Int,
+                        data_type: DataType::Int,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
@@ -57,56 +57,56 @@ fn parse_create_table_with_defaults() {
                             )
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "store_id".into(),
-                        data_type: SQLType::SmallInt,
+                        data_type: DataType::SmallInt,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::NotNull,
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "first_name".into(),
-                        data_type: SQLType::Varchar(Some(45)),
+                        data_type: DataType::Varchar(Some(45)),
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::NotNull,
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "last_name".into(),
-                        data_type: SQLType::Varchar(Some(45)),
-                        collation: Some(SQLObjectName(vec!["\"es_ES\"".into()])),
+                        data_type: DataType::Varchar(Some(45)),
+                        collation: Some(ObjectName(vec!["\"es_ES\"".into()])),
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::NotNull,
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "email".into(),
-                        data_type: SQLType::Varchar(Some(50)),
+                        data_type: DataType::Varchar(Some(50)),
                         collation: None,
                         options: vec![],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "address_id".into(),
-                        data_type: SQLType::SmallInt,
+                        data_type: DataType::SmallInt,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
                             option: ColumnOption::NotNull
                         }],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "activebool".into(),
-                        data_type: SQLType::Boolean,
+                        data_type: DataType::Boolean,
                         collation: None,
                         options: vec![
                             ColumnOptionDef {
                                 name: None,
-                                option: ColumnOption::Default(Expr::SQLValue(Value::Boolean(true))),
+                                option: ColumnOption::Default(Expr::Value(Value::Boolean(true))),
                             },
                             ColumnOptionDef {
                                 name: None,
@@ -114,9 +114,9 @@ fn parse_create_table_with_defaults() {
                             }
                         ],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "create_date".into(),
-                        data_type: SQLType::Date,
+                        data_type: DataType::Date,
                         collation: None,
                         options: vec![
                             ColumnOptionDef {
@@ -131,9 +131,9 @@ fn parse_create_table_with_defaults() {
                             }
                         ],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "last_update".into(),
-                        data_type: SQLType::Timestamp,
+                        data_type: DataType::Timestamp,
                         collation: None,
                         options: vec![
                             ColumnOptionDef {
@@ -146,9 +146,9 @@ fn parse_create_table_with_defaults() {
                             }
                         ],
                     },
-                    SQLColumnDef {
+                    ColumnDef {
                         name: "active".into(),
-                        data_type: SQLType::Int,
+                        data_type: DataType::Int,
                         collation: None,
                         options: vec![ColumnOptionDef {
                             name: None,
@@ -161,15 +161,15 @@ fn parse_create_table_with_defaults() {
             assert_eq!(
                 with_options,
                 vec![
-                    SQLOption {
+                    SqlOption {
                         name: "fillfactor".into(),
                         value: Value::Long(20)
                     },
-                    SQLOption {
+                    SqlOption {
                         name: "user_catalog_table".into(),
                         value: Value::Boolean(true)
                     },
-                    SQLOption {
+                    SqlOption {
                         name: "autovacuum_vacuum_threshold".into(),
                         value: Value::Long(100)
                     },
@@ -259,9 +259,6 @@ fn pg() -> TestedDialects {
 
 fn pg_and_generic() -> TestedDialects {
     TestedDialects {
-        dialects: vec![
-            Box::new(PostgreSqlDialect {}),
-            Box::new(GenericSqlDialect {}),
-        ],
+        dialects: vec![Box::new(PostgreSqlDialect {}), Box::new(GenericDialect {})],
     }
 }