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 }