github.com/walf443/mgr@v0.0.0-20150203144449-6f7a3a548462/sqlparser/mysql/ast.go (about)

     1  package mysql
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  )
     7  
     8  type (
     9  	Statement interface {
    10  		statement()
    11  		ToQuery() string
    12  	}
    13  
    14  	Identifier interface {
    15  		identifier()
    16  	}
    17  
    18  	AlterSpecification interface {
    19  		alterspecification()
    20  		ToQuery() string
    21  	}
    22  
    23  	ColumnDefinition struct {
    24  		DataTypeDefinition DataTypeDefinition
    25  		Nullable           bool
    26  		AutoIncrement      bool
    27  		Default            DefaultDefinition
    28  	}
    29  
    30  	DataTypeDefinition interface {
    31  		data_type_definition()
    32  		ToQuery() string
    33  	}
    34  
    35  	CreateDefinition interface {
    36  		create_definition()
    37  		ToQuery() string
    38  	}
    39  
    40  	DefaultDefinition interface {
    41  		default_definition()
    42  		ToQuery() string
    43  	}
    44  )
    45  
    46  type (
    47  	DropTableStatement struct {
    48  		TableNames []TableNameIdentifier
    49  	}
    50  	DropDatabaseStatement struct {
    51  		DatabaseName DatabaseNameIdentifier
    52  	}
    53  	CreateDatabaseStatement struct {
    54  		DatabaseName DatabaseNameIdentifier
    55  	}
    56  	AlterTableStatement struct {
    57  		TableName           TableNameIdentifier
    58  		AlterSpecifications []AlterSpecification
    59  	}
    60  
    61  	CreateTableStatement struct {
    62  		TableName         TableNameIdentifier
    63  		CreateDefinitions []CreateDefinition
    64  		TableOptions      []TableOption
    65  	}
    66  
    67  	CommentStatement struct {
    68  		Content string
    69  	}
    70  )
    71  
    72  func (x *DropTableStatement) statement() {}
    73  func (x *DropTableStatement) ToQuery() string {
    74  	var tableNames []string
    75  	for _, table := range x.TableNames {
    76  		tableNames = append(tableNames, table.ToQuery())
    77  	}
    78  	return "DROP TABLE " + strings.Join(tableNames, ", ") + ";"
    79  }
    80  
    81  func (x *DropDatabaseStatement) statement() {}
    82  func (x *DropDatabaseStatement) ToQuery() string {
    83  	return "DROP DATABASE " + x.DatabaseName.ToQuery() + ";"
    84  }
    85  func (x *CreateDatabaseStatement) statement() {}
    86  func (x *CreateDatabaseStatement) ToQuery() string {
    87  	return "CREATE DATABASE " + x.DatabaseName.ToQuery() + ";"
    88  }
    89  
    90  func (x *AlterTableStatement) statement() {}
    91  func (x *AlterTableStatement) ToQuery() string {
    92  	var specQueries []string
    93  	for _, spec := range x.AlterSpecifications {
    94  		specQueries = append(specQueries, spec.ToQuery())
    95  	}
    96  	return "ALTER TABLE " + x.TableName.ToQuery() + " " + strings.Join(specQueries, ", ") + ";"
    97  }
    98  func (x *CreateTableStatement) statement() {}
    99  func (x *CreateTableStatement) ToQuery() string {
   100  	var options []string
   101  	for _, option := range x.TableOptions {
   102  		options = append(options, option.ToQuery())
   103  	}
   104  	var defs []string
   105  	for _, def := range x.CreateDefinitions {
   106  		defs = append(defs, def.ToQuery())
   107  	}
   108  	return "CREATE TABLE " + x.TableName.ToQuery() + " (\n\t" + strings.Join(defs, ",\n\t") + "\n) " + strings.Join(options, " ") + ";"
   109  }
   110  func (x *CommentStatement) statement() {}
   111  func (x *CommentStatement) ToQuery() string {
   112  	return "TODO"
   113  }
   114  
   115  type (
   116  	TableNameIdentifier struct {
   117  		Name     string
   118  		Database string
   119  	}
   120  	DatabaseNameIdentifier struct {
   121  		Name string
   122  	}
   123  	ColumnNameIdentifier struct {
   124  		Name string
   125  	}
   126  	IndexNameIdentifier struct {
   127  		Name string
   128  	}
   129  
   130  	EngineNameIdentifier struct {
   131  		Name string
   132  	}
   133  )
   134  
   135  func (x *TableNameIdentifier) identifier() {}
   136  
   137  func (x *TableNameIdentifier) ToQuery() string {
   138  	if x.Database == "" {
   139  		return "`" + x.Name + "`"
   140  	} else {
   141  		return fmt.Sprintf("`%s`.`%s`", x.Database, x.Name)
   142  	}
   143  }
   144  
   145  func (x *DatabaseNameIdentifier) identifier() {}
   146  func (x *DatabaseNameIdentifier) ToQuery() string {
   147  	return "`" + x.Name + "`"
   148  }
   149  func (x *ColumnNameIdentifier) identifier() {}
   150  func (x *ColumnNameIdentifier) ToQuery() string {
   151  	return "`" + x.Name + "`"
   152  }
   153  
   154  func (x *IndexNameIdentifier) identifier() {}
   155  func (x *IndexNameIdentifier) ToQuery() string {
   156  	return "`" + x.Name + "`"
   157  }
   158  
   159  type (
   160  	AlterSpecificationDropColumn struct {
   161  		ColumnName ColumnNameIdentifier
   162  	}
   163  	AlterSpecificationDropIndex struct {
   164  		Name IndexNameIdentifier
   165  	}
   166  	AlterSpecificationAddColumn struct {
   167  		ColumnName       ColumnNameIdentifier
   168  		ColumnDefinition ColumnDefinition
   169  	}
   170  	AlterSpecificationAddIndex struct {
   171  		Name    IndexNameIdentifier
   172  		Columns []ColumnNameIdentifier
   173  		Unique  bool
   174  	}
   175  )
   176  
   177  func (x *AlterSpecificationDropColumn) alterspecification() {}
   178  func (x *AlterSpecificationDropColumn) ToQuery() string {
   179  	return "DROP " + x.ColumnName.ToQuery()
   180  }
   181  
   182  func (x *AlterSpecificationDropIndex) alterspecification() {}
   183  func (x *AlterSpecificationDropIndex) ToQuery() string {
   184  	return "DROP INDEX " + x.Name.ToQuery()
   185  }
   186  func (x *AlterSpecificationAddColumn) alterspecification() {}
   187  func (x *AlterSpecificationAddColumn) ToQuery() string {
   188  	return "ADD " + x.ColumnName.ToQuery() + " " + x.ColumnDefinition.ToQuery()
   189  }
   190  
   191  func (x *AlterSpecificationAddIndex) alterspecification() {}
   192  func (x *AlterSpecificationAddIndex) ToQuery() string {
   193  	result := "ADD "
   194  	if x.Unique {
   195  		result = result + "UNIQUE "
   196  	}
   197  	result = result + "INDEX "
   198  	if x.Name.Name != "" {
   199  		result = result + x.Name.ToQuery() + " "
   200  	}
   201  	var columnNames []string
   202  	for _, col := range x.Columns {
   203  		columnNames = append(columnNames, col.ToQuery())
   204  	}
   205  	result = result + "(" + strings.Join(columnNames, ", ") + ")"
   206  	return result
   207  }
   208  
   209  func (x ColumnDefinition) ToQuery() string {
   210  	result := ""
   211  	result += x.DataTypeDefinition.ToQuery()
   212  	if !x.Nullable {
   213  		result += " NOT NULL"
   214  	}
   215  	if x.AutoIncrement {
   216  		result += " AUTO_INCREMENT"
   217  	}
   218  	result += " " + x.Default.ToQuery()
   219  
   220  	return result
   221  }
   222  
   223  type (
   224  	DataTypeDefinitionSimple struct {
   225  		Type DataType
   226  	}
   227  	DataTypeDefinitionNumber struct {
   228  		Type     DataType
   229  		Length   uint
   230  		Unsigned bool
   231  		Zerofill bool
   232  	}
   233  	DataTypeDefinitionFraction struct {
   234  		Type     DataType
   235  		Length   uint
   236  		Decimals uint
   237  		Unsigned bool
   238  		Zerofill bool
   239  	}
   240  	DataTypeDefinitionString struct {
   241  		Type          DataType
   242  		Length        uint
   243  		CharsetName   string
   244  		CollationName string
   245  	}
   246  	DataTypeDefinitionTextBlob struct {
   247  		Type          DataType
   248  		Binary        bool
   249  		CharsetName   string
   250  		CollationName string
   251  	}
   252  )
   253  
   254  func (x *DataTypeDefinitionSimple) data_type_definition() {}
   255  func (x *DataTypeDefinitionSimple) ToQuery() string {
   256  	return x.Type.String()
   257  }
   258  func (x *DataTypeDefinitionNumber) data_type_definition() {}
   259  func (x *DataTypeDefinitionNumber) ToQuery() string {
   260  	result := x.Type.String()
   261  	if x.Length != 0 {
   262  		result += fmt.Sprintf("(%d)", x.Length)
   263  	}
   264  	if x.Unsigned {
   265  		result += " UNSIGNED"
   266  	}
   267  	if x.Zerofill {
   268  		result += " ZEROFILL"
   269  	}
   270  	return result
   271  }
   272  
   273  func (x *DataTypeDefinitionFraction) data_type_definition() {}
   274  func (x *DataTypeDefinitionFraction) ToQuery() string {
   275  	result := x.Type.String()
   276  	if x.Decimals == 0 {
   277  		if x.Length != 0 {
   278  			result += fmt.Sprintf("(%d)", x.Length)
   279  		}
   280  	} else {
   281  		result += fmt.Sprintf("(%d, %d)", x.Length, x.Decimals)
   282  	}
   283  	if x.Unsigned {
   284  		result += " UNSIGNED"
   285  	}
   286  	if x.Zerofill {
   287  		result += " ZEROFILL"
   288  	}
   289  	return result
   290  }
   291  func (x *DataTypeDefinitionString) data_type_definition() {}
   292  func (x *DataTypeDefinitionString) ToQuery() string {
   293  	result := x.Type.String()
   294  	if x.Length > 0 {
   295  		result += fmt.Sprintf("(%d)", x.Length)
   296  	}
   297  	if x.CharsetName != "" {
   298  		result += fmt.Sprintf(" CHARACTER SET %s", x.CharsetName)
   299  	}
   300  	if x.CollationName != "" {
   301  		result += fmt.Sprintf(" COLLATE %s", x.CollationName)
   302  	}
   303  	return result
   304  }
   305  
   306  func (x *DataTypeDefinitionTextBlob) data_type_definition() {}
   307  func (x *DataTypeDefinitionTextBlob) ToQuery() string {
   308  	result := x.Type.String()
   309  	if x.Binary {
   310  		result += " BINARY"
   311  	}
   312  	if x.CharsetName != "" {
   313  		result += fmt.Sprintf(" CHARACTER SET %s", x.CharsetName)
   314  	}
   315  	if x.CollationName != "" {
   316  		result += fmt.Sprintf(" COLLATE %s", x.CollationName)
   317  	}
   318  	return result
   319  }
   320  
   321  type (
   322  	CreateDefinitionColumn struct {
   323  		ColumnName       ColumnNameIdentifier
   324  		ColumnDefinition ColumnDefinition
   325  	}
   326  	CreateDefinitionPrimaryIndex struct {
   327  		Columns []ColumnNameIdentifier
   328  	}
   329  
   330  	CreateDefinitionUniqueIndex struct {
   331  		Name    IndexNameIdentifier
   332  		Columns []ColumnNameIdentifier
   333  	}
   334  	CreateDefinitionIndex struct {
   335  		Name    IndexNameIdentifier
   336  		Columns []ColumnNameIdentifier
   337  	}
   338  )
   339  
   340  func (x *CreateDefinitionColumn) create_definition() {}
   341  func (x *CreateDefinitionColumn) ToQuery() string {
   342  	return x.ColumnName.ToQuery() + " " + x.ColumnDefinition.ToQuery()
   343  }
   344  func (x *CreateDefinitionPrimaryIndex) create_definition() {}
   345  func (x *CreateDefinitionPrimaryIndex) ToQuery() string {
   346  	var columns []string
   347  	for _, column := range x.Columns {
   348  		columns = append(columns, column.ToQuery())
   349  	}
   350  	return "PRIMARY KEY ( " + strings.Join(columns, ",") + " )"
   351  }
   352  func (x *CreateDefinitionUniqueIndex) create_definition() {}
   353  func (x *CreateDefinitionUniqueIndex) ToQuery() string {
   354  	var columns []string
   355  	for _, column := range x.Columns {
   356  		columns = append(columns, column.ToQuery())
   357  	}
   358  	name := ""
   359  	if x.Name.Name != "" {
   360  		name = x.Name.ToQuery()
   361  	}
   362  	return "UNIQUE KEY " + name + " ( " + strings.Join(columns, ",") + " )"
   363  }
   364  func (x *CreateDefinitionIndex) create_definition() {}
   365  func (x *CreateDefinitionIndex) ToQuery() string {
   366  	var columns []string
   367  	for _, column := range x.Columns {
   368  		columns = append(columns, column.ToQuery())
   369  	}
   370  	name := ""
   371  	if x.Name.Name != "" {
   372  		name = x.Name.ToQuery()
   373  	}
   374  	return "INDEX " + name + " ( " + strings.Join(columns, ",") + " )"
   375  }
   376  
   377  type (
   378  	DefaultDefinitionString struct {
   379  		Value string
   380  	}
   381  
   382  	DefaultDefinitionEmpty struct {
   383  	}
   384  
   385  	DefaultDefinitionNull struct {
   386  	}
   387  
   388  	DefaultDefinitionCurrentTimestamp struct {
   389  		OnUpdate bool
   390  	}
   391  )
   392  
   393  func (x *DefaultDefinitionEmpty) default_definition() {}
   394  func (x *DefaultDefinitionEmpty) ToQuery() string {
   395  	return ""
   396  }
   397  func (x *DefaultDefinitionNull) default_definition() {}
   398  func (x *DefaultDefinitionNull) ToQuery() string {
   399  	return "DEFAULT NULL"
   400  }
   401  func (x *DefaultDefinitionString) default_definition() {}
   402  func (x *DefaultDefinitionString) ToQuery() string {
   403  	return "DEFAULT \"" + x.Value + "\""
   404  }
   405  func (x *DefaultDefinitionCurrentTimestamp) default_definition() {}
   406  func (x *DefaultDefinitionCurrentTimestamp) ToQuery() string {
   407  	if x.OnUpdate {
   408  		return "DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"
   409  	} else {
   410  		return "DEFAULT CURRENT_TIMESTAMP"
   411  	}
   412  }
   413  
   414  type TableOption struct {
   415  	Key   string
   416  	Value string
   417  }
   418  
   419  func (x *TableOption) ToQuery() string {
   420  	switch x.Key {
   421  	case "COMMENT":
   422  		return x.Key + " " + "\"" + x.Value + "\""
   423  	default:
   424  		return x.Key + "=" + x.Value
   425  	}
   426  }