├── db_create.sh ├── screenshot.png ├── db_create.sql ├── todo.md ├── .gitignore ├── log.txt ├── helpers ├── common.go ├── db.go ├── xml.go ├── file.go └── export.go ├── LICENSE ├── README.md ├── structures ├── operation_status │ ├── operation_status.go │ └── operation_status_bulk.go ├── center_status │ ├── center_status.go │ └── center_status_bulk.go ├── normative_document_type │ ├── normative_document_type.go │ └── normative_document_type_bulk.go ├── current_status │ ├── current_status.go │ └── current_status_bulk.go ├── interval_status │ ├── interval_status.go │ └── interval_status_bulk.go ├── house_state_status │ ├── house_state_status.go │ └── house_state_status_bulk.go ├── estate_status │ ├── estate_status.go │ └── estate_status_bulk.go ├── structure_status │ ├── structure_status.go │ └── structure_status_bulk.go ├── address_object_type │ ├── address_object_type.go │ └── address_object_type_bulk.go ├── actual_status │ ├── actual_status.go │ └── actual_status_bulk.go ├── normative_document │ ├── normative_document_bulk.go │ └── normative_document.go ├── landmark │ ├── landmark_bulk.go │ └── landmark.go ├── house_interval │ ├── house_interval_bulk.go │ └── house_interval.go ├── house │ ├── house_bulk.go │ └── house.go └── address_object │ ├── address_object.go │ └── address_object_bulk.go └── main.go /db_create.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | #psql -U postgres -f db_create.sql 3 | psql -f db_create.sql 4 | -------------------------------------------------------------------------------- /screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/region23/fias_xml2postgresql/HEAD/screenshot.png -------------------------------------------------------------------------------- /db_create.sql: -------------------------------------------------------------------------------- 1 | DROP DATABASE IF EXISTS fias; 2 | DROP ROLE IF EXISTS dev; 3 | 4 | CREATE DATABASE fias; 5 | CREATE USER dev WITH password 'dev'; 6 | GRANT ALL privileges ON DATABASE fias TO dev; 7 | -------------------------------------------------------------------------------- /todo.md: -------------------------------------------------------------------------------- 1 | ### Сделано: 2 | 3 | ### Сделать: 4 | * Сделать обработку таблиц многопоточной 5 | * Вариант экспорта либо из XML, либо из DBF 6 | * Добавить возможность автоматического скачивания архива с сайта ФИАС, распаковки и экспорта 7 | * Добавить возможность автоматической проверки обновлений базы и автоматической установки, если требуется 8 | * Проставить в схемах таблиц индексные поля 9 | * Написать Makefile для автоматического создания таблицы fias и пользователя, для работы с ней 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files, Static and Dynamic libs (Shared Objects) 2 | *.o 3 | *.a 4 | *.so 5 | main 6 | fias_xml2postgresql 7 | 8 | # Folders 9 | _obj 10 | _test 11 | xml 12 | dbf 13 | xml_full 14 | xml_delta 15 | 16 | # Architecture specific extensions/prefixes 17 | *.[568vq] 18 | [568vq].out 19 | 20 | *.cgo1.go 21 | *.cgo2.c 22 | _cgo_defun.c 23 | _cgo_gotypes.go 24 | _cgo_export.* 25 | 26 | _testmain.go 27 | 28 | *.exe 29 | *.test 30 | *.prof 31 | *.pdf 32 | 33 | *.DS_Store 34 | *.xml 35 | *.DBF 36 | *.DBT 37 | 38 | log.txt 39 | -------------------------------------------------------------------------------- /log.txt: -------------------------------------------------------------------------------- 1 | FATAL: 2015/08/07 15:30:23 main.go:284: Попали в done 2 | FATAL: 2015/08/07 15:30:23 main.go:332: Все горутины завершились 3 | FATAL: 2015/08/07 15:44:24 main.go:284: Попали в done 4 | FATAL: 2015/08/07 15:44:24 main.go:332: Все горутины завершились 5 | FATAL: 2015/08/07 16:01:08 main.go:338: Все горутины завершились 6 | FATAL: 2015/08/07 16:01:08 main.go:290: Попали в done 7 | FATAL: 2015/08/07 16:04:06 main.go:289: Попали в done 8 | FATAL: 2015/08/07 16:04:06 main.go:337: Все горутины завершились 9 | FATAL: 2015/08/08 17:39:43 main.go:337: Все горутины завершились 10 | FATAL: 2015/08/08 17:39:43 main.go:289: Попали в done 11 | -------------------------------------------------------------------------------- /helpers/common.go: -------------------------------------------------------------------------------- 1 | package helpers 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | "strconv" 7 | ) 8 | 9 | func concat(values ...string) string { 10 | var buffer bytes.Buffer 11 | for _, s := range values { 12 | buffer.WriteString(s) 13 | } 14 | return buffer.String() 15 | } 16 | 17 | func humanizeInt(n int) string { 18 | var pretty string 19 | 20 | ns := strconv.Itoa(n) 21 | nsl := len(ns) 22 | 23 | for i := nsl; i > 0; i-- { 24 | if (nsl-i)%3 == 0 { 25 | pretty = concat(" ", pretty) 26 | } 27 | pretty = concat(string(ns[i-1]), pretty) 28 | } 29 | 30 | return pretty 31 | } 32 | 33 | func PrintRowsAffected(elementName string, currentRow int) string { 34 | return fmt.Sprintf("Таблица %s. Обработано %s строк.", elementName, humanizeInt(currentRow)) 35 | } 36 | -------------------------------------------------------------------------------- /helpers/db.go: -------------------------------------------------------------------------------- 1 | package helpers 2 | 3 | import "github.com/jmoiron/sqlx" 4 | 5 | // DropAndCreateTable удаляет таблицу, если она уже существует и создает заново 6 | func DropAndCreateTable(schema string, tableName string, db *sqlx.DB) (bool, error) { 7 | var err error 8 | var rows *sqlx.Rows 9 | // Проверяем нет ли такой таблицы в базе 10 | rows, err = db.Queryx("SELECT to_regclass('" + tableName + "');") 11 | if err != nil { 12 | //fmt.Println("Error on check table '"+tableName+"':", err) 13 | return false, err 14 | } 15 | defer rows.Close() 16 | 17 | // И если есть удаляем 18 | rowsCount := 0 19 | for rows.Next() { 20 | rowsCount++ 21 | } 22 | 23 | if rowsCount > 0 { 24 | _, err = db.Exec("DROP TABLE IF EXISTS " + tableName + ";") 25 | if err != nil { 26 | //fmt.Println("Error on drop table '"+tableName+"':", err) 27 | return false, err 28 | } 29 | } 30 | 31 | // Создаем таблицу 32 | _, err = db.Exec(schema) 33 | if err != nil { 34 | //fmt.Println("Error on create table '"+tableName+"':", err) 35 | return false, err 36 | } 37 | 38 | return true, nil 39 | } 40 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Pavel Pavlenko 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | 23 | -------------------------------------------------------------------------------- /helpers/xml.go: -------------------------------------------------------------------------------- 1 | package helpers 2 | 3 | import ( 4 | "encoding/xml" 5 | "log" 6 | "os" 7 | "sync" 8 | ) 9 | 10 | // CountElementsInXML возвращает количество узлов в XML-файле 11 | func CountElementsInXML(w *sync.WaitGroup, c chan int, tableName string, countedElement string, logger *log.Logger) { 12 | w.Add(1) 13 | defer w.Done() 14 | 15 | var err error 16 | 17 | format := "xml" 18 | 19 | fileName, err2 := SearchFile(tableName, format) 20 | if err2 != nil { 21 | logger.Fatalln("Error searching file:", err) 22 | } 23 | 24 | pathToFile := format + "/" + fileName 25 | 26 | xmlFile, err := os.Open(pathToFile) 27 | if err != nil { 28 | logger.Fatalln("Error opening file:", err) 29 | } 30 | 31 | defer xmlFile.Close() 32 | 33 | decoder := xml.NewDecoder(xmlFile) 34 | total := 0 35 | var inElement string 36 | for { 37 | // Read tokens from the XML document in a stream. 38 | t, _ := decoder.Token() 39 | if t == nil { 40 | break 41 | } 42 | // Inspect the type of the token just read. 43 | switch se := t.(type) { 44 | case xml.StartElement: 45 | // If we just read a StartElement token 46 | inElement = se.Name.Local 47 | 48 | if inElement == countedElement { 49 | total++ 50 | c <- total 51 | } 52 | default: 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /helpers/file.go: -------------------------------------------------------------------------------- 1 | package helpers 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | "io" 7 | "io/ioutil" 8 | "net/http" 9 | "os" 10 | "strings" 11 | ) 12 | 13 | // SearchFile ищет в заданной директории файл, по части его имени и возвращает полное название файла 14 | func SearchFile(filePartName string, dir string) (string, error) { 15 | var err error 16 | var filesInfo []os.FileInfo 17 | var fullFileName string 18 | 19 | filesInfo, err = ioutil.ReadDir(dir) 20 | if err != nil { 21 | //fmt.Println("Error Reading dir "+dir+":", err) 22 | return "", err 23 | } 24 | 25 | for i := range filesInfo { 26 | if strings.Contains(strings.ToLower(filesInfo[i].Name()), filePartName) { 27 | fullFileName = filesInfo[i].Name() 28 | break 29 | } 30 | } 31 | 32 | if fullFileName == "" { 33 | return "", errors.New("File not found") 34 | } 35 | 36 | return fullFileName, nil 37 | } 38 | 39 | func downloadFromURL(url string) { 40 | tokens := strings.Split(url, "/") 41 | fileName := tokens[len(tokens)-1] 42 | fmt.Println("Downloading", url, "to", fileName) 43 | 44 | // TODO: check file existence first with io.IsExist 45 | output, err := os.Create(fileName) 46 | if err != nil { 47 | fmt.Println("Error while creating", fileName, "-", err) 48 | return 49 | } 50 | defer output.Close() 51 | 52 | response, err := http.Get(url) 53 | if err != nil { 54 | fmt.Println("Error while downloading", url, "-", err) 55 | return 56 | } 57 | defer response.Body.Close() 58 | 59 | n, err := io.Copy(output, response.Body) 60 | if err != nil { 61 | fmt.Println("Error while downloading", url, "-", err) 62 | return 63 | } 64 | 65 | fmt.Println(n, "bytes downloaded.") 66 | } 67 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Экспорт справочника ФИАС в БД PostgreSQL 2 | 3 | [![GoDoc](https://godoc.org/github.com/pavlik/fias_xml2postgresql?status.svg)](https://godoc.org/github.com/pavlik/fias_xml2postgresql) 4 | 5 | > ФИАС - Федеральная информационная адресная система 6 | 7 | [ФИАС](http://fias.nalog.ru/Updates.aspx) выкладывает справочник адресов России в открытом доступе (и регулярно его обновляет). Но данные доступны всего в 2 форматах XML и DBF (FoxPro). В распакованом виде база весит около 20Гб. В таком формате не совсем удобно работать со справочником. 8 | 9 | Для решения этой проблемы на [Go](http://golang.org/) была написана утилита экспортирующая данные из XML (в дальнейшем будет опция XML или DBF) в PostgreSQL. 10 | 11 | ![Программа работает в терминале и выглядит следующим образом :)](screenshot.png) 12 | 13 | ## Установка 14 | 1. Скачайте утилиту `go get -u github.com/pavlik/fias_xml2postgresql` 15 | 2. Перейдите в директорию с исходниками `cd $GOPATH/src/github.com/pavlik/fias_xml2postgresql` 16 | 3. Скачайте все зависимости `go get -u` 17 | 4. В этой директории создайте папку `xml` (позже будет создаваться автоматически). 18 | 5. Скачайте в директорию `xml` полный архив справочника в формате XML (позже будет скачиваться автоматически). 19 | 6. Создайте в PostgreSQL базу с именем fias принадлежащую пользователю dev с паролем dev. Или ваши данные, но тогда не забудьте изменить строку подключения в файле main.go 20 | 7. Запустите `go run main.go` 21 | 22 | ### Сделано: 23 | * Сделать обработку таблиц многопоточной 24 | * Написать Makefile для автоматического создания таблицы fias и пользователя, для работы с ней 25 | 26 | ### В планах: 27 | * Добавить возможность автоматического скачивания архива с сайта ФИАС, распаковки и экспорта 28 | * Вариант экспорта либо из XML, либо из DBF 29 | * Добавить возможность автоматической проверки обновлений базы и автоматической установки, если требуется 30 | * Проставить в схемах таблиц индексные поля 31 | -------------------------------------------------------------------------------- /structures/operation_status/operation_status.go: -------------------------------------------------------------------------------- 1 | package operation_status 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | // const dateformat = "2006-01-02" 8 | 9 | // Статус действия 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"OperationStatus" db:"as_operstat"` 12 | OPERSTATID int `xml:"OPERSTATID,attr" db:"oper_stat_id"` 13 | NAME string `xml:"NAME,attr" db:"name"` 14 | } 15 | 16 | // схема таблицы в БД 17 | 18 | // const tableName = "as_operstat" 19 | // const elementName = "OperationStatus" 20 | 21 | func Schema(tableName string) string { 22 | return `CREATE TABLE ` + tableName + ` ( 23 | oper_stat_id INT UNIQUE NOT NULL, 24 | name VARCHAR(100) NOT NULL, 25 | PRIMARY KEY (oper_stat_id));` 26 | } 27 | 28 | /* 29 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 30 | 31 | defer w.Done() 32 | helpers.DropAndCreateTable(schema, tableName, db) 33 | 34 | var format2 string 35 | format2 = *format 36 | fileName, err2 := helpers.SearchFile(tableName, format2) 37 | if err2 != nil { 38 | fmt.Println("Error searching file:", err2) 39 | return 40 | } 41 | 42 | pathToFile := format2 + "/" + fileName 43 | 44 | // Подсчитываем, сколько элементов нужно обработать 45 | //_, err := helpers.CountElementsInXML(pathToFile, elementName) 46 | // if err != nil { 47 | // fmt.Println("Error counting elements in XML file:", err) 48 | // return 49 | // } 50 | // fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 51 | 52 | xmlFile, err := os.Open(pathToFile) 53 | if err != nil { 54 | fmt.Println("Error opening file:", err) 55 | return 56 | } 57 | 58 | defer xmlFile.Close() 59 | 60 | decoder := xml.NewDecoder(xmlFile) 61 | total := 0 62 | var inElement string 63 | for { 64 | // Read tokens from the XML document in a stream. 65 | t, _ := decoder.Token() 66 | if t == nil { 67 | break 68 | } 69 | // Inspect the type of the token just read. 70 | switch se := t.(type) { 71 | case xml.StartElement: 72 | // If we just read a StartElement token 73 | inElement = se.Name.Local 74 | 75 | if inElement == elementName { 76 | total++ 77 | var item XmlObject 78 | 79 | // decode a whole chunk of following XML into the 80 | // variable item which is a ActualStatus (se above) 81 | err = decoder.DecodeElement(&item, &se) 82 | if err != nil { 83 | fmt.Println("Error in decode element:", err) 84 | return 85 | } 86 | query := "INSERT INTO " + tableName + " (oper_stat_id, name) VALUES ($1, $2)" 87 | db.MustExec(query, item.OPERSTATID, item.NAME) 88 | 89 | c <- helpers.PrintRowsAffected(elementName, total) 90 | } 91 | default: 92 | } 93 | 94 | } 95 | } 96 | */ 97 | -------------------------------------------------------------------------------- /structures/center_status/center_status.go: -------------------------------------------------------------------------------- 1 | package center_status 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | // const dateformat = "2006-01-02" 8 | // const tableName = "as_centerst" 9 | // const elementName = "CenterStatus" 10 | 11 | // Статус центра 12 | type XmlObject struct { 13 | XMLName xml.Name `xml:"CenterStatus" db:"as_centerst"` 14 | CENTERSTID int `xml:"CENTERSTID,attr" db:"center_st_id"` 15 | NAME string `xml:"NAME,attr" db:"name"` 16 | } 17 | 18 | func Schema(tableName string) string { 19 | return `CREATE TABLE ` + tableName + ` ( 20 | center_st_id INT UNIQUE NOT NULL, 21 | name VARCHAR(100) NOT NULL, 22 | PRIMARY KEY (center_st_id));` 23 | } 24 | 25 | /* 26 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 27 | 28 | defer w.Done() 29 | helpers.DropAndCreateTable(schema, tableName, db) 30 | 31 | var format2 string 32 | format2 = *format 33 | fileName, err2 := helpers.SearchFile(tableName, format2) 34 | if err2 != nil { 35 | fmt.Println("Error searching file:", err2) 36 | return 37 | } 38 | 39 | pathToFile := format2 + "/" + fileName 40 | 41 | // Подсчитываем, сколько элементов нужно обработать 42 | //fmt.Println("Подсчет строк") 43 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 44 | // if err != nil { 45 | // fmt.Println("Error counting elements in XML file:", err) 46 | // return 47 | // } 48 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 49 | 50 | xmlFile, err := os.Open(pathToFile) 51 | if err != nil { 52 | fmt.Println("Error opening file:", err) 53 | return 54 | } 55 | 56 | defer xmlFile.Close() 57 | 58 | decoder := xml.NewDecoder(xmlFile) 59 | total := 0 60 | var inElement string 61 | for { 62 | // Read tokens from the XML document in a stream. 63 | t, _ := decoder.Token() 64 | if t == nil { 65 | break 66 | } 67 | // Inspect the type of the token just read. 68 | switch se := t.(type) { 69 | case xml.StartElement: 70 | // If we just read a StartElement token 71 | inElement = se.Name.Local 72 | 73 | if inElement == elementName { 74 | total++ 75 | var item XmlObject 76 | 77 | // decode a whole chunk of following XML into the 78 | // variable item which is a ActualStatus (se above) 79 | err = decoder.DecodeElement(&item, &se) 80 | if err != nil { 81 | fmt.Println("Error in decode element:", err) 82 | return 83 | } 84 | query := "INSERT INTO " + tableName + " (center_st_id, name) VALUES ($1, $2)" 85 | db.MustExec(query, item.CENTERSTID, item.NAME) 86 | 87 | c <- helpers.PrintRowsAffected(elementName, total) 88 | } 89 | default: 90 | } 91 | 92 | } 93 | 94 | //fmt.Printf("\nTotal processed items in "+elementName+": %d \n", total) 95 | } 96 | */ 97 | -------------------------------------------------------------------------------- /structures/normative_document_type/normative_document_type.go: -------------------------------------------------------------------------------- 1 | package normative_document_type 2 | 3 | import "encoding/xml" 4 | 5 | // const dateformat = "2006-01-02" 6 | // const tableName = "as_ndoctype" 7 | // const elementName = "NormativeDocumentType" 8 | 9 | // Статус центра 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"NormativeDocumentType" db:"as_ndoctype"` 12 | NDTYPEID int `xml:"NDTYPEID,attr" db:"nd_type_id"` 13 | NAME string `xml:"NAME,attr" db:"name"` 14 | } 15 | 16 | func Schema(tableName string) string { 17 | return `CREATE TABLE ` + tableName + ` ( 18 | nd_type_id INT UNIQUE NOT NULL, 19 | name VARCHAR(100) NOT NULL, 20 | PRIMARY KEY (nd_type_id));` 21 | } 22 | 23 | /* 24 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 25 | 26 | defer w.Done() 27 | helpers.DropAndCreateTable(schema, tableName, db) 28 | 29 | var format2 string 30 | format2 = *format 31 | fileName, err2 := helpers.SearchFile(tableName, format2) 32 | if err2 != nil { 33 | fmt.Println("Error searching file:", err2) 34 | return 35 | } 36 | 37 | pathToFile := format2 + "/" + fileName 38 | 39 | // Подсчитываем, сколько элементов нужно обработать 40 | //fmt.Println("Подсчет строк") 41 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 42 | // if err != nil { 43 | // fmt.Println("Error counting elements in XML file:", err) 44 | // return 45 | // } 46 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 47 | 48 | xmlFile, err := os.Open(pathToFile) 49 | if err != nil { 50 | fmt.Println("Error opening file:", err) 51 | return 52 | } 53 | 54 | defer xmlFile.Close() 55 | 56 | decoder := xml.NewDecoder(xmlFile) 57 | total := 0 58 | var inElement string 59 | for { 60 | // Read tokens from the XML document in a stream. 61 | t, _ := decoder.Token() 62 | if t == nil { 63 | break 64 | } 65 | // Inspect the type of the token just read. 66 | switch se := t.(type) { 67 | case xml.StartElement: 68 | // If we just read a StartElement token 69 | inElement = se.Name.Local 70 | 71 | if inElement == elementName { 72 | total++ 73 | var item XmlObject 74 | 75 | // decode a whole chunk of following XML into the 76 | // variable item which is a ActualStatus (se above) 77 | err = decoder.DecodeElement(&item, &se) 78 | if err != nil { 79 | fmt.Println("Error in decode element:", err) 80 | return 81 | } 82 | query := "INSERT INTO " + tableName + " (nd_type_id, name) VALUES ($1, $2)" 83 | db.MustExec(query, item.NDTYPEID, item.NAME) 84 | 85 | c <- helpers.PrintRowsAffected(elementName, total) 86 | } 87 | default: 88 | } 89 | 90 | } 91 | 92 | //fmt.Printf("\nTotal processed items in "+elementName+": %d \n", total) 93 | } 94 | */ 95 | -------------------------------------------------------------------------------- /structures/current_status/current_status.go: -------------------------------------------------------------------------------- 1 | package current_status 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | //const dateformat = "2006-01-02" 8 | 9 | // Статус актуальности КЛАДР 4.0 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"CurrentStatus" db:"as_curentst"` 12 | CURENTSTID int `xml:"CURENTSTID,attr" db:"curent_st_id"` 13 | NAME string `xml:"NAME,attr" db:"name"` 14 | } 15 | 16 | // схема таблицы в БД 17 | 18 | // const tableName = "as_curentst" 19 | // const elementName = "CurrentStatus" 20 | 21 | func Schema(tableName string) string { 22 | return `CREATE TABLE ` + tableName + ` ( 23 | curent_st_id INT UNIQUE NOT NULL, 24 | name VARCHAR(100) NOT NULL, 25 | PRIMARY KEY (curent_st_id));` 26 | } 27 | 28 | /* 29 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 30 | 31 | defer w.Done() 32 | helpers.DropAndCreateTable(schema, tableName, db) 33 | 34 | var format2 string 35 | format2 = *format 36 | fileName, err2 := helpers.SearchFile(tableName, format2) 37 | if err2 != nil { 38 | fmt.Println("Error searching file:", err2) 39 | return 40 | } 41 | 42 | pathToFile := format2 + "/" + fileName 43 | 44 | // Подсчитываем, сколько элементов нужно обработать 45 | //_, err := helpers.CountElementsInXML(pathToFile, elementName) 46 | // if err != nil { 47 | // fmt.Println("Error counting elements in XML file:", err) 48 | // return 49 | // } 50 | // fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 51 | 52 | xmlFile, err := os.Open(pathToFile) 53 | if err != nil { 54 | fmt.Println("Error opening file:", err) 55 | return 56 | } 57 | 58 | defer xmlFile.Close() 59 | 60 | decoder := xml.NewDecoder(xmlFile) 61 | total := 0 62 | var inElement string 63 | for { 64 | // Read tokens from the XML document in a stream. 65 | t, _ := decoder.Token() 66 | if t == nil { 67 | break 68 | } 69 | // Inspect the type of the token just read. 70 | switch se := t.(type) { 71 | case xml.StartElement: 72 | // If we just read a StartElement token 73 | inElement = se.Name.Local 74 | 75 | if inElement == elementName { 76 | total++ 77 | var item XmlObject 78 | 79 | // decode a whole chunk of following XML into the 80 | // variable item which is a ActualStatus (se above) 81 | err = decoder.DecodeElement(&item, &se) 82 | if err != nil { 83 | fmt.Println("Error in decode element:", err) 84 | return 85 | } 86 | query := "INSERT INTO " + tableName + " (curent_st_id, name) VALUES ($1, $2)" 87 | db.MustExec(query, item.CURENTSTID, item.NAME) 88 | 89 | c <- helpers.PrintRowsAffected(elementName, total) 90 | } 91 | default: 92 | } 93 | 94 | } 95 | 96 | //fmt.Printf("Total processed items in CurrentStatus: %d \n", total) 97 | } 98 | */ 99 | -------------------------------------------------------------------------------- /structures/interval_status/interval_status.go: -------------------------------------------------------------------------------- 1 | package interval_status 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | // const dateformat = "2006-01-02" 8 | // const tableName = "as_intvstat" 9 | // const elementName = "IntervalStatus" 10 | 11 | // Статус интервала домов 12 | type XmlObject struct { 13 | XMLName xml.Name `xml:"IntervalStatus" db:"as_intvstat"` 14 | INTVSTATID int `xml:"INTVSTATID,attr" db:"intv_stat_id"` 15 | NAME string `xml:"NAME,attr" db:"name"` 16 | } 17 | 18 | func Schema(tableName string) string { 19 | return `CREATE TABLE ` + tableName + ` ( 20 | intv_stat_id INT UNIQUE NOT NULL, 21 | name VARCHAR(100) NOT NULL, 22 | PRIMARY KEY (intv_stat_id));` 23 | } 24 | 25 | /* 26 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 27 | 28 | defer w.Done() 29 | helpers.DropAndCreateTable(schema, tableName, db) 30 | 31 | var format2 string 32 | format2 = *format 33 | fileName, err2 := helpers.SearchFile(tableName, format2) 34 | if err2 != nil { 35 | fmt.Println("Error searching file:", err2) 36 | return 37 | } 38 | 39 | pathToFile := format2 + "/" + fileName 40 | 41 | // Подсчитываем, сколько элементов нужно обработать 42 | //fmt.Println("Подсчет строк") 43 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 44 | // if err != nil { 45 | // fmt.Println("Error counting elements in XML file:", err) 46 | // return 47 | // } 48 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 49 | 50 | xmlFile, err := os.Open(pathToFile) 51 | if err != nil { 52 | fmt.Println("Error opening file:", err) 53 | return 54 | } 55 | 56 | defer xmlFile.Close() 57 | 58 | decoder := xml.NewDecoder(xmlFile) 59 | total := 0 60 | var inElement string 61 | for { 62 | // Read tokens from the XML document in a stream. 63 | t, _ := decoder.Token() 64 | if t == nil { 65 | break 66 | } 67 | // Inspect the type of the token just read. 68 | switch se := t.(type) { 69 | case xml.StartElement: 70 | // If we just read a StartElement token 71 | inElement = se.Name.Local 72 | 73 | if inElement == elementName { 74 | total++ 75 | var item XmlObject 76 | 77 | // decode a whole chunk of following XML into the 78 | // variable item which is a ActualStatus (se above) 79 | err = decoder.DecodeElement(&item, &se) 80 | if err != nil { 81 | fmt.Println("Error in decode element:", err) 82 | return 83 | } 84 | query := "INSERT INTO " + tableName + " (intv_stat_id, name) VALUES ($1, $2)" 85 | db.MustExec(query, item.INTVSTATID, item.NAME) 86 | 87 | c <- helpers.PrintRowsAffected(elementName, total) 88 | } 89 | default: 90 | } 91 | 92 | } 93 | 94 | //fmt.Printf("\nTotal processed items in "+elementName+": %d \n", total) 95 | } 96 | */ 97 | -------------------------------------------------------------------------------- /structures/house_state_status/house_state_status.go: -------------------------------------------------------------------------------- 1 | package house_state_status 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | // 8 | // const dateformat = "2006-01-02" 9 | // const tableName = "as_hststat" 10 | // const elementName = "HouseStateStatus" 11 | 12 | // Статус состояния домов 13 | type XmlObject struct { 14 | XMLName xml.Name `xml:"HouseStateStatus" db:"as_hststat"` 15 | HOUSESTID int `xml:"HOUSESTID,attr" db:"house_st_id"` 16 | NAME string `xml:"NAME,attr" db:"name"` 17 | } 18 | 19 | func Schema(tableName string) string { 20 | return `CREATE TABLE ` + tableName + ` ( 21 | house_st_id INT UNIQUE NOT NULL, 22 | name VARCHAR(100) NOT NULL, 23 | PRIMARY KEY (house_st_id));` 24 | } 25 | 26 | /* 27 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 28 | 29 | defer w.Done() 30 | helpers.DropAndCreateTable(schema, tableName, db) 31 | 32 | var format2 string 33 | format2 = *format 34 | fileName, err2 := helpers.SearchFile(tableName, format2) 35 | if err2 != nil { 36 | fmt.Println("Error searching file:", err2) 37 | return 38 | } 39 | 40 | pathToFile := format2 + "/" + fileName 41 | 42 | // Подсчитываем, сколько элементов нужно обработать 43 | //fmt.Println("Подсчет строк") 44 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 45 | // if err != nil { 46 | // fmt.Println("Error counting elements in XML file:", err) 47 | // return 48 | // } 49 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 50 | 51 | xmlFile, err := os.Open(pathToFile) 52 | if err != nil { 53 | fmt.Println("Error opening file:", err) 54 | return 55 | } 56 | 57 | defer xmlFile.Close() 58 | 59 | decoder := xml.NewDecoder(xmlFile) 60 | total := 0 61 | var inElement string 62 | for { 63 | // Read tokens from the XML document in a stream. 64 | t, _ := decoder.Token() 65 | if t == nil { 66 | break 67 | } 68 | // Inspect the type of the token just read. 69 | switch se := t.(type) { 70 | case xml.StartElement: 71 | // If we just read a StartElement token 72 | inElement = se.Name.Local 73 | 74 | if inElement == elementName { 75 | total++ 76 | var item XmlObject 77 | 78 | // decode a whole chunk of following XML into the 79 | // variable item which is a ActualStatus (se above) 80 | err = decoder.DecodeElement(&item, &se) 81 | if err != nil { 82 | fmt.Println("Error in decode element:", err) 83 | return 84 | } 85 | query := "INSERT INTO " + tableName + " (house_st_id, name) VALUES ($1, $2)" 86 | db.MustExec(query, item.HOUSESTID, item.NAME) 87 | 88 | c <- helpers.PrintRowsAffected(elementName, total) 89 | } 90 | default: 91 | } 92 | 93 | } 94 | 95 | //fmt.Printf("\nTotal processed items in "+elementName+": %d \n", total) 96 | } 97 | */ 98 | -------------------------------------------------------------------------------- /structures/estate_status/estate_status.go: -------------------------------------------------------------------------------- 1 | package estate_status 2 | 3 | import ( 4 | "encoding/xml" 5 | 6 | _ "github.com/lib/pq" 7 | ) 8 | 9 | // const dateformat = "2006-01-02" 10 | 11 | // Признак владения 12 | type XmlObject struct { 13 | XMLName xml.Name `xml:"EstateStatus" db:"as_eststat"` 14 | ESTSTATID int `xml:"ESTSTATID,attr" db:"est_stat_id"` 15 | NAME string `xml:"NAME,attr" db:"name"` 16 | SHORTNAME string `xml:"SHORTNAME,attr" db:"short_name"` 17 | } 18 | 19 | // схема таблицы в БД 20 | 21 | // const tableName = "as_eststat" 22 | // const elementName = "EstateStatus" 23 | 24 | func Schema(tableName string) string { 25 | return `CREATE TABLE ` + tableName + ` ( 26 | est_stat_id INT UNIQUE NOT NULL, 27 | name VARCHAR(20) NOT NULL, 28 | short_name VARCHAR(20), 29 | PRIMARY KEY (est_stat_id));` 30 | } 31 | 32 | /* 33 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 34 | 35 | defer w.Done() 36 | helpers.DropAndCreateTable(schema, tableName, db) 37 | 38 | var format2 string 39 | format2 = *format 40 | fileName, err2 := helpers.SearchFile(tableName, format2) 41 | if err2 != nil { 42 | fmt.Println("Error searching file:", err2) 43 | return 44 | } 45 | 46 | pathToFile := format2 + "/" + fileName 47 | 48 | // Подсчитываем, сколько элементов нужно обработать 49 | //_, err := helpers.CountElementsInXML(pathToFile, elementName) 50 | // if err != nil { 51 | // fmt.Println("Error counting elements in XML file:", err) 52 | // return 53 | // } 54 | // fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 55 | 56 | xmlFile, err := os.Open(pathToFile) 57 | if err != nil { 58 | fmt.Println("Error opening file:", err) 59 | return 60 | } 61 | 62 | defer xmlFile.Close() 63 | 64 | decoder := xml.NewDecoder(xmlFile) 65 | total := 0 66 | var inElement string 67 | for { 68 | // Read tokens from the XML document in a stream. 69 | t, _ := decoder.Token() 70 | if t == nil { 71 | break 72 | } 73 | // Inspect the type of the token just read. 74 | switch se := t.(type) { 75 | case xml.StartElement: 76 | // If we just read a StartElement token 77 | inElement = se.Name.Local 78 | 79 | if inElement == elementName { 80 | total++ 81 | var item XmlObject 82 | 83 | // decode a whole chunk of following XML into the 84 | // variable item which is a ActualStatus (se above) 85 | err = decoder.DecodeElement(&item, &se) 86 | if err != nil { 87 | fmt.Println("Error in decode element:", err) 88 | return 89 | } 90 | query := "INSERT INTO " + tableName + " (est_stat_id, name, short_name) VALUES ($1, $2, $3)" 91 | db.MustExec(query, item.ESTSTATID, item.NAME, item.SHORTNAME) 92 | 93 | c <- helpers.PrintRowsAffected(elementName, total) 94 | } 95 | default: 96 | } 97 | 98 | } 99 | 100 | //fmt.Printf("Total processed items in CurrentStatus: %d \n", total) 101 | } 102 | */ 103 | -------------------------------------------------------------------------------- /structures/structure_status/structure_status.go: -------------------------------------------------------------------------------- 1 | package structure_status 2 | 3 | import "encoding/xml" 4 | 5 | //const dateformat = "2006-01-02" 6 | 7 | // Признак строения 8 | type XmlObject struct { 9 | XMLName xml.Name `xml:"StructureStatus" db:"as_strstat"` 10 | STRSTATID int `xml:"STRSTATID,attr" db:"str_stat_id"` 11 | NAME string `xml:"NAME,attr" db:"name"` 12 | SHORTNAME string `xml:"SHORTNAME,attr" db:"short_name"` 13 | } 14 | 15 | // схема таблицы в БД 16 | 17 | // const tableName = "as_strstat" 18 | // const elementName = "StructureStatus" 19 | 20 | func Schema(tableName string) string { 21 | return `CREATE TABLE ` + tableName + ` ( 22 | str_stat_id INT UNIQUE NOT NULL, 23 | name VARCHAR(20) NOT NULL, 24 | short_name VARCHAR(20), 25 | PRIMARY KEY (str_stat_id));` 26 | } 27 | 28 | /* 29 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 30 | 31 | defer w.Done() 32 | helpers.DropAndCreateTable(schema, tableName, db) 33 | 34 | var format2 string 35 | format2 = *format 36 | fileName, err2 := helpers.SearchFile(tableName, format2) 37 | if err2 != nil { 38 | fmt.Println("Error searching file:", err2) 39 | return 40 | } 41 | 42 | pathToFile := format2 + "/" + fileName 43 | 44 | // Подсчитываем, сколько элементов нужно обработать 45 | //_, err := helpers.CountElementsInXML(pathToFile, elementName) 46 | // if err != nil { 47 | // fmt.Println("Error counting elements in XML file:", err) 48 | // return 49 | // } 50 | // fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 51 | 52 | xmlFile, err := os.Open(pathToFile) 53 | if err != nil { 54 | fmt.Println("Error opening file:", err) 55 | return 56 | } 57 | 58 | defer xmlFile.Close() 59 | 60 | decoder := xml.NewDecoder(xmlFile) 61 | total := 0 62 | var inElement string 63 | for { 64 | // Read tokens from the XML document in a stream. 65 | t, _ := decoder.Token() 66 | if t == nil { 67 | break 68 | } 69 | // Inspect the type of the token just read. 70 | switch se := t.(type) { 71 | case xml.StartElement: 72 | // If we just read a StartElement token 73 | inElement = se.Name.Local 74 | 75 | if inElement == elementName { 76 | total++ 77 | var item XmlObject 78 | 79 | // decode a whole chunk of following XML into the 80 | // variable item which is a ActualStatus (se above) 81 | err = decoder.DecodeElement(&item, &se) 82 | if err != nil { 83 | fmt.Println("Error in decode element:", err) 84 | return 85 | } 86 | query := `INSERT INTO ` + tableName + ` ( 87 | str_stat_id, 88 | name, 89 | short_name) 90 | VALUES ( 91 | $1, $2, $3)` 92 | 93 | db.MustExec(query, 94 | item.STRSTATID, 95 | item.NAME, 96 | item.SHORTNAME) 97 | 98 | c <- helpers.PrintRowsAffected(elementName, total) 99 | } 100 | default: 101 | } 102 | 103 | } 104 | } 105 | */ 106 | -------------------------------------------------------------------------------- /structures/address_object_type/address_object_type.go: -------------------------------------------------------------------------------- 1 | package address_object_type 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | //const dateformat = "2006-01-02" 8 | 9 | // Статус действия 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"AddressObjectType" db:"as_socrbase"` 12 | LEVEL int `xml:"LEVEL,attr" db:"level"` 13 | SCNAME string `xml:"SCNAME,attr" db:"sc_name"` 14 | SOCRNAME string `xml:"SOCRNAME,attr" db:"socr_name"` 15 | KOD_T_ST string `xml:"KOD_T_ST,attr" db:"kod_t_st"` 16 | } 17 | 18 | // схема таблицы в БД 19 | 20 | // const tableName = "as_socrbase" 21 | // const elementName = "AddressObjectType" 22 | 23 | func Schema(tableName string) string { 24 | return `CREATE TABLE ` + tableName + ` ( 25 | level INT NOT NULL, 26 | sc_name VARCHAR(20), 27 | socr_name VARCHAR(60), 28 | kod_t_st INT UNIQUE NOT NULL, 29 | PRIMARY KEY (kod_t_st));` 30 | } 31 | 32 | /* 33 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 34 | 35 | defer w.Done() 36 | helpers.DropAndCreateTable(schema, tableName, db) 37 | 38 | var format2 string 39 | format2 = *format 40 | fileName, err2 := helpers.SearchFile(tableName, format2) 41 | if err2 != nil { 42 | fmt.Println("Error searching file:", err2) 43 | return 44 | } 45 | 46 | pathToFile := format2 + "/" + fileName 47 | 48 | // Подсчитываем, сколько элементов нужно обработать 49 | //_, err := helpers.CountElementsInXML(pathToFile, elementName) 50 | // if err != nil { 51 | // fmt.Println("Error counting elements in XML file:", err) 52 | // return 53 | // } 54 | // fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 55 | 56 | xmlFile, err := os.Open(pathToFile) 57 | if err != nil { 58 | fmt.Println("Error opening file:", err) 59 | return 60 | } 61 | 62 | defer xmlFile.Close() 63 | 64 | decoder := xml.NewDecoder(xmlFile) 65 | total := 0 66 | var inElement string 67 | for { 68 | // Read tokens from the XML document in a stream. 69 | t, _ := decoder.Token() 70 | if t == nil { 71 | break 72 | } 73 | // Inspect the type of the token just read. 74 | switch se := t.(type) { 75 | case xml.StartElement: 76 | // If we just read a StartElement token 77 | inElement = se.Name.Local 78 | 79 | if inElement == elementName { 80 | total++ 81 | var item XmlObject 82 | 83 | // decode a whole chunk of following XML into the 84 | // variable item which is a ActualStatus (se above) 85 | err = decoder.DecodeElement(&item, &se) 86 | if err != nil { 87 | fmt.Println("Error in decode element:", err) 88 | return 89 | } 90 | query := `INSERT INTO ` + tableName + ` ( 91 | level, 92 | sc_name, 93 | socr_name, 94 | kod_t_st) 95 | VALUES ( 96 | $1, $2, $3, $4)` 97 | 98 | db.MustExec(query, 99 | item.LEVEL, 100 | item.SCNAME, 101 | item.SOCRNAME, 102 | item.KOD_T_ST) 103 | 104 | c <- helpers.PrintRowsAffected(elementName, total) 105 | } 106 | default: 107 | } 108 | 109 | } 110 | } 111 | */ 112 | -------------------------------------------------------------------------------- /structures/actual_status/actual_status.go: -------------------------------------------------------------------------------- 1 | package actual_status 2 | 3 | import ( 4 | "encoding/xml" 5 | 6 | _ "github.com/lib/pq" 7 | ) 8 | 9 | // Статус актуальности ФИАС 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"ActualStatus" db:"as_actstat"` 12 | ActStatId int `xml:"ACTSTATID,attr" db:"act_stat_id"` 13 | Name string `xml:"NAME,attr" db:"name"` 14 | } 15 | 16 | // схема таблицы в БД 17 | 18 | // const tableName = "as_actstat" 19 | // const elementName = "ActualStatus" 20 | 21 | func Schema(tableName string) string { 22 | return `CREATE TABLE ` + tableName + ` ( 23 | act_stat_id INT UNIQUE NOT NULL, 24 | name VARCHAR(100) NOT NULL, 25 | PRIMARY KEY (act_stat_id));` 26 | } 27 | 28 | // func (item XmlObject) String() string { 29 | // return fmt.Sprintf("\t ActStatId : %d - Name : %s \n", item.ActStatId, item.Name) 30 | // } 31 | 32 | // 33 | // func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 34 | // 35 | // defer w.Done() 36 | // 37 | // helpers.DropAndCreateTable(schema, tableName, db) 38 | // 39 | // var format2 string 40 | // format2 = *format 41 | // fileName, err2 := helpers.SearchFile(tableName, format2) 42 | // if err2 != nil { 43 | // fmt.Println("Error searching file:", err2) 44 | // return 45 | // } 46 | // 47 | // pathToFile := format2 + "/" + fileName 48 | // 49 | // // Подсчитываем, сколько элементов нужно обработать 50 | // //_, err := helpers.CountElementsInXML(pathToFile, elementName) 51 | // // if err != nil { 52 | // // fmt.Println("Error counting elements in XML file:", err) 53 | // // return 54 | // // } 55 | // // fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 56 | // 57 | // xmlFile, err := os.Open(pathToFile) 58 | // if err != nil { 59 | // fmt.Println("Error opening file:", err) 60 | // return 61 | // } 62 | // 63 | // defer xmlFile.Close() 64 | // 65 | // decoder := xml.NewDecoder(xmlFile) 66 | // total := 0 67 | // var inElement string 68 | // for { 69 | // // Read tokens from the XML document in a stream. 70 | // t, _ := decoder.Token() 71 | // if t == nil { 72 | // break 73 | // } 74 | // // Inspect the type of the token just read. 75 | // switch se := t.(type) { 76 | // case xml.StartElement: 77 | // // If we just read a StartElement token 78 | // inElement = se.Name.Local 79 | // 80 | // if inElement == elementName { 81 | // total++ 82 | // var item XmlObject 83 | // // decode a whole chunk of following XML into the 84 | // // variable item which is a ActualStatus (se above) 85 | // err = decoder.DecodeElement(&item, &se) 86 | // if err != nil { 87 | // fmt.Println("Error in decode element:", err) 88 | // return 89 | // } 90 | // query := "INSERT INTO " + tableName + " (act_stat_id, name) VALUES ($1, $2)" 91 | // db.MustExec(query, item.ActStatId, item.Name) 92 | // 93 | // c <- helpers.PrintRowsAffected(elementName, total) 94 | // } 95 | // default: 96 | // } 97 | // 98 | // } 99 | // 100 | // //fmt.Printf("\nВсего в "+elementName+" обработано %d строк\n", total) 101 | // } 102 | -------------------------------------------------------------------------------- /structures/center_status/center_status_bulk.go: -------------------------------------------------------------------------------- 1 | package center_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "center_st_id", "name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.CENTERSTID, item.NAME) 129 | 130 | if err != nil { 131 | logger.Fatalln(err) 132 | } 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | i++ 135 | } 136 | default: 137 | } 138 | 139 | } 140 | } 141 | */ 142 | -------------------------------------------------------------------------------- /structures/current_status/current_status_bulk.go: -------------------------------------------------------------------------------- 1 | package current_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "curent_st_id", "name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.CURENTSTID, item.NAME) 129 | 130 | if err != nil { 131 | logger.Fatalln(err) 132 | } 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | i++ 135 | } 136 | default: 137 | } 138 | 139 | } 140 | } 141 | */ 142 | -------------------------------------------------------------------------------- /structures/interval_status/interval_status_bulk.go: -------------------------------------------------------------------------------- 1 | package interval_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "intv_stat_id", "name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.INTVSTATID, item.NAME) 129 | 130 | if err != nil { 131 | logger.Fatalln(err) 132 | } 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | i++ 135 | } 136 | default: 137 | } 138 | 139 | } 140 | } 141 | */ 142 | -------------------------------------------------------------------------------- /structures/operation_status/operation_status_bulk.go: -------------------------------------------------------------------------------- 1 | package operation_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "oper_stat_id", "name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.OPERSTATID, item.NAME) 129 | 130 | if err != nil { 131 | logger.Fatalln(err) 132 | } 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | i++ 135 | } 136 | default: 137 | } 138 | 139 | } 140 | } 141 | */ 142 | -------------------------------------------------------------------------------- /structures/house_state_status/house_state_status_bulk.go: -------------------------------------------------------------------------------- 1 | package house_state_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "house_st_id", "name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.HOUSESTID, item.NAME) 129 | 130 | if err != nil { 131 | logger.Fatalln(err) 132 | } 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | i++ 135 | } 136 | default: 137 | } 138 | 139 | } 140 | } 141 | */ 142 | -------------------------------------------------------------------------------- /structures/normative_document_type/normative_document_type_bulk.go: -------------------------------------------------------------------------------- 1 | package normative_document_type 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "nd_type_id", "name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.NDTYPEID, item.NAME) 129 | 130 | if err != nil { 131 | logger.Fatalln(err) 132 | } 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | i++ 135 | } 136 | default: 137 | } 138 | 139 | } 140 | } 141 | */ 142 | -------------------------------------------------------------------------------- /structures/estate_status/estate_status_bulk.go: -------------------------------------------------------------------------------- 1 | package estate_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | return 34 | } 35 | 36 | defer xmlFile.Close() 37 | 38 | decoder := xml.NewDecoder(xmlFile) 39 | var inElement string 40 | total := 0 41 | i := 0 42 | 43 | txn, err := db.Begin() 44 | if err != nil { 45 | logger.Fatalln(err) 46 | } 47 | 48 | query := pq.CopyIn(tableName, "est_stat_id", "name", "short_name") 49 | 50 | stmt, err := txn.Prepare(query) 51 | if err != nil { 52 | logger.Fatalln(err) 53 | } 54 | 55 | for { 56 | if i == 50000 { 57 | i = 0 58 | 59 | _, err = stmt.Exec() 60 | if err != nil { 61 | logger.Fatalln(err) 62 | } 63 | 64 | err = stmt.Close() 65 | if err != nil { 66 | logger.Fatalln(err) 67 | } 68 | 69 | err = txn.Commit() 70 | if err != nil { 71 | logger.Fatalln(err) 72 | } 73 | 74 | //c <- helpers.PrintRowsAffected(elementName, total) 75 | 76 | txn, err = db.Begin() 77 | if err != nil { 78 | logger.Fatalln(err) 79 | } 80 | 81 | stmt, err = txn.Prepare(query) 82 | if err != nil { 83 | logger.Fatalln(err) 84 | } 85 | } 86 | // Read tokens from the XML document in a stream. 87 | t, _ := decoder.Token() 88 | 89 | // Если достигли конца xml-файла 90 | if t == nil { 91 | if i > 0 { 92 | _, err = stmt.Exec() 93 | if err != nil { 94 | logger.Fatalln(err) 95 | } 96 | 97 | err = stmt.Close() 98 | if err != nil { 99 | logger.Fatalln(err) 100 | } 101 | 102 | err = txn.Commit() 103 | if err != nil { 104 | logger.Fatalln(err) 105 | } 106 | } 107 | 108 | //c <- helpers.PrintRowsAffected(elementName, total) 109 | 110 | break 111 | } 112 | // Inspect the type of the token just read. 113 | switch se := t.(type) { 114 | case xml.StartElement: 115 | // If we just read a StartElement token 116 | inElement = se.Name.Local 117 | 118 | if inElement == elementName { 119 | total++ 120 | var item XmlObject 121 | 122 | // decode a whole chunk of following XML into the 123 | // variable item which is a ActualStatus (se above) 124 | err = decoder.DecodeElement(&item, &se) 125 | if err != nil { 126 | logger.Fatalln("Error in decode element:", err) 127 | } 128 | 129 | _, err = stmt.Exec(item.ESTSTATID, item.NAME, item.SHORTNAME) 130 | 131 | if err != nil { 132 | logger.Fatalln(err) 133 | } 134 | c <- helpers.PrintRowsAffected(elementName, total) 135 | i++ 136 | } 137 | default: 138 | } 139 | 140 | } 141 | } 142 | */ 143 | -------------------------------------------------------------------------------- /structures/structure_status/structure_status_bulk.go: -------------------------------------------------------------------------------- 1 | package structure_status 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "str_stat_id", "name", "short_name") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | } 127 | 128 | _, err = stmt.Exec(item.STRSTATID, 129 | item.NAME, 130 | item.SHORTNAME) 131 | 132 | if err != nil { 133 | logger.Fatalln(err) 134 | } 135 | c <- helpers.PrintRowsAffected(elementName, total) 136 | i++ 137 | } 138 | default: 139 | } 140 | 141 | } 142 | } 143 | */ 144 | -------------------------------------------------------------------------------- /structures/address_object_type/address_object_type_bulk.go: -------------------------------------------------------------------------------- 1 | package address_object_type 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, "level", "sc_name", "socr_name", "kod_t_st") 48 | 49 | stmt, err := txn.Prepare(query) 50 | if err != nil { 51 | logger.Fatalln(err) 52 | } 53 | 54 | for { 55 | if i == 50000 { 56 | i = 0 57 | 58 | _, err = stmt.Exec() 59 | if err != nil { 60 | logger.Fatalln(err) 61 | } 62 | 63 | err = stmt.Close() 64 | if err != nil { 65 | logger.Fatalln(err) 66 | } 67 | 68 | err = txn.Commit() 69 | if err != nil { 70 | logger.Fatalln(err) 71 | } 72 | 73 | //c <- helpers.PrintRowsAffected(elementName, total) 74 | 75 | txn, err = db.Begin() 76 | if err != nil { 77 | logger.Fatalln(err) 78 | } 79 | 80 | stmt, err = txn.Prepare(query) 81 | if err != nil { 82 | logger.Fatalln(err) 83 | } 84 | } 85 | // Read tokens from the XML document in a stream. 86 | t, _ := decoder.Token() 87 | 88 | // Если достигли конца xml-файла 89 | if t == nil { 90 | if i > 0 { 91 | _, err = stmt.Exec() 92 | if err != nil { 93 | logger.Fatalln(err) 94 | } 95 | 96 | err = stmt.Close() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | err = txn.Commit() 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | 107 | //c <- helpers.PrintRowsAffected(elementName, total) 108 | 109 | break 110 | } 111 | // Inspect the type of the token just read. 112 | switch se := t.(type) { 113 | case xml.StartElement: 114 | // If we just read a StartElement token 115 | inElement = se.Name.Local 116 | 117 | if inElement == elementName { 118 | total++ 119 | var item XmlObject 120 | 121 | // decode a whole chunk of following XML into the 122 | // variable item which is a ActualStatus (se above) 123 | err = decoder.DecodeElement(&item, &se) 124 | if err != nil { 125 | logger.Fatalln("Error in decode element:", err) 126 | return 127 | } 128 | 129 | _, err = stmt.Exec(item.LEVEL, 130 | item.SCNAME, 131 | item.SOCRNAME, 132 | item.KOD_T_ST) 133 | 134 | if err != nil { 135 | logger.Fatalln(err) 136 | } 137 | c <- helpers.PrintRowsAffected(elementName, total) 138 | i++ 139 | } 140 | default: 141 | } 142 | 143 | } 144 | } 145 | */ 146 | -------------------------------------------------------------------------------- /structures/actual_status/actual_status_bulk.go: -------------------------------------------------------------------------------- 1 | package actual_status 2 | 3 | // 4 | // func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 5 | // 6 | // defer w.Done() 7 | // 8 | // helpers.DropAndCreateTable(schema, tableName, db) 9 | // 10 | // var format2 string 11 | // format2 = *format 12 | // fileName, err2 := helpers.SearchFile(tableName, format2) 13 | // if err2 != nil { 14 | // logger.Fatalln("Error searching file:", err2) 15 | // } 16 | // 17 | // pathToFile := format2 + "/" + fileName 18 | // 19 | // xmlFile, err := os.Open(pathToFile) 20 | // if err != nil { 21 | // logger.Fatalln("Error opening file:", err) 22 | // } 23 | // 24 | // defer xmlFile.Close() 25 | // 26 | // decoder := xml.NewDecoder(xmlFile) 27 | // var inElement string 28 | // total := 0 29 | // i := 0 30 | // 31 | // txn, err := db.Begin() 32 | // if err != nil { 33 | // logger.Fatalln(err) 34 | // } 35 | // 36 | // query := pq.CopyIn(tableName, "act_stat_id", "name") 37 | // 38 | // stmt, err := txn.Prepare(query) 39 | // if err != nil { 40 | // logger.Fatalln(err) 41 | // } 42 | // 43 | // for { 44 | // if i == 10000 { 45 | // i = 0 46 | // 47 | // _, err = stmt.Exec() 48 | // if err != nil { 49 | // logger.Fatalln(err) 50 | // } 51 | // 52 | // err = stmt.Close() 53 | // if err != nil { 54 | // logger.Fatalln(err) 55 | // } 56 | // 57 | // err = txn.Commit() 58 | // if err != nil { 59 | // logger.Fatalln(err) 60 | // } 61 | // 62 | // //c <- helpers.PrintRowsAffected(elementName, total) 63 | // 64 | // txn, err = db.Begin() 65 | // if err != nil { 66 | // logger.Fatalln(err) 67 | // } 68 | // 69 | // stmt, err = txn.Prepare(query) 70 | // if err != nil { 71 | // logger.Fatalln(err) 72 | // } 73 | // } 74 | // // Read tokens from the XML document in a stream. 75 | // t, _ := decoder.Token() 76 | // 77 | // // Если достигли конца xml-файла 78 | // if t == nil { 79 | // if i > 0 { 80 | // _, err = stmt.Exec() 81 | // if err != nil { 82 | // logger.Fatalln(err) 83 | // } 84 | // 85 | // err = stmt.Close() 86 | // if err != nil { 87 | // logger.Fatalln(err) 88 | // } 89 | // 90 | // err = txn.Commit() 91 | // if err != nil { 92 | // logger.Fatalln(err) 93 | // } 94 | // } 95 | // 96 | // //c <- helpers.PrintRowsAffected(elementName, total) 97 | // 98 | // break 99 | // } 100 | // // Inspect the type of the token just read. 101 | // switch se := t.(type) { 102 | // case xml.StartElement: 103 | // // If we just read a StartElement token 104 | // inElement = se.Name.Local 105 | // 106 | // if inElement == elementName { 107 | // total++ 108 | // var item XmlObject 109 | // 110 | // // decode a whole chunk of following XML into the 111 | // // variable item which is a ActualStatus (se above) 112 | // err = decoder.DecodeElement(&item, &se) 113 | // if err != nil { 114 | // logger.Fatalln("Error in decode element:", err) 115 | // } 116 | // 117 | // _, err = stmt.Exec(item.ActStatId, item.Name) 118 | // 119 | // if err != nil { 120 | // logger.Fatalln(err) 121 | // } 122 | // c <- helpers.PrintRowsAffected(elementName, total) 123 | // i++ 124 | // } 125 | // default: 126 | // } 127 | // 128 | // } 129 | // } 130 | -------------------------------------------------------------------------------- /structures/normative_document/normative_document_bulk.go: -------------------------------------------------------------------------------- 1 | package normative_document 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, 48 | "norm_doc_id", 49 | "doc_name", 50 | "doc_date", 51 | "doc_num", 52 | "doc_type", 53 | "doc_img_id") 54 | 55 | stmt, err := txn.Prepare(query) 56 | if err != nil { 57 | logger.Fatalln(err) 58 | } 59 | 60 | for { 61 | if i == 50000 { 62 | i = 0 63 | 64 | _, err = stmt.Exec() 65 | if err != nil { 66 | logger.Fatalln(err) 67 | } 68 | 69 | err = stmt.Close() 70 | if err != nil { 71 | logger.Fatalln(err) 72 | } 73 | 74 | err = txn.Commit() 75 | if err != nil { 76 | logger.Fatalln(err) 77 | } 78 | 79 | //c <- helpers.PrintRowsAffected(elementName, total) 80 | 81 | txn, err = db.Begin() 82 | if err != nil { 83 | logger.Fatalln(err) 84 | } 85 | 86 | stmt, err = txn.Prepare(query) 87 | if err != nil { 88 | logger.Fatalln(err) 89 | } 90 | } 91 | // Read tokens from the XML document in a stream. 92 | t, _ := decoder.Token() 93 | 94 | // Если достигли конца xml-файла 95 | if t == nil { 96 | if i > 0 { 97 | _, err = stmt.Exec() 98 | if err != nil { 99 | logger.Fatalln(err) 100 | } 101 | 102 | err = stmt.Close() 103 | if err != nil { 104 | logger.Fatalln(err) 105 | } 106 | 107 | err = txn.Commit() 108 | if err != nil { 109 | logger.Fatalln(err) 110 | } 111 | } 112 | 113 | //c <- helpers.PrintRowsAffected(elementName, total) 114 | 115 | break 116 | } 117 | // Inspect the type of the token just read. 118 | switch se := t.(type) { 119 | case xml.StartElement: 120 | // If we just read a StartElement token 121 | inElement = se.Name.Local 122 | 123 | if inElement == elementName { 124 | total++ 125 | var item XmlObject 126 | 127 | // decode a whole chunk of following XML into the 128 | // variable item which is a ActualStatus (se above) 129 | err = decoder.DecodeElement(&item, &se) 130 | if err != nil { 131 | logger.Fatalln("Error in decode element:", err) 132 | } 133 | 134 | _, err = stmt.Exec(item.NORMDOCID, 135 | item.DOCNAME, 136 | item.DOCDATE, 137 | item.DOCNUM, 138 | item.DOCTYPE, 139 | item.DOCIMGID) 140 | 141 | if err != nil { 142 | logger.Fatalln(err) 143 | } 144 | c <- helpers.PrintRowsAffected(elementName, total) 145 | i++ 146 | } 147 | default: 148 | } 149 | 150 | } 151 | } 152 | */ 153 | -------------------------------------------------------------------------------- /structures/landmark/landmark_bulk.go: -------------------------------------------------------------------------------- 1 | package landmark 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, 48 | "location", 49 | "postal_code", 50 | "ifns_fl", 51 | "terr_ifns_fl", 52 | "ifns_ul", 53 | "terr_ifns_ul", 54 | "okato", 55 | "oktmo", 56 | "update_date", 57 | "land_id", 58 | "land_guid", 59 | "ao_guid", 60 | "start_date", 61 | "end_date", 62 | "norm_doc") 63 | 64 | stmt, err := txn.Prepare(query) 65 | if err != nil { 66 | logger.Fatalln(err) 67 | } 68 | 69 | for { 70 | if i == 50000 { 71 | i = 0 72 | 73 | _, err = stmt.Exec() 74 | if err != nil { 75 | logger.Fatalln(err) 76 | } 77 | 78 | err = stmt.Close() 79 | if err != nil { 80 | logger.Fatalln(err) 81 | } 82 | 83 | err = txn.Commit() 84 | if err != nil { 85 | logger.Fatalln(err) 86 | } 87 | 88 | //c <- helpers.PrintRowsAffected(elementName, total) 89 | 90 | txn, err = db.Begin() 91 | if err != nil { 92 | logger.Fatalln(err) 93 | } 94 | 95 | stmt, err = txn.Prepare(query) 96 | if err != nil { 97 | logger.Fatalln(err) 98 | } 99 | } 100 | // Read tokens from the XML document in a stream. 101 | t, _ := decoder.Token() 102 | 103 | // Если достигли конца xml-файла 104 | if t == nil { 105 | if i > 0 { 106 | _, err = stmt.Exec() 107 | if err != nil { 108 | logger.Fatalln(err) 109 | } 110 | 111 | err = stmt.Close() 112 | if err != nil { 113 | logger.Fatalln(err) 114 | } 115 | 116 | err = txn.Commit() 117 | if err != nil { 118 | logger.Fatalln(err) 119 | } 120 | } 121 | 122 | //c <- helpers.PrintRowsAffected(elementName, total) 123 | 124 | break 125 | } 126 | // Inspect the type of the token just read. 127 | switch se := t.(type) { 128 | case xml.StartElement: 129 | // If we just read a StartElement token 130 | inElement = se.Name.Local 131 | 132 | if inElement == elementName { 133 | total++ 134 | var item XmlObject 135 | 136 | // decode a whole chunk of following XML into the 137 | // variable item which is a ActualStatus (se above) 138 | err = decoder.DecodeElement(&item, &se) 139 | if err != nil { 140 | logger.Fatalln("Error in decode element:", err) 141 | } 142 | 143 | _, err = stmt.Exec(item.LOCATION, 144 | item.POSTALCODE, 145 | item.IFNSFL, 146 | item.TERRIFNSFL, 147 | item.IFNSUL, 148 | item.TERRIFNSUL, 149 | item.OKATO, 150 | item.OKTMO, 151 | item.UPDATEDATE, 152 | item.LANDID, 153 | item.LANDGUID, 154 | item.AOGUID, 155 | item.STARTDATE, 156 | item.ENDDATE, 157 | item.NORMDOC) 158 | 159 | if err != nil { 160 | logger.Fatalln(err) 161 | } 162 | c <- helpers.PrintRowsAffected(elementName, total) 163 | i++ 164 | } 165 | default: 166 | } 167 | 168 | } 169 | } 170 | */ 171 | -------------------------------------------------------------------------------- /structures/house_interval/house_interval_bulk.go: -------------------------------------------------------------------------------- 1 | package house_interval 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName, format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, 48 | "postal_code", 49 | "ifns_fl", 50 | "terr_ifns_fl", 51 | "ifns_ul", 52 | "terr_ifns_ul", 53 | "okato", 54 | "oktmo", 55 | "update_date", 56 | "int_start", 57 | "int_end", 58 | "house_int_id", 59 | "int_guid", 60 | "ao_guid", 61 | "start_date", 62 | "end_date", 63 | "int_status", 64 | "norm_doc", 65 | "counter") 66 | 67 | stmt, err := txn.Prepare(query) 68 | if err != nil { 69 | logger.Fatalln(err) 70 | } 71 | 72 | for { 73 | if i == 50000 { 74 | i = 0 75 | 76 | _, err = stmt.Exec() 77 | if err != nil { 78 | logger.Fatalln(err) 79 | } 80 | 81 | err = stmt.Close() 82 | if err != nil { 83 | logger.Fatalln(err) 84 | } 85 | 86 | err = txn.Commit() 87 | if err != nil { 88 | logger.Fatalln(err) 89 | } 90 | 91 | //c <- helpers.PrintRowsAffected(elementName, total) 92 | 93 | txn, err = db.Begin() 94 | if err != nil { 95 | logger.Fatalln(err) 96 | } 97 | 98 | stmt, err = txn.Prepare(query) 99 | if err != nil { 100 | logger.Fatalln(err) 101 | } 102 | } 103 | // Read tokens from the XML document in a stream. 104 | t, _ := decoder.Token() 105 | 106 | // Если достигли конца xml-файла 107 | if t == nil { 108 | if i > 0 { 109 | _, err = stmt.Exec() 110 | if err != nil { 111 | logger.Fatalln(err) 112 | } 113 | 114 | err = stmt.Close() 115 | if err != nil { 116 | logger.Fatalln(err) 117 | } 118 | 119 | err = txn.Commit() 120 | if err != nil { 121 | logger.Fatalln(err) 122 | } 123 | } 124 | 125 | //c <- helpers.PrintRowsAffected(elementName, total) 126 | 127 | break 128 | } 129 | // Inspect the type of the token just read. 130 | switch se := t.(type) { 131 | case xml.StartElement: 132 | // If we just read a StartElement token 133 | inElement = se.Name.Local 134 | 135 | if inElement == elementName { 136 | total++ 137 | var item XmlObject 138 | 139 | // decode a whole chunk of following XML into the 140 | // variable item which is a ActualStatus (se above) 141 | err = decoder.DecodeElement(&item, &se) 142 | if err != nil { 143 | logger.Fatalln("Error in decode element:", err) 144 | } 145 | 146 | _, err = stmt.Exec(item.POSTALCODE, 147 | item.IFNSFL, 148 | item.TERRIFNSFL, 149 | item.IFNSUL, 150 | item.TERRIFNSUL, 151 | item.OKATO, 152 | item.OKTMO, 153 | item.UPDATEDATE, 154 | item.INTSTART, 155 | item.INTEND, 156 | item.HOUSEINTID, 157 | item.INTGUID, 158 | item.AOGUID, 159 | item.STARTDATE, 160 | item.ENDDATE, 161 | item.INTSTATUS, 162 | item.NORMDOC, 163 | item.COUNTER) 164 | 165 | if err != nil { 166 | logger.Fatalln(err) 167 | } 168 | c <- helpers.PrintRowsAffected(elementName, total) 169 | i++ 170 | } 171 | default: 172 | } 173 | 174 | } 175 | } 176 | */ 177 | -------------------------------------------------------------------------------- /structures/normative_document/normative_document.go: -------------------------------------------------------------------------------- 1 | package normative_document 2 | 3 | import "encoding/xml" 4 | 5 | // const dateformat = "2006-01-02" 6 | // const tableName = "as_normdoc" 7 | // const elementName = "NormativeDocument" 8 | 9 | // Сведения по нормативному документу, 10 | // являющемуся основанием присвоения адресному элементу наименования 11 | type XmlObject struct { 12 | XMLName xml.Name `xml:"NormativeDocument" db:"as_normdoc"` 13 | NORMDOCID string `xml:"NORMDOCID,attr" db:"norm_doc_id"` 14 | DOCNAME *string `xml:"DOCNAME,attr,omitempty" db:"doc_name"` 15 | DOCDATE *string `xml:"DOCDATE,attr,omitempty" db:"doc_date"` 16 | DOCNUM *string `xml:"DOCNUM,attr,omitempty" db:"doc_num"` 17 | DOCTYPE int `xml:"DOCTYPE,attr" db:"doc_type"` 18 | DOCIMGID int `xml:"DOCIMGID,attr,omitempty" db:"doc_img_id"` 19 | } 20 | 21 | func Schema(tableName string) string { 22 | return `CREATE TABLE ` + tableName + ` ( 23 | norm_doc_id UUID NOT NULL, 24 | doc_name VARCHAR(1000), 25 | doc_date TIMESTAMP, 26 | doc_num VARCHAR(20), 27 | doc_type INT NOT NULL, 28 | doc_img_id INT, 29 | PRIMARY KEY (norm_doc_id));` 30 | } 31 | 32 | /* 33 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 34 | 35 | defer w.Done() 36 | // make sure log.txt exists first 37 | // use touch command to create if log.txt does not exist 38 | var logFile *os.File 39 | var err error 40 | if _, err1 := os.Stat("log.txt"); err1 == nil { 41 | logFile, err = os.OpenFile("log.txt", os.O_WRONLY, 0666) 42 | } else { 43 | logFile, err = os.Create("log.txt") 44 | } 45 | 46 | if err != nil { 47 | panic(err) 48 | } 49 | 50 | defer logFile.Close() 51 | 52 | // direct all log messages to log.txt 53 | log.SetOutput(logFile) 54 | 55 | helpers.DropAndCreateTable(schema, tableName, db) 56 | 57 | var format2 string 58 | format2 = *format 59 | fileName, err2 := helpers.SearchFile(tableName, format2) 60 | if err2 != nil { 61 | log.Println("Error searching file:", err2) 62 | return 63 | } 64 | 65 | pathToFile := format2 + "/" + fileName 66 | 67 | // Подсчитываем, сколько элементов нужно обработать 68 | //fmt.Println("Подсчет строк") 69 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 70 | // if err != nil { 71 | // fmt.Println("Error counting elements in XML file:", err) 72 | // return 73 | // } 74 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 75 | 76 | xmlFile, err := os.Open(pathToFile) 77 | if err != nil { 78 | log.Println("Error opening file:", err) 79 | return 80 | } 81 | 82 | defer xmlFile.Close() 83 | 84 | decoder := xml.NewDecoder(xmlFile) 85 | total := 0 86 | var inElement string 87 | for { 88 | // Read tokens from the XML document in a stream. 89 | t, _ := decoder.Token() 90 | if t == nil { 91 | break 92 | } 93 | // Inspect the type of the token just read. 94 | switch se := t.(type) { 95 | case xml.StartElement: 96 | // If we just read a StartElement token 97 | inElement = se.Name.Local 98 | 99 | if inElement == elementName { 100 | total++ 101 | var item XmlObject 102 | 103 | // decode a whole chunk of following XML into the 104 | // variable item which is a ActualStatus (se above) 105 | err = decoder.DecodeElement(&item, &se) 106 | if err != nil { 107 | log.Println("Error in decode element:", err) 108 | return 109 | } 110 | 111 | var err error 112 | 113 | query := `INSERT INTO ` + tableName + ` (norm_doc_id, 114 | doc_name, 115 | doc_date, 116 | doc_num, 117 | doc_type, 118 | doc_img_id 119 | ) VALUES ($1, $2, $3, $4, $5, $6)` 120 | 121 | _, err = db.Exec(query, 122 | item.NORMDOCID, 123 | item.DOCNAME, 124 | item.DOCDATE, 125 | item.DOCNUM, 126 | item.DOCTYPE, 127 | item.DOCIMGID) 128 | 129 | if err != nil { 130 | log.Fatal(err) 131 | } 132 | 133 | c <- helpers.PrintRowsAffected(elementName, total) 134 | } 135 | default: 136 | } 137 | 138 | } 139 | } 140 | */ 141 | -------------------------------------------------------------------------------- /structures/house/house_bulk.go: -------------------------------------------------------------------------------- 1 | package house 2 | 3 | /* 4 | import ( 5 | "encoding/xml" 6 | "log" 7 | "os" 8 | "sync" 9 | 10 | "github.com/jmoiron/sqlx" 11 | "github.com/lib/pq" 12 | "github.com/pavlik/fias_xml2postgresql/helpers" 13 | ) 14 | 15 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 16 | 17 | defer w.Done() 18 | 19 | helpers.DropAndCreateTable(schema, tableName, db) 20 | 21 | var format2 string 22 | format2 = *format 23 | fileName, err2 := helpers.SearchFile(tableName+"_", format2) 24 | if err2 != nil { 25 | logger.Fatalln("Error searching file:", err2) 26 | } 27 | 28 | pathToFile := format2 + "/" + fileName 29 | 30 | xmlFile, err := os.Open(pathToFile) 31 | if err != nil { 32 | logger.Fatalln("Error opening file:", err) 33 | } 34 | 35 | defer xmlFile.Close() 36 | 37 | decoder := xml.NewDecoder(xmlFile) 38 | var inElement string 39 | total := 0 40 | i := 0 41 | 42 | txn, err := db.Begin() 43 | if err != nil { 44 | logger.Fatalln(err) 45 | } 46 | 47 | query := pq.CopyIn(tableName, 48 | "house_guid", 49 | "postal_code", 50 | "ifns_fl", 51 | "terr_ifns_fl", 52 | "ifns_ul", 53 | "terr_ifns_ul", 54 | "okato", 55 | "oktmo", 56 | "update_date", 57 | "house_num", 58 | "est_status", 59 | "build_num", 60 | "struc_num", 61 | "str_status", 62 | "house_id", 63 | "ao_guid", 64 | "start_date", 65 | "end_date", 66 | "stat_status", 67 | "norm_doc", 68 | "counter") 69 | 70 | stmt, err := txn.Prepare(query) 71 | if err != nil { 72 | logger.Fatalln(err) 73 | } 74 | 75 | for { 76 | if i == 100000 { 77 | i = 0 78 | 79 | _, err = stmt.Exec() 80 | if err != nil { 81 | logger.Fatalln(err) 82 | } 83 | 84 | err = stmt.Close() 85 | if err != nil { 86 | logger.Fatalln(err) 87 | } 88 | 89 | err = txn.Commit() 90 | if err != nil { 91 | logger.Fatalln(err) 92 | } 93 | 94 | //c <- helpers.PrintRowsAffected(elementName, total) 95 | 96 | txn, err = db.Begin() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | stmt, err = txn.Prepare(query) 102 | if err != nil { 103 | logger.Fatalln(err) 104 | } 105 | } 106 | // Read tokens from the XML document in a stream. 107 | t, _ := decoder.Token() 108 | 109 | // Если достигли конца xml-файла 110 | if t == nil { 111 | if i > 0 { 112 | _, err = stmt.Exec() 113 | if err != nil { 114 | logger.Fatalln(err) 115 | } 116 | 117 | err = stmt.Close() 118 | if err != nil { 119 | logger.Fatalln(err) 120 | } 121 | 122 | err = txn.Commit() 123 | if err != nil { 124 | logger.Fatalln(err) 125 | } 126 | } 127 | 128 | //c <- helpers.PrintRowsAffected(elementName, total) 129 | 130 | break 131 | } 132 | // Inspect the type of the token just read. 133 | switch se := t.(type) { 134 | case xml.StartElement: 135 | // If we just read a StartElement token 136 | inElement = se.Name.Local 137 | 138 | if inElement == elementName { 139 | var item XmlObject 140 | 141 | // decode a whole chunk of following XML into the 142 | // variable item which is a ActualStatus (se above) 143 | err = decoder.DecodeElement(&item, &se) 144 | if err != nil { 145 | logger.Fatalln("Error in decode element:", err) 146 | } 147 | 148 | _, err = stmt.Exec(item.HOUSEGUID, 149 | item.POSTALCODE, 150 | item.IFNSFL, 151 | item.TERRIFNSFL, 152 | item.IFNSUL, 153 | item.TERRIFNSUL, 154 | item.OKATO, 155 | item.OKTMO, 156 | item.UPDATEDATE, 157 | item.HOUSENUM, 158 | item.ESTSTATUS, 159 | item.BUILDNUM, 160 | item.STRUCNUM, 161 | item.STRSTATUS, 162 | item.HOUSEID, 163 | item.AOGUID, 164 | item.STARTDATE, 165 | item.ENDDATE, 166 | item.STATSTATUS, 167 | item.NORMDOC, 168 | item.COUNTER) 169 | 170 | if err != nil { 171 | logger.Fatalln(err) 172 | } 173 | total++ 174 | i++ 175 | c <- helpers.PrintRowsAffected(elementName, total) 176 | } 177 | default: 178 | } 179 | 180 | } 181 | } 182 | */ 183 | -------------------------------------------------------------------------------- /structures/landmark/landmark.go: -------------------------------------------------------------------------------- 1 | package landmark 2 | 3 | import "encoding/xml" 4 | 5 | // 6 | // const dateformat = "2006-01-02" 7 | // const tableName = "as_landmark" 8 | // const elementName = "Landmark" 9 | 10 | // Описание мест расположения имущественных объектов 11 | type XmlObject struct { 12 | XMLName xml.Name `xml:"Landmark" db:"as_landmark"` 13 | LOCATION string `xml:"LOCATION,attr" db:"location"` 14 | POSTALCODE *string `xml:"POSTALCODE,attr,omitempty" db:"postal_code"` 15 | IFNSFL int `xml:"IFNSFL,attr,omitempty" db:"ifns_fl"` 16 | TERRIFNSFL int `xml:"TERRIFNSFL,attr,omitempty" db:"terr_ifns_fl"` 17 | IFNSUL int `xml:"IFNSUL,attr,omitempty" db:"ifns_ul"` 18 | TERRIFNSUL int `xml:"TERRIFNSUL,attr,omitempty" db:"terr_ifns_ul"` 19 | OKATO *string `xml:"OKATO,attr,omitempty" db:"okato"` 20 | OKTMO *string `xml:"OKTMO,attr,omitempty" db:"oktmo"` 21 | UPDATEDATE string `xml:"UPDATEDATE,attr" db:"update_date"` 22 | LANDID string `xml:"LANDID,attr" db:"land_id"` 23 | LANDGUID string `xml:"LANDGUID,attr" db:"land_guid"` 24 | AOGUID string `xml:"AOGUID,attr" db:"ao_guid"` 25 | STARTDATE string `xml:"STARTDATE,attr" db:"start_date"` 26 | ENDDATE string `xml:"ENDDATE,attr" db:"end_date"` 27 | NORMDOC *string `xml:"NORMDOC,attr,omitempty" db:"norm_doc"` 28 | } 29 | 30 | func Schema(tableName string) string { 31 | return `CREATE TABLE ` + tableName + ` ( 32 | location VARCHAR(500) NOT NULL, 33 | postal_code VARCHAR(6), 34 | ifns_fl INT, 35 | terr_ifns_fl INT, 36 | ifns_ul INT, 37 | terr_ifns_ul INT, 38 | okato VARCHAR(11), 39 | oktmo VARCHAR(11), 40 | update_date TIMESTAMP NOT NULL, 41 | land_id UUID NOT NULL, 42 | land_guid UUID NOT NULL, 43 | ao_guid UUID NOT NULL, 44 | start_date TIMESTAMP NOT NULL, 45 | end_date TIMESTAMP NOT NULL, 46 | norm_doc UUID, 47 | PRIMARY KEY (land_id));` 48 | } 49 | 50 | /* 51 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 52 | 53 | defer w.Done() 54 | 55 | helpers.DropAndCreateTable(schema, tableName, db) 56 | 57 | var format2 string 58 | format2 = *format 59 | fileName, err2 := helpers.SearchFile(tableName, format2) 60 | if err2 != nil { 61 | log.Println("Error searching file:", err2) 62 | return 63 | } 64 | 65 | pathToFile := format2 + "/" + fileName 66 | 67 | xmlFile, err := os.Open(pathToFile) 68 | if err != nil { 69 | log.Println("Error opening file:", err) 70 | return 71 | } 72 | 73 | defer xmlFile.Close() 74 | 75 | decoder := xml.NewDecoder(xmlFile) 76 | total := 0 77 | var inElement string 78 | for { 79 | // Read tokens from the XML document in a stream. 80 | t, _ := decoder.Token() 81 | if t == nil { 82 | break 83 | } 84 | // Inspect the type of the token just read. 85 | switch se := t.(type) { 86 | case xml.StartElement: 87 | // If we just read a StartElement token 88 | inElement = se.Name.Local 89 | 90 | if inElement == elementName { 91 | total++ 92 | var item XmlObject 93 | 94 | // decode a whole chunk of following XML into the 95 | // variable item which is a ActualStatus (se above) 96 | err = decoder.DecodeElement(&item, &se) 97 | if err != nil { 98 | log.Println("Error in decode element:", err) 99 | return 100 | } 101 | 102 | //fmt.Println(item, "\n\n") 103 | 104 | var err error 105 | 106 | query := `INSERT INTO ` + tableName + ` (location, 107 | postal_code, 108 | ifns_fl, 109 | terr_ifns_fl, 110 | ifns_ul, 111 | terr_ifns_ul, 112 | okato, 113 | oktmo, 114 | update_date, 115 | land_id, 116 | land_guid, 117 | ao_guid, 118 | start_date, 119 | end_date, 120 | norm_doc 121 | ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 122 | $11, $12, $13, $14, $15)` 123 | 124 | _, err = db.Exec(query, 125 | item.LOCATION, 126 | item.POSTALCODE, 127 | item.IFNSFL, 128 | item.TERRIFNSFL, 129 | item.IFNSUL, 130 | item.TERRIFNSUL, 131 | item.OKATO, 132 | item.OKTMO, 133 | item.UPDATEDATE, 134 | item.LANDID, 135 | item.LANDGUID, 136 | item.AOGUID, 137 | item.STARTDATE, 138 | item.ENDDATE, 139 | item.NORMDOC) 140 | 141 | if err != nil { 142 | log.Fatal(err) 143 | } 144 | 145 | c <- helpers.PrintRowsAffected(elementName, total) 146 | } 147 | default: 148 | } 149 | } 150 | } 151 | */ 152 | -------------------------------------------------------------------------------- /helpers/export.go: -------------------------------------------------------------------------------- 1 | package helpers 2 | 3 | import ( 4 | "encoding/xml" 5 | "log" 6 | "os" 7 | "reflect" 8 | "strings" 9 | "sync" 10 | 11 | "github.com/jmoiron/sqlx" 12 | "github.com/lib/pq" 13 | ) 14 | 15 | type xmlObjectName struct { 16 | tableName string 17 | elementName string 18 | } 19 | 20 | func extractXMLObjectName(xmlObject interface{}) xmlObjectName { 21 | v := reflect.ValueOf(xmlObject).Elem() 22 | field := v.Type().Field(0) 23 | obj := xmlObjectName{tableName: field.Tag.Get("db"), elementName: field.Tag.Get("xml")} 24 | return obj 25 | } 26 | 27 | func extractFeilds(xmlObject interface{}) []string { 28 | v := reflect.ValueOf(xmlObject).Elem() 29 | fields := make([]string, v.NumField()-1) 30 | 31 | for i := 0; i < v.NumField(); i++ { 32 | field := v.Type().Field(i) 33 | if field.Type.String() != "xml.Name" { 34 | fields[i-1] = field.Tag.Get("db") 35 | } 36 | } 37 | return fields 38 | } 39 | 40 | func extractValues(xmlObject interface{}) []interface{} { 41 | //fmt.Println(xmlObject) 42 | s := reflect.ValueOf(xmlObject).Elem() 43 | values := make([]interface{}, s.NumField()-1) 44 | 45 | for i := 0; i < s.NumField(); i++ { 46 | f := s.Field(i) 47 | if f.Type().Name() != "xml.Name" { 48 | if f.Kind() == reflect.String { 49 | values[i-1] = f.String() 50 | } else if f.Kind() == reflect.Int { 51 | values[i-1] = f.Int() 52 | } else if f.Kind() == reflect.Bool { 53 | values[i-1] = f.Bool() 54 | } 55 | } 56 | } 57 | 58 | return values 59 | } 60 | 61 | // ExportBulk экспортирует данные из xml-файла в таблицу указанную в описании xml-структуры 62 | func ExportBulk(schema func(tableName string) string, xmlObject interface{}, w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 63 | 64 | defer w.Done() 65 | 66 | const dateformat = "2006-01-02" 67 | 68 | objName := extractXMLObjectName(xmlObject) 69 | fields := extractFeilds(xmlObject) 70 | searchFileName := objName.tableName 71 | objName.tableName = strings.TrimSuffix(objName.tableName, "_") 72 | 73 | DropAndCreateTable(schema(objName.tableName), objName.tableName, db) 74 | 75 | var format2 string 76 | format2 = *format 77 | fileName, err2 := SearchFile(searchFileName, format2) 78 | if err2 != nil { 79 | logger.Fatalln("Error searching file:", err2) 80 | } 81 | 82 | pathToFile := format2 + "/" + fileName 83 | 84 | xmlFile, err := os.Open(pathToFile) 85 | if err != nil { 86 | logger.Fatalln("Error opening file:", err) 87 | } 88 | 89 | defer xmlFile.Close() 90 | 91 | decoder := xml.NewDecoder(xmlFile) 92 | var inElement string 93 | total := 0 94 | i := 0 95 | 96 | txn, err := db.Begin() 97 | if err != nil { 98 | logger.Fatalln(err) 99 | } 100 | 101 | query := pq.CopyIn(objName.tableName, fields...) 102 | 103 | stmt, err := txn.Prepare(query) 104 | if err != nil { 105 | logger.Fatalln(err) 106 | } 107 | 108 | for { 109 | if i == 50000 { 110 | i = 0 111 | 112 | _, err = stmt.Exec() 113 | if err != nil { 114 | logger.Fatalln(err) 115 | } 116 | 117 | err = stmt.Close() 118 | if err != nil { 119 | logger.Fatalln(err) 120 | } 121 | 122 | err = txn.Commit() 123 | if err != nil { 124 | logger.Fatalln(err) 125 | } 126 | 127 | txn, err = db.Begin() 128 | if err != nil { 129 | logger.Fatalln(err) 130 | } 131 | 132 | stmt, err = txn.Prepare(query) 133 | if err != nil { 134 | logger.Fatalln(err) 135 | } 136 | } 137 | 138 | t, _ := decoder.Token() 139 | 140 | // Если достигли конца xml-файла 141 | if t == nil { 142 | if i > 0 { 143 | _, err = stmt.Exec() 144 | if err != nil { 145 | logger.Fatalln(err) 146 | } 147 | 148 | err = stmt.Close() 149 | if err != nil { 150 | logger.Fatalln(err) 151 | } 152 | 153 | err = txn.Commit() 154 | if err != nil { 155 | logger.Fatalln(err) 156 | } 157 | } 158 | 159 | //c <- helpers.PrintRowsAffected(elementName, total) 160 | 161 | break 162 | } 163 | // Inspect the type of the token just read. 164 | switch se := t.(type) { 165 | case xml.StartElement: 166 | // If we just read a StartElement token 167 | inElement = se.Name.Local 168 | 169 | if inElement == objName.elementName { 170 | total++ 171 | //var item xmlObject 172 | 173 | // decode a whole chunk of following XML into the 174 | // variable item which is a ActualStatus (se above) 175 | err = decoder.DecodeElement(&xmlObject, &se) 176 | if err != nil { 177 | logger.Fatalln("Error in decode element:", err) 178 | } 179 | 180 | values := extractValues(xmlObject) 181 | //logger.Println(values) 182 | _, err = stmt.Exec(values...) 183 | 184 | if err != nil { 185 | logger.Fatalln(err) 186 | } 187 | c <- PrintRowsAffected(objName.elementName, total) 188 | i++ 189 | } 190 | default: 191 | } 192 | 193 | } 194 | 195 | // Если закончили обработку всех записей, ставим вначале строки восклицательный знак. 196 | // Признак того, что все записи в данном файле обработаны 197 | c <- "!" + PrintRowsAffected(objName.elementName, total) 198 | } 199 | -------------------------------------------------------------------------------- /structures/house/house.go: -------------------------------------------------------------------------------- 1 | package house 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | //const dateformat = "2006-01-02" 8 | 9 | // Сведения по номерам домов улиц городов и населенных пунктов, номера земельных участков и т.п 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"House" db:"as_house_"` 12 | POSTALCODE *string `xml:"POSTALCODE,attr,omitempty" db:"postal_code"` 13 | IFNSFL int `xml:"IFNSFL,attr,omitempty" db:"ifns_fl"` 14 | TERRIFNSFL int `xml:"TERRIFNSFL,attr,omitempty" db:"terr_ifns_fl"` 15 | IFNSUL int `xml:"IFNSUL,attr,omitempty" db:"ifns_ul"` 16 | TERRIFNSUL int `xml:"TERRIFNSUL,attr,omitempty" db:"terr_ifns_ul"` 17 | OKATO *string `xml:"OKATO,attr,omitempty" db:"okato"` 18 | OKTMO *string `xml:"OKTMO,attr,omitempty" db:"oktmo"` 19 | UPDATEDATE string `xml:"UPDATEDATE,attr" db:"update_date"` 20 | HOUSENUM *string `xml:"HOUSENUM,attr,omitempty" db:"house_num"` 21 | ESTSTATUS int `xml:"ESTSTATUS,attr" db:"est_status"` 22 | BUILDNUM *string `xml:"BUILDNUM,attr,omitempty" db:"build_num"` 23 | STRUCNUM *string `xml:"STRUCNUM,attr,omitempty" db:"struc_num"` 24 | STRSTATUS int `xml:"STRSTATUS,attr" db:"str_status"` 25 | HOUSEID string `xml:"HOUSEID,attr" db:"house_id"` 26 | HOUSEGUID string `xml:"HOUSEGUID,attr" db:"house_guid"` 27 | AOGUID string `xml:"AOGUID,attr" db:"ao_guid"` 28 | STARTDATE string `xml:"STARTDATE,attr" db:"start_date"` 29 | ENDDATE string `xml:"ENDDATE,attr" db:"end_date"` 30 | STATSTATUS int `xml:"STATSTATUS,attr" db:"stat_status"` 31 | NORMDOC *string `xml:"NORMDOC,attr,omitempty" db:"norm_doc"` 32 | COUNTER int `xml:"COUNTER,attr" db:"counter"` 33 | } 34 | 35 | // схема таблицы в БД 36 | 37 | // const tableName = "as_house" 38 | // const elementName = "House" 39 | 40 | func Schema(tableName string) string { 41 | return `CREATE TABLE ` + tableName + ` ( 42 | house_id UUID NOT NULL, 43 | postal_code VARCHAR(6), 44 | ifns_fl INT, 45 | terr_ifns_fl INT, 46 | ifns_ul INT, 47 | terr_ifns_ul INT, 48 | okato VARCHAR(11), 49 | oktmo VARCHAR(11), 50 | update_date TIMESTAMP NOT NULL, 51 | house_num VARCHAR(20), 52 | est_status INT NOT NULL, 53 | build_num VARCHAR(20), 54 | struc_num VARCHAR(20), 55 | str_status INT, 56 | house_guid UUID NOT NULL, 57 | ao_guid UUID NOT NULL, 58 | start_date TIMESTAMP NOT NULL, 59 | end_date TIMESTAMP NOT NULL, 60 | stat_status INT NOT NULL, 61 | norm_doc UUID, 62 | counter INT NOT NULL, 63 | PRIMARY KEY (house_id));` 64 | } 65 | 66 | /* 67 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 68 | 69 | defer w.Done() 70 | helpers.DropAndCreateTable(schema, tableName, db) 71 | 72 | var format2 string 73 | format2 = *format 74 | fileName, err2 := helpers.SearchFile(tableName+"_", format2) 75 | if err2 != nil { 76 | fmt.Println("Error searching file:", err2) 77 | return 78 | } 79 | 80 | pathToFile := format2 + "/" + fileName 81 | 82 | xmlFile, err := os.Open(pathToFile) 83 | if err != nil { 84 | fmt.Println("Error opening file:", err) 85 | return 86 | } 87 | 88 | defer xmlFile.Close() 89 | 90 | decoder := xml.NewDecoder(xmlFile) 91 | total := 0 92 | var inElement string 93 | for { 94 | // Read tokens from the XML document in a stream. 95 | t, _ := decoder.Token() 96 | if t == nil { 97 | break 98 | } 99 | // Inspect the type of the token just read. 100 | switch se := t.(type) { 101 | case xml.StartElement: 102 | // If we just read a StartElement token 103 | inElement = se.Name.Local 104 | 105 | if inElement == elementName { 106 | total++ 107 | var item XmlObject 108 | 109 | // decode a whole chunk of following XML into the 110 | // variable item which is a ActualStatus (se above) 111 | err = decoder.DecodeElement(&item, &se) 112 | if err != nil { 113 | fmt.Println("Error in decode element:", err) 114 | return 115 | } 116 | 117 | query := `INSERT INTO ` + tableName + ` (house_guid, 118 | postal_code, 119 | ifns_fl, 120 | terr_ifns_fl, 121 | ifns_ul, 122 | terr_ifns_ul, 123 | okato, 124 | oktmo, 125 | update_date, 126 | house_num, 127 | est_status, 128 | build_num, 129 | struc_num, 130 | str_status, 131 | house_id, 132 | ao_guid, 133 | start_date, 134 | end_date, 135 | stat_status, 136 | norm_doc, 137 | counter 138 | ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 139 | $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, 140 | $21)` 141 | 142 | db.MustExec(query, 143 | item.HOUSEGUID, 144 | item.POSTALCODE, 145 | item.IFNSFL, 146 | item.TERRIFNSFL, 147 | item.IFNSUL, 148 | item.TERRIFNSUL, 149 | item.OKATO, 150 | item.OKTMO, 151 | item.UPDATEDATE, 152 | item.HOUSENUM, 153 | item.ESTSTATUS, 154 | item.BUILDNUM, 155 | item.STRUCNUM, 156 | item.STRSTATUS, 157 | item.HOUSEID, 158 | item.AOGUID, 159 | item.STARTDATE, 160 | item.ENDDATE, 161 | item.STATSTATUS, 162 | item.NORMDOC, 163 | item.COUNTER) 164 | 165 | c <- helpers.PrintRowsAffected(elementName, total) 166 | } 167 | default: 168 | } 169 | 170 | } 171 | 172 | //fmt.Printf("Total processed items in AddressObjects: %d \n", total) 173 | } 174 | */ 175 | -------------------------------------------------------------------------------- /structures/house_interval/house_interval.go: -------------------------------------------------------------------------------- 1 | package house_interval 2 | 3 | import ( 4 | "encoding/xml" 5 | ) 6 | 7 | //const dateformat = "2006-01-02" 8 | 9 | // Интервалы домов 10 | type XmlObject struct { 11 | XMLName xml.Name `xml:"HouseInterval" db:"as_houseint"` 12 | POSTALCODE *string `xml:"POSTALCODE,attr,omitempty" db:"postal_code"` 13 | IFNSFL int `xml:"IFNSFL,attr,omitempty" db:"ifns_fl"` 14 | TERRIFNSFL int `xml:"TERRIFNSFL,attr,omitempty" db:"terr_ifns_fl"` 15 | IFNSUL int `xml:"IFNSUL,attr,omitempty" db:"ifns_ul"` 16 | TERRIFNSUL int `xml:"TERRIFNSUL,attr,omitempty" db:"terr_ifns_ul"` 17 | OKATO *string `xml:"OKATO,attr,omitempty" db:"okato"` 18 | OKTMO *string `xml:"OKTMO,attr,omitempty" db:"oktmo"` 19 | UPDATEDATE string `xml:"UPDATEDATE,attr" db:"update_date"` 20 | INTSTART int `xml:"INTSTART,attr" db:"int_start"` 21 | INTEND int `xml:"INTEND,attr" db:"int_end"` 22 | HOUSEINTID string `xml:"HOUSEINTID,attr" db:"house_int_id"` 23 | INTGUID string `xml:"INTGUID,attr" db:"int_guid"` 24 | AOGUID string `xml:"AOGUID,attr" db:"ao_guid"` 25 | STARTDATE string `xml:"STARTDATE,attr" db:"start_date"` 26 | ENDDATE string `xml:"ENDDATE,attr" db:"end_date"` 27 | INTSTATUS int `xml:"INTSTATUS,attr" db:"int_status"` 28 | NORMDOC *string `xml:"NORMDOC,attr,omitempty" db:"norm_doc"` 29 | COUNTER int `xml:"COUNTER,attr" db:"counter"` 30 | } 31 | 32 | // схема таблицы в БД 33 | // const tableName = "as_houseint" 34 | // const elementName = "HouseInterval" 35 | 36 | func Schema(tableName string) string { 37 | return `CREATE TABLE ` + tableName + ` ( 38 | postal_code VARCHAR(6), 39 | ifns_fl INT, 40 | terr_ifns_fl INT, 41 | ifns_ul INT, 42 | terr_ifns_ul INT, 43 | okato VARCHAR(11), 44 | oktmo VARCHAR(11), 45 | update_date TIMESTAMP NOT NULL, 46 | int_start INT NOT NULL, 47 | int_end INT NOT NULL, 48 | house_int_id UUID NOT NULL, 49 | int_guid UUID NOT NULL, 50 | ao_guid UUID NOT NULL, 51 | start_date TIMESTAMP NOT NULL, 52 | end_date TIMESTAMP NOT NULL, 53 | int_status INT NOT NULL, 54 | norm_doc UUID, 55 | counter INT NOT NULL, 56 | PRIMARY KEY (house_int_id));` 57 | } 58 | 59 | /* 60 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 61 | 62 | defer w.Done() 63 | helpers.DropAndCreateTable(schema, tableName, db) 64 | 65 | var format2 string 66 | format2 = *format 67 | fileName, err2 := helpers.SearchFile(tableName, format2) 68 | if err2 != nil { 69 | fmt.Println("Error searching file:", err2) 70 | return 71 | } 72 | 73 | pathToFile := format2 + "/" + fileName 74 | 75 | // Подсчитываем, сколько элементов нужно обработать 76 | //fmt.Println("Подсчет строк") 77 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 78 | // if err != nil { 79 | // fmt.Println("Error counting elements in XML file:", err) 80 | // return 81 | // } 82 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 83 | 84 | xmlFile, err := os.Open(pathToFile) 85 | if err != nil { 86 | fmt.Println("Error opening file:", err) 87 | return 88 | } 89 | 90 | defer xmlFile.Close() 91 | 92 | decoder := xml.NewDecoder(xmlFile) 93 | total := 0 94 | var inElement string 95 | for { 96 | // Read tokens from the XML document in a stream. 97 | t, _ := decoder.Token() 98 | if t == nil { 99 | break 100 | } 101 | // Inspect the type of the token just read. 102 | switch se := t.(type) { 103 | case xml.StartElement: 104 | // If we just read a StartElement token 105 | inElement = se.Name.Local 106 | 107 | if inElement == elementName { 108 | total++ 109 | var item XmlObject 110 | 111 | // decode a whole chunk of following XML into the 112 | // variable item which is a ActualStatus (se above) 113 | err = decoder.DecodeElement(&item, &se) 114 | if err != nil { 115 | fmt.Println("Error in decode element:", err) 116 | return 117 | } 118 | 119 | //fmt.Println(item, "\n\n") 120 | 121 | var err error 122 | 123 | query := `INSERT INTO ` + tableName + ` (postal_code, 124 | ifns_fl, 125 | terr_ifns_fl, 126 | ifns_ul, 127 | terr_ifns_ul, 128 | okato, 129 | oktmo, 130 | update_date, 131 | int_start, 132 | int_end, 133 | house_int_id, 134 | int_guid, 135 | ao_guid, 136 | start_date, 137 | end_date, 138 | int_status, 139 | norm_doc, 140 | counter 141 | ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 142 | $11, $12, $13, $14, $15, $16, $17, $18)` 143 | 144 | _, err = db.Exec(query, 145 | item.POSTALCODE, 146 | item.IFNSFL, 147 | item.TERRIFNSFL, 148 | item.IFNSUL, 149 | item.TERRIFNSUL, 150 | item.OKATO, 151 | item.OKTMO, 152 | item.UPDATEDATE, 153 | item.INTSTART, 154 | item.INTEND, 155 | item.HOUSEINTID, 156 | item.INTGUID, 157 | item.AOGUID, 158 | item.STARTDATE, 159 | item.ENDDATE, 160 | item.INTSTATUS, 161 | item.NORMDOC, 162 | item.COUNTER) 163 | 164 | if err != nil { 165 | log.Fatal(err) 166 | } 167 | 168 | c <- helpers.PrintRowsAffected(elementName, total) 169 | } 170 | default: 171 | } 172 | 173 | } 174 | 175 | //fmt.Printf("Total processed items in AddressObjects: %d \n", total) 176 | } 177 | */ 178 | -------------------------------------------------------------------------------- /structures/address_object/address_object.go: -------------------------------------------------------------------------------- 1 | package address_object 2 | 3 | import ( 4 | "encoding/xml" 5 | 6 | _ "github.com/lib/pq" 7 | ) 8 | 9 | // const dateformat = "2006-01-02" 10 | // const tableName = "as_addrobj" 11 | // const elementName = "Object" 12 | 13 | // Классификатор адресообразующих элементов 14 | type XmlObject struct { 15 | XMLName xml.Name `xml:"Object" db:"as_addrobj"` 16 | AOGUID string `xml:"AOGUID,attr" db:"ao_guid"` 17 | FORMALNAME string `xml:"FORMALNAME,attr" db:"formal_name"` 18 | REGIONCODE int `xml:"REGIONCODE,attr" db:"region_code"` 19 | AUTOCODE int `xml:"AUTOCODE,attr" db:"auto_code"` 20 | AREACODE int `xml:"AREACODE,attr" db:"area_code"` 21 | CITYCODE int `xml:"CITYCODE,attr" db:"city_code"` 22 | CTARCODE int `xml:"CTARCODE,attr" db:"ctar_code"` 23 | PLACECODE int `xml:"PLACECODE,attr" db:"place_code"` 24 | STREETCODE int `xml:"STREETCODE,attr,omitempty" db:"street_code"` 25 | EXTRCODE int `xml:"EXTRCODE,attr" db:"extr_code"` 26 | SEXTCODE int `xml:"SEXTCODE,attr" db:"sext_code"` 27 | OFFNAME *string `xml:"OFFNAME,attr,omitempty" db:"off_name"` 28 | POSTALCODE *string `xml:"POSTALCODE,attr,omitempty" db:"postal_code"` 29 | IFNSFL int `xml:"IFNSFL,attr,omitempty" db:"ifns_fl"` 30 | TERRIFNSFL int `xml:"TERRIFNSFL,attr,omitempty" db:"terr_ifns_fl"` 31 | IFNSUL int `xml:"IFNSUL,attr,omitempty" db:"ifns_ul"` 32 | TERRIFNSUL int `xml:"TERRIFNSUL,attr,omitempty" db:"terr_ifns_ul"` 33 | OKATO *string `xml:"OKATO,attr,omitempty" db:"okato"` 34 | OKTMO *string `xml:"OKTMO,attr,omitempty" db:"oktmo"` 35 | UPDATEDATE string `xml:"UPDATEDATE,attr" db:"update_date"` 36 | SHORTNAME string `xml:"SHORTNAME,attr" db:"short_name"` 37 | AOLEVEL int `xml:"AOLEVEL,attr" db:"ao_level"` 38 | PARENTGUID *string `xml:"PARENTGUID,attr,omitempty" db:"parent_guid"` 39 | AOID string `xml:"AOID,attr" db:"ao_id"` 40 | PREVID *string `xml:"PREVID,attr,omitempty" db:"prev_id"` 41 | NEXTID *string `xml:"NEXTID,attr,omitempty" db:"next_id"` 42 | CODE *string `xml:"CODE,attr,omitempty" db:"code"` 43 | PLAINCODE *string `xml:"PLAINCODE,attr,omitempty" db:"plain_code"` 44 | ACTSTATUS bool `xml:"ACTSTATUS,attr" db:"act_status"` 45 | CENTSTATUS bool `xml:"CENTSTATUS,attr" db:"cent_status"` 46 | OPERSTATUS int `xml:"OPERSTATUS,attr" db:"oper_status"` 47 | CURRSTATUS int `xml:"CURRSTATUS,attr" db:"curr_status"` 48 | STARTDATE string `xml:"STARTDATE,attr" db:"start_date"` 49 | ENDDATE string `xml:"ENDDATE,attr" db:"end_date"` 50 | NORMDOC *string `xml:"NORMDOC,attr,omitempty" db:"norm_doc"` 51 | LIVESTATUS bool `xml:"LIVESTATUS,attr" db:"live_status"` 52 | } 53 | 54 | func Schema(tableName string) string { 55 | return `CREATE TABLE ` + tableName + ` ( 56 | ao_guid UUID NOT NULL, 57 | formal_name VARCHAR(120) NOT NULL, 58 | region_code INT NOT NULL, 59 | auto_code INT NOT NULL, 60 | area_code INT NOT NULL, 61 | city_code INT NOT NULL, 62 | ctar_code INT NOT NULL, 63 | place_code INT NOT NULL, 64 | street_code INT, 65 | extr_code INT NOT NULL, 66 | sext_code INT NOT NULL, 67 | off_name VARCHAR(120), 68 | postal_code VARCHAR(6), 69 | ifns_fl INT, 70 | terr_ifns_fl INT, 71 | ifns_ul INT, 72 | terr_ifns_ul INT, 73 | okato VARCHAR(11), 74 | oktmo VARCHAR(11), 75 | update_date TIMESTAMP NOT NULL, 76 | short_name VARCHAR(10) NOT NULL, 77 | ao_level INT NOT NULL, 78 | parent_guid UUID, 79 | ao_id UUID NOT NULL, 80 | prev_id UUID, 81 | next_id UUID, 82 | code VARCHAR(17), 83 | plain_code VARCHAR(15), 84 | act_status BOOL NOT NULL, 85 | cent_status BOOL NOT NULL, 86 | oper_status INT NOT NULL, 87 | curr_status INT NOT NULL, 88 | start_date TIMESTAMP NOT NULL, 89 | end_date TIMESTAMP NOT NULL, 90 | norm_doc UUID, 91 | live_status BOOL NOT NULL, 92 | PRIMARY KEY (ao_id));` 93 | } 94 | 95 | /* 96 | func Export(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string) { 97 | 98 | defer w.Done() 99 | // make sure log.txt exists first 100 | // use touch command to create if log.txt does not exist 101 | var logFile *os.File 102 | var err error 103 | if _, err1 := os.Stat("log.txt"); err1 == nil { 104 | logFile, err = os.OpenFile("log.txt", os.O_WRONLY, 0666) 105 | } else { 106 | logFile, err = os.Create("log.txt") 107 | } 108 | 109 | if err != nil { 110 | panic(err) 111 | } 112 | 113 | defer logFile.Close() 114 | 115 | // direct all log messages to log.txt 116 | log.SetOutput(logFile) 117 | 118 | helpers.DropAndCreateTable(schema, tableName, db) 119 | 120 | var format2 string 121 | format2 = *format 122 | fileName, err2 := helpers.SearchFile(tableName, format2) 123 | if err2 != nil { 124 | log.Println("Error searching file:", err2) 125 | return 126 | } 127 | 128 | pathToFile := format2 + "/" + fileName 129 | 130 | // Подсчитываем, сколько элементов нужно обработать 131 | //fmt.Println("Подсчет строк") 132 | // _, err := helpers.CountElementsInXML(pathToFile, elementName) 133 | // if err != nil { 134 | // fmt.Println("Error counting elements in XML file:", err) 135 | // return 136 | // } 137 | //fmt.Println("\nВ ", elementName, " содержится ", countedElements, " строк") 138 | 139 | xmlFile, err := os.Open(pathToFile) 140 | if err != nil { 141 | log.Println("Error opening file:", err) 142 | return 143 | } 144 | 145 | defer xmlFile.Close() 146 | 147 | decoder := xml.NewDecoder(xmlFile) 148 | total := 0 149 | var inElement string 150 | for { 151 | // Read tokens from the XML document in a stream. 152 | t, _ := decoder.Token() 153 | if t == nil { 154 | break 155 | } 156 | // Inspect the type of the token just read. 157 | switch se := t.(type) { 158 | case xml.StartElement: 159 | // If we just read a StartElement token 160 | inElement = se.Name.Local 161 | 162 | if inElement == elementName { 163 | total++ 164 | var item XmlObject 165 | 166 | // decode a whole chunk of following XML into the 167 | // variable item which is a ActualStatus (se above) 168 | err = decoder.DecodeElement(&item, &se) 169 | if err != nil { 170 | log.Println("Error in decode element:", err) 171 | return 172 | } 173 | 174 | //fmt.Println(item, "\n\n") 175 | 176 | var err error 177 | 178 | query := `INSERT INTO ` + tableName + ` (ao_guid, 179 | formal_name, 180 | region_code, 181 | auto_code, 182 | area_code, 183 | city_code, 184 | ctar_code, 185 | place_code, 186 | street_code, 187 | extr_code, 188 | sext_code, 189 | off_name, 190 | postal_code, 191 | ifns_fl, 192 | terr_ifns_fl, 193 | ifns_ul, 194 | terr_ifns_ul, 195 | okato, 196 | oktmo, 197 | update_date, 198 | short_name, 199 | ao_level, 200 | parent_guid, 201 | ao_id, 202 | prev_id, 203 | next_id, 204 | code, 205 | plain_code, 206 | act_status, 207 | cent_status, 208 | oper_status, 209 | curr_status, 210 | start_date, 211 | end_date, 212 | norm_doc, 213 | live_status 214 | ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 215 | $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, 216 | $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, 217 | $31, $32, $33, $34, $35, $36)` 218 | 219 | _, err = db.Exec(query, 220 | item.AOGUID, 221 | item.FORMALNAME, 222 | item.REGIONCODE, 223 | item.AUTOCODE, 224 | item.AREACODE, 225 | item.CITYCODE, 226 | item.CTARCODE, 227 | item.PLACECODE, 228 | item.STREETCODE, 229 | item.EXTRCODE, 230 | item.SEXTCODE, 231 | item.OFFNAME, 232 | item.POSTALCODE, 233 | item.IFNSFL, 234 | item.TERRIFNSFL, 235 | item.IFNSUL, 236 | item.TERRIFNSUL, 237 | item.OKATO, 238 | item.OKTMO, 239 | item.UPDATEDATE, 240 | item.SHORTNAME, 241 | item.AOLEVEL, 242 | item.PARENTGUID, 243 | item.AOID, 244 | item.PREVID, 245 | item.NEXTID, 246 | item.CODE, 247 | item.PLAINCODE, 248 | item.ACTSTATUS, 249 | item.CENTSTATUS, 250 | item.OPERSTATUS, 251 | item.CURRSTATUS, 252 | item.STARTDATE, 253 | item.ENDDATE, 254 | item.NORMDOC, 255 | item.LIVESTATUS) 256 | 257 | if err != nil { 258 | log.Fatal(err) 259 | } 260 | 261 | c <- helpers.PrintRowsAffected(elementName, total) 262 | } 263 | default: 264 | } 265 | 266 | } 267 | 268 | //fmt.Printf("\nВсего в "+elementName+" обработано %d строк\n", total) 269 | } 270 | */ 271 | -------------------------------------------------------------------------------- /structures/address_object/address_object_bulk.go: -------------------------------------------------------------------------------- 1 | package address_object 2 | 3 | // import ( 4 | // "encoding/xml" 5 | // 6 | // "github.com/pavlik/fias_xml2postgresql/helpers" 7 | // ) 8 | // 9 | // func InitAdressObject() helpers.ExportParams { 10 | // tableName := "as_addrobj" 11 | // elementName := "Object" 12 | // 13 | // // Классификатор адресообразующих элементов 14 | // type xmlObject struct { 15 | // XMLName xml.Name `xml:"Object"` 16 | // AOGUID string `xml:"AOGUID,attr"` 17 | // FORMALNAME string `xml:"FORMALNAME,attr"` 18 | // REGIONCODE int `xml:"REGIONCODE,attr"` 19 | // AUTOCODE int `xml:"AUTOCODE,attr"` 20 | // AREACODE int `xml:"AREACODE,attr"` 21 | // CITYCODE int `xml:"CITYCODE,attr"` 22 | // CTARCODE int `xml:"CTARCODE,attr"` 23 | // PLACECODE int `xml:"PLACECODE,attr"` 24 | // STREETCODE int `xml:"STREETCODE,attr,omitempty"` 25 | // EXTRCODE int `xml:"EXTRCODE,attr"` 26 | // SEXTCODE int `xml:"SEXTCODE,attr"` 27 | // OFFNAME *string `xml:"OFFNAME,attr,omitempty"` 28 | // POSTALCODE *string `xml:"POSTALCODE,attr,omitempty"` 29 | // IFNSFL int `xml:"IFNSFL,attr,omitempty"` 30 | // TERRIFNSFL int `xml:"TERRIFNSFL,attr,omitempty"` 31 | // IFNSUL int `xml:"IFNSUL,attr,omitempty"` 32 | // TERRIFNSUL int `xml:"TERRIFNSUL,attr,omitempty"` 33 | // OKATO *string `xml:"OKATO,attr,omitempty"` 34 | // OKTMO *string `xml:"OKTMO,attr,omitempty"` 35 | // UPDATEDATE string `xml:"UPDATEDATE,attr"` 36 | // SHORTNAME string `xml:"SHORTNAME,attr"` 37 | // AOLEVEL int `xml:"AOLEVEL,attr"` 38 | // PARENTGUID *string `xml:"PARENTGUID,attr,omitempty"` 39 | // AOID string `xml:"AOID,attr"` 40 | // PREVID *string `xml:"PREVID,attr,omitempty"` 41 | // NEXTID *string `xml:"NEXTID,attr,omitempty"` 42 | // CODE *string `xml:"CODE,attr,omitempty"` 43 | // PLAINCODE *string `xml:"PLAINCODE,attr,omitempty"` 44 | // ACTSTATUS bool `xml:"ACTSTATUS,attr"` 45 | // CENTSTATUS bool `xml:"CENTSTATUS,attr"` 46 | // OPERSTATUS int `xml:"OPERSTATUS,attr"` 47 | // CURRSTATUS int `xml:"CURRSTATUS,attr"` 48 | // STARTDATE string `xml:"STARTDATE,attr"` 49 | // ENDDATE string `xml:"ENDDATE,attr"` 50 | // NORMDOC *string `xml:"NORMDOC,attr,omitempty"` 51 | // LIVESTATUS bool `xml:"LIVESTATUS,attr"` 52 | // } 53 | // 54 | // schema := `CREATE TABLE ` + tableName + ` ( 55 | // ao_guid UUID NOT NULL, 56 | // formal_name VARCHAR(120) NOT NULL, 57 | // region_code INT NOT NULL, 58 | // auto_code INT NOT NULL, 59 | // area_code INT NOT NULL, 60 | // city_code INT NOT NULL, 61 | // ctar_code INT NOT NULL, 62 | // place_code INT NOT NULL, 63 | // street_code INT, 64 | // extr_code INT NOT NULL, 65 | // sext_code INT NOT NULL, 66 | // off_name VARCHAR(120), 67 | // postal_code VARCHAR(6), 68 | // ifns_fl INT, 69 | // terr_ifns_fl INT, 70 | // ifns_ul INT, 71 | // terr_ifns_ul INT, 72 | // okato VARCHAR(11), 73 | // oktmo VARCHAR(11), 74 | // update_date TIMESTAMP NOT NULL, 75 | // short_name VARCHAR(10) NOT NULL, 76 | // ao_level INT NOT NULL, 77 | // parent_guid UUID, 78 | // ao_id UUID NOT NULL, 79 | // prev_id UUID, 80 | // next_id UUID, 81 | // code VARCHAR(17), 82 | // plain_code VARCHAR(15), 83 | // act_status BOOL NOT NULL, 84 | // cent_status BOOL NOT NULL, 85 | // oper_status INT NOT NULL, 86 | // curr_status INT NOT NULL, 87 | // start_date TIMESTAMP NOT NULL, 88 | // end_date TIMESTAMP NOT NULL, 89 | // norm_doc UUID, 90 | // live_status BOOL NOT NULL, 91 | // PRIMARY KEY (ao_id));` 92 | // 93 | // ao := new(helpers.ExportParams) 94 | // 95 | // ao.tableName = tableName 96 | // ao.elementName = elementName 97 | // ao.schema = schema 98 | // ao.xmlObject = xmlObject 99 | // ao.fields = []string{"ao_guid", 100 | // "formal_name", 101 | // "region_code", 102 | // "auto_code", 103 | // "area_code", 104 | // "city_code", 105 | // "ctar_code", 106 | // "place_code", 107 | // "street_code", 108 | // "extr_code", 109 | // "sext_code", 110 | // "off_name", 111 | // "postal_code", 112 | // "ifns_fl", 113 | // "terr_ifns_fl", 114 | // "ifns_ul", 115 | // "terr_ifns_ul", 116 | // "okato", 117 | // "oktmo", 118 | // "update_date", 119 | // "short_name", 120 | // "ao_level", 121 | // "parent_guid", 122 | // "ao_id", 123 | // "prev_id", 124 | // "next_id", 125 | // "code", 126 | // "plain_code", 127 | // "act_status", 128 | // "cent_status", 129 | // "oper_status", 130 | // "curr_status", 131 | // "start_date", 132 | // "end_date", 133 | // "norm_doc", 134 | // "live_status"} 135 | // 136 | // return ao 137 | // } 138 | /* 139 | import ( 140 | "encoding/xml" 141 | "log" 142 | "os" 143 | "sync" 144 | 145 | "github.com/jmoiron/sqlx" 146 | "github.com/lib/pq" 147 | "github.com/pavlik/fias_xml2postgresql/helpers" 148 | ) 149 | 150 | func ExportBulk(w *sync.WaitGroup, c chan string, db *sqlx.DB, format *string, logger *log.Logger) { 151 | 152 | defer w.Done() 153 | 154 | helpers.DropAndCreateTable(schema, tableName, db) 155 | 156 | var format2 string 157 | format2 = *format 158 | fileName, err2 := helpers.SearchFile(tableName, format2) 159 | if err2 != nil { 160 | logger.Fatalln("Error searching file:", err2) 161 | } 162 | 163 | pathToFile := format2 + "/" + fileName 164 | 165 | xmlFile, err := os.Open(pathToFile) 166 | if err != nil { 167 | logger.Fatalln("Error opening file:", err) 168 | } 169 | 170 | defer xmlFile.Close() 171 | 172 | decoder := xml.NewDecoder(xmlFile) 173 | var inElement string 174 | total := 0 175 | i := 0 176 | 177 | txn, err := db.Begin() 178 | if err != nil { 179 | logger.Fatalln(err) 180 | } 181 | 182 | query := pq.CopyIn(tableName, 183 | "ao_guid", 184 | "formal_name", 185 | "region_code", 186 | "auto_code", 187 | "area_code", 188 | "city_code", 189 | "ctar_code", 190 | "place_code", 191 | "street_code", 192 | "extr_code", 193 | "sext_code", 194 | "off_name", 195 | "postal_code", 196 | "ifns_fl", 197 | "terr_ifns_fl", 198 | "ifns_ul", 199 | "terr_ifns_ul", 200 | "okato", 201 | "oktmo", 202 | "update_date", 203 | "short_name", 204 | "ao_level", 205 | "parent_guid", 206 | "ao_id", 207 | "prev_id", 208 | "next_id", 209 | "code", 210 | "plain_code", 211 | "act_status", 212 | "cent_status", 213 | "oper_status", 214 | "curr_status", 215 | "start_date", 216 | "end_date", 217 | "norm_doc", 218 | "live_status") 219 | 220 | stmt, err := txn.Prepare(query) 221 | if err != nil { 222 | logger.Fatalln(err) 223 | } 224 | 225 | for { 226 | if i == 50000 { 227 | i = 0 228 | 229 | _, err = stmt.Exec() 230 | if err != nil { 231 | logger.Fatalln(err) 232 | } 233 | 234 | err = stmt.Close() 235 | if err != nil { 236 | logger.Fatalln(err) 237 | } 238 | 239 | err = txn.Commit() 240 | if err != nil { 241 | logger.Fatalln(err) 242 | } 243 | 244 | //c <- helpers.PrintRowsAffected(elementName, total) 245 | 246 | txn, err = db.Begin() 247 | if err != nil { 248 | logger.Fatalln(err) 249 | } 250 | 251 | stmt, err = txn.Prepare(query) 252 | if err != nil { 253 | logger.Fatalln(err) 254 | } 255 | } 256 | // Read tokens from the XML document in a stream. 257 | t, _ := decoder.Token() 258 | 259 | // Если достигли конца xml-файла 260 | if t == nil { 261 | if i > 0 { 262 | _, err = stmt.Exec() 263 | if err != nil { 264 | logger.Fatalln(err) 265 | } 266 | 267 | err = stmt.Close() 268 | if err != nil { 269 | logger.Fatalln(err) 270 | } 271 | 272 | err = txn.Commit() 273 | if err != nil { 274 | logger.Fatalln(err) 275 | } 276 | } 277 | 278 | //c <- helpers.PrintRowsAffected(elementName, total) 279 | 280 | break 281 | } 282 | // Inspect the type of the token just read. 283 | switch se := t.(type) { 284 | case xml.StartElement: 285 | // If we just read a StartElement token 286 | inElement = se.Name.Local 287 | 288 | if inElement == elementName { 289 | total++ 290 | var item XmlObject 291 | 292 | // decode a whole chunk of following XML into the 293 | // variable item which is a ActualStatus (se above) 294 | err = decoder.DecodeElement(&item, &se) 295 | if err != nil { 296 | logger.Fatalln("Error in decode element:", err) 297 | } 298 | 299 | _, err = stmt.Exec(item.AOGUID, 300 | item.FORMALNAME, 301 | item.REGIONCODE, 302 | item.AUTOCODE, 303 | item.AREACODE, 304 | item.CITYCODE, 305 | item.CTARCODE, 306 | item.PLACECODE, 307 | item.STREETCODE, 308 | item.EXTRCODE, 309 | item.SEXTCODE, 310 | item.OFFNAME, 311 | item.POSTALCODE, 312 | item.IFNSFL, 313 | item.TERRIFNSFL, 314 | item.IFNSUL, 315 | item.TERRIFNSUL, 316 | item.OKATO, 317 | item.OKTMO, 318 | item.UPDATEDATE, 319 | item.SHORTNAME, 320 | item.AOLEVEL, 321 | item.PARENTGUID, 322 | item.AOID, 323 | item.PREVID, 324 | item.NEXTID, 325 | item.CODE, 326 | item.PLAINCODE, 327 | item.ACTSTATUS, 328 | item.CENTSTATUS, 329 | item.OPERSTATUS, 330 | item.CURRSTATUS, 331 | item.STARTDATE, 332 | item.ENDDATE, 333 | item.NORMDOC, 334 | item.LIVESTATUS) 335 | 336 | if err != nil { 337 | logger.Fatalln(err) 338 | } 339 | c <- helpers.PrintRowsAffected(elementName, total) 340 | i++ 341 | } 342 | default: 343 | } 344 | 345 | } 346 | } 347 | */ 348 | -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "flag" 5 | "fmt" 6 | "log" 7 | "os" 8 | "runtime" 9 | "runtime/pprof" 10 | "strings" 11 | "sync" 12 | "time" 13 | 14 | "github.com/jmoiron/sqlx" 15 | "github.com/nsf/termbox-go" 16 | 17 | _ "github.com/lib/pq" 18 | "github.com/pavlik/fias_xml2postgresql/helpers" 19 | "github.com/pavlik/fias_xml2postgresql/structures/actual_status" 20 | "github.com/pavlik/fias_xml2postgresql/structures/address_object" 21 | "github.com/pavlik/fias_xml2postgresql/structures/address_object_type" 22 | "github.com/pavlik/fias_xml2postgresql/structures/center_status" 23 | "github.com/pavlik/fias_xml2postgresql/structures/current_status" 24 | "github.com/pavlik/fias_xml2postgresql/structures/estate_status" 25 | "github.com/pavlik/fias_xml2postgresql/structures/house" 26 | "github.com/pavlik/fias_xml2postgresql/structures/house_interval" 27 | "github.com/pavlik/fias_xml2postgresql/structures/house_state_status" 28 | "github.com/pavlik/fias_xml2postgresql/structures/interval_status" 29 | "github.com/pavlik/fias_xml2postgresql/structures/landmark" 30 | "github.com/pavlik/fias_xml2postgresql/structures/normative_document" 31 | "github.com/pavlik/fias_xml2postgresql/structures/normative_document_type" 32 | "github.com/pavlik/fias_xml2postgresql/structures/operation_status" 33 | "github.com/pavlik/fias_xml2postgresql/structures/structure_status" 34 | ) 35 | 36 | func print_tb(x, y int, fg, bg termbox.Attribute, msg string) { 37 | for _, c := range msg { 38 | termbox.SetCell(x, y, c, fg, bg) 39 | x++ 40 | } 41 | } 42 | 43 | func printf_tb(x, y int, fg, bg termbox.Attribute, format string, args ...interface{}) { 44 | s := fmt.Sprintf(format, args...) 45 | print_tb(x, y, fg, bg, s) 46 | } 47 | 48 | const timeLayout = "2006-01-02 в 15:04" 49 | 50 | func progressPrint(msgs [15]string, startTime time.Time, finished bool) { 51 | /* color := [15]termbox.Attribute{termbox.ColorWhite, 52 | termbox.ColorWhite, 53 | termbox.ColorWhite, 54 | termbox.ColorWhite, 55 | termbox.ColorWhite, 56 | termbox.ColorBlue, 57 | termbox.ColorBlue, 58 | termbox.ColorBlue, 59 | termbox.ColorBlue, 60 | termbox.ColorBlue, 61 | termbox.ColorRed, 62 | termbox.ColorRed, 63 | termbox.ColorRed, 64 | termbox.ColorRed, 65 | termbox.ColorRed} */ 66 | 67 | termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) 68 | 69 | printf_tb(0, 0, termbox.ColorGreen|termbox.AttrBold, termbox.ColorBlack, "Экспорт базы ФИАС в БД PostgreSQL") 70 | printf_tb(0, 1, termbox.ColorYellow, termbox.ColorBlack, fmt.Sprintf("Количество используемых ядер: %d", runtime.NumCPU())) 71 | printf_tb(0, 20, termbox.ColorCyan, termbox.ColorBlack, fmt.Sprintf("Конвертация началась %s", startTime.Format(timeLayout))) 72 | 73 | duration := time.Since(startTime) 74 | var durationText string 75 | 76 | if duration.Seconds() < 60 { 77 | durationText = fmt.Sprintf("%.1f секунд", duration.Seconds()) 78 | } else if duration.Minutes() < 60 { 79 | durationText = fmt.Sprintf("%.1f минут", duration.Minutes()) 80 | } else { 81 | durationText = fmt.Sprintf("%.1f часов", duration.Hours()) 82 | } 83 | 84 | if finished { 85 | printf_tb(0, 21, termbox.ColorGreen, termbox.ColorBlack, fmt.Sprintf("База экспортировалась %s. Экспорт завершен.", durationText)) 86 | } else { 87 | printf_tb(0, 21, termbox.ColorCyan, termbox.ColorBlack, fmt.Sprintf("и уже длится %s", durationText)) 88 | } 89 | printf_tb(0, 22, termbox.ColorMagenta|termbox.AttrUnderline, termbox.ColorBlack, "Для прерывания экспорта и выхода из программы нажмите CTRL+Q") 90 | 91 | y := 0 92 | for _, v := range msgs { 93 | // if counters[y] > 0 { 94 | // v = fmt.Sprintf("%s. Total count is %d", v, counters[y]) 95 | // } 96 | if strings.HasPrefix(v, "!") { 97 | printf_tb(0, y+3, termbox.ColorGreen, termbox.ColorDefault, strings.TrimPrefix(v, "!")) 98 | } else { 99 | printf_tb(0, y+3, termbox.ColorWhite, termbox.ColorDefault, v) 100 | } 101 | //printf_tb(0, y+3, color[y], termbox.ColorDefault, v) 102 | y++ 103 | } 104 | 105 | termbox.Flush() 106 | } 107 | 108 | func initDb() *sqlx.DB { 109 | // connect to db using standard Go database/sql API 110 | // use whatever database/sql driver you wish 111 | db, err := sqlx.Open("postgres", "user=dev dbname=fias password=dev sslmode=disable") 112 | checkErr(err, "sqlx.Open failed") 113 | 114 | return db 115 | } 116 | 117 | func checkErr(err error, msg string) { 118 | if err != nil { 119 | log.Fatalln(msg, err) 120 | } 121 | } 122 | 123 | func logInit() *log.Logger { 124 | logFile := "log.txt" 125 | 126 | file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) 127 | if err != nil { 128 | log.Fatalln("Failed to open log file", logFile, ":", err) 129 | } 130 | 131 | logger := log.New(file, 132 | "FATAL: ", 133 | log.Ldate|log.Ltime|log.Lshortfile) 134 | 135 | return logger 136 | } 137 | 138 | func main() { 139 | 140 | logger := logInit() 141 | 142 | defer func() { 143 | if r := recover(); r != nil { 144 | fmt.Println("Program terminated. Main goroutine paniced:", r) 145 | } 146 | }() 147 | 148 | runtime.GOMAXPROCS(runtime.NumCPU()) 149 | 150 | var format = flag.String("format", "xml", "File format for import (xml or dbf)") 151 | var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file") 152 | flag.Parse() 153 | 154 | if *cpuprofile != "" { 155 | f, err := os.Create(*cpuprofile) 156 | if err != nil { 157 | log.Fatal(err) 158 | } 159 | pprof.StartCPUProfile(f) 160 | defer pprof.StopCPUProfile() 161 | } 162 | 163 | // initialize the DbMap 164 | db := initDb() 165 | defer db.Close() 166 | 167 | var w sync.WaitGroup 168 | w.Add(15) 169 | 170 | as_stat := make(chan string) 171 | ao_stat := make(chan string) 172 | //ao_counter := make(chan int, 1000) 173 | cs_stat := make(chan string) 174 | cur_stat := make(chan string) 175 | est_stat := make(chan string) 176 | house_stat := make(chan string) 177 | //house_counter := make(chan int, 1000) 178 | house_int_stat := make(chan string) 179 | //house_int_counter := make(chan int, 1000) 180 | house_st_stat := make(chan string) 181 | intv_stat := make(chan string) 182 | landmark_stat := make(chan string) 183 | //landmark_counter := make(chan int, 1000) 184 | ndtype_stat := make(chan string) 185 | nd_stat := make(chan string) 186 | //nd_counter := make(chan int, 1000) 187 | oper_stat := make(chan string) 188 | socrbase_stat := make(chan string) 189 | str_stat := make(chan string) 190 | 191 | done := make(chan bool) 192 | //done <- false 193 | //logger.Println(<-done) 194 | 195 | if *format == "xml" { 196 | fmt.Println("обработка XML-файлов") 197 | 198 | asObj := &actual_status.XmlObject{} 199 | go helpers.ExportBulk(actual_status.Schema, asObj, &w, as_stat, db, format, logger) 200 | //go actual_status.ExportBulk(&w, as_stat, db, format, logger) 201 | 202 | estsObj := &estate_status.XmlObject{} 203 | go helpers.ExportBulk(estate_status.Schema, estsObj, &w, est_stat, db, format, logger) 204 | // go estate_status.ExportBulk(&w, est_stat, db, format, logger) 205 | 206 | isObj := &interval_status.XmlObject{} 207 | go helpers.ExportBulk(interval_status.Schema, isObj, &w, intv_stat, db, format, logger) 208 | // go interval_status.ExportBulk(&w, intv_stat, db, format, logger) 209 | 210 | strsObj := &structure_status.XmlObject{} 211 | go helpers.ExportBulk(structure_status.Schema, strsObj, &w, str_stat, db, format, logger) 212 | 213 | // go structure_status.ExportBulk(&w, str_stat, db, format, logger) 214 | 215 | // go center_status.ExportBulk(&w, cs_stat, db, format, logger) 216 | csObj := ¢er_status.XmlObject{} 217 | go helpers.ExportBulk(center_status.Schema, csObj, &w, cs_stat, db, format, logger) 218 | 219 | osObj := &operation_status.XmlObject{} 220 | go helpers.ExportBulk(operation_status.Schema, osObj, &w, oper_stat, db, format, logger) 221 | // go operation_status.ExportBulk(&w, oper_stat, db, format, logger) 222 | 223 | ndtObj := &normative_document_type.XmlObject{} 224 | go helpers.ExportBulk(normative_document_type.Schema, ndtObj, &w, ndtype_stat, db, format, logger) 225 | // go normative_document_type.ExportBulk(&w, ndtype_stat, db, format, logger) 226 | 227 | hssObj := &house_state_status.XmlObject{} 228 | go helpers.ExportBulk(house_state_status.Schema, hssObj, &w, house_st_stat, db, format, logger) 229 | // go house_state_status.ExportBulk(&w, house_st_stat, db, format, logger) 230 | 231 | cursObj := ¤t_status.XmlObject{} 232 | go helpers.ExportBulk(current_status.Schema, cursObj, &w, cur_stat, db, format, logger) 233 | // go current_status.ExportBulk(&w, cur_stat, db, format, logger) 234 | 235 | aotObj := &address_object_type.XmlObject{} 236 | go helpers.ExportBulk(address_object_type.Schema, aotObj, &w, socrbase_stat, db, format, logger) 237 | // go address_object_type.ExportBulk(&w, socrbase_stat, db, format, logger) 238 | 239 | landmarkObj := &landmark.XmlObject{} 240 | go helpers.ExportBulk(landmark.Schema, landmarkObj, &w, landmark_stat, db, format, logger) 241 | // go landmark.ExportBulk(&w, landmark_stat, db, format, logger) 242 | // //go helpers.CountElementsInXML(&w, landmark_counter, "as_landmark", "Landmark") 243 | 244 | ndObj := &normative_document.XmlObject{} 245 | go helpers.ExportBulk(normative_document.Schema, ndObj, &w, nd_stat, db, format, logger) 246 | // go normative_document.ExportBulk(&w, nd_stat, db, format, logger) 247 | // //go helpers.CountElementsInXML(&w, nd_counter, "as_normdoc", "NormativeDocument") 248 | 249 | hiObj := &house_interval.XmlObject{} 250 | go helpers.ExportBulk(house_interval.Schema, hiObj, &w, house_int_stat, db, format, logger) 251 | // go house_interval.ExportBulk(&w, house_int_stat, db, format, logger) 252 | // //go helpers.CountElementsInXML(&w, house_int_counter, "as_houseint", "HouseInterval") 253 | 254 | aoObj := &address_object.XmlObject{} 255 | go helpers.ExportBulk(address_object.Schema, aoObj, &w, ao_stat, db, format, logger) 256 | // go address_object.ExportBulk(&w, ao_stat, db, format, logger) 257 | // //go helpers.CountElementsInXML(&w, ao_counter, "as_addrobj", "Object") 258 | 259 | hObj := &house.XmlObject{} 260 | go helpers.ExportBulk(house.Schema, hObj, &w, house_stat, db, format, logger) 261 | // go house.ExportBulk(&w, house_stat, db, format, logger) 262 | // //go helpers.CountElementsInXML(&w, house_counter, "as_house_", "House") 263 | 264 | } else if *format == "dbf" { 265 | // todo: обработка DBF-файлов 266 | fmt.Println("обработка DBF-файлов") 267 | } 268 | 269 | err := termbox.Init() 270 | if err != nil { 271 | logger.Fatal(err) 272 | } 273 | defer termbox.Close() 274 | 275 | termbox.SetInputMode(termbox.InputEsc) 276 | 277 | var msgs [15]string 278 | // var counters [15]int 279 | 280 | doneStat := false 281 | 282 | timer := time.After(time.Second * 1) 283 | go func() { 284 | 285 | startTime := time.Now() 286 | 287 | for { 288 | select { 289 | case doneStat = <-done: 290 | logger.Println("Попали в done") 291 | progressPrint(msgs, startTime, true) 292 | return 293 | case <-timer: 294 | progressPrint(msgs, startTime, false) 295 | timer = time.After(time.Millisecond) 296 | // default: 297 | // } 298 | // select { 299 | case msgs[0] = <-as_stat: 300 | case msgs[1] = <-est_stat: 301 | case msgs[2] = <-intv_stat: 302 | case msgs[3] = <-str_stat: 303 | case msgs[4] = <-cs_stat: 304 | case msgs[5] = <-oper_stat: 305 | case msgs[6] = <-ndtype_stat: 306 | case msgs[7] = <-house_st_stat: 307 | case msgs[8] = <-cur_stat: 308 | case msgs[9] = <-socrbase_stat: 309 | case msgs[10] = <-landmark_stat: 310 | case msgs[11] = <-nd_stat: 311 | case msgs[12] = <-house_int_stat: 312 | case msgs[13] = <-ao_stat: 313 | case msgs[14] = <-house_stat: 314 | } 315 | // select { 316 | // // case msgs[0] = <-as_stat: 317 | // // case msgs[1] = <-est_stat: 318 | // // case msgs[2] = <-intv_stat: 319 | // // case msgs[3] = <-str_stat: 320 | // // case msgs[4] = <-cs_stat: 321 | // // case msgs[5] = <-oper_stat: 322 | // // case msgs[6] = <-ndtype_stat: 323 | // // case msgs[7] = <-house_st_stat: 324 | // // case msgs[8] = <-cur_stat: 325 | // // case msgs[9] = <-socrbase_stat: 326 | // // case counters[10] = <-landmark_counter: 327 | // // case counters[11] = <-nd_counter: 328 | // // case counters[12] = <-house_int_counter: 329 | // // case counters[13] = <-ao_counter: 330 | // // case counters[14] = <-house_counter: 331 | // } 332 | } 333 | }() 334 | 335 | go func() { 336 | w.Wait() 337 | done <- true 338 | logger.Println("Все горутины завершились") 339 | }() 340 | 341 | loop: 342 | for { 343 | switch ev := termbox.PollEvent(); ev.Type { 344 | case termbox.EventKey: 345 | if ev.Key == termbox.KeyCtrlQ { 346 | break loop 347 | } 348 | termbox.Clear(termbox.ColorDefault, termbox.ColorDefault) 349 | termbox.Flush() 350 | //progressPrint(msg1, msg2, msg3, msg4, msg5) 351 | case termbox.EventError: 352 | logger.Fatal(err) 353 | } 354 | } 355 | 356 | } 357 | --------------------------------------------------------------------------------