Установка MediaWiki в docker

Installing and Using MariaDB via Docker
Docker Official Images mariadb
mediawiki

Удалить все контейнеры
$ docker rm -f $(docker ps -aq)

$ docker pull mariadb/server:10.3
Задаем пароль root  mypass :
------------------------------------------------------------------------------------------------------------------------ 
Вариант через link
$ docker run --name mariadbtest -e MYSQL_ROOT_PASSWORD=mypass -d mariadb/server:10.3
$ docker run --name some-mediawiki --link mariadbtest -p 80:80 -d mediawiki

Хост базы данных mariadbtest

------------------------------------------------------------------------------------------------------------------------
Вариант через ip host 
$ docker run --name mariadbtest -e MYSQL_ROOT_PASSWORD=mypass -p 3306:3306 -d mariadb/server:10.3

$ docker run --name some-mediawiki -p 80:80 -d mediawiki 
Хост базы данных ip host

------------------------------------------------------------------------------------------------------------------------

$ docker exec -it some-mediawiki bash
# apt update
# apt install mc nano
Скачать LocalSettings.php по ссылке полученной в процессе конфигурации
# nano LocalSettings.php
Вставить  содержимое LocalSettings.php
$wgEnableUploads = true

# exit

Справка:Форматирование

Cвечи plx

Особенности формирования неполной свечи,
Неполная свеча появляется когда в sql запрос попадает хотя бы одна сделка
а неполном периоде:
timestamp x =  1521933300

Расчет свечей из кэша :
data1 = [{'date': 1521929700, 'open': 8640.0, 'high': 8717.0, 'low': 8610.81133606, 'close': 8694.24124667}, {'date': 1521930600, 'open': 8694.24124712, 'high': 8719.44583815, 'low': 8650.76841592, 'close': 8667.85584522}, {'date': 1521931500, 'open': 8667.83364934, 'high': 8683.19046025, 'low': 8613.02673386, 'close': 8630.0}, {'date': 1521932400, 'open': 8630.0, 'high': 8653.33548722, 'low': 8610.81133606, 'close': 8653.33548722}]
cand2_st =  1521933300
cand2_end =  1521933300

data2= []

Удаляем последнюю свечу
data1 = [{'date': 1521929700, 'open': 8640.0, 'high': 8717.0, 'low': 8610.81133606, 'close': 8694.24124667}, {'date': 1521930600, 'open': 8694.24124712, 'high': 8719.44583815, 'low': 8650.76841592, 'close': 8667.85584522}, {'date': 1521931500, 'open': 8667.83364934, 'high': 8683.19046025, 'low': 8613.02673386, 'close': 8630.0}, {'date': 1521932400, 'open': 8630.0, 'high': 8653.33548722, 'low': 8610.81133606, 'close': 8653.33548722}]

Добавим последню свечу
Если data2 не пустой
Список в работу целиком :
data1 = [{'date': 1521929700, 'open': 8640.0, 'high': 8717.0, 'low': 8610.81133606, 'close': 8694.24124667}, {'date': 1521930600, 'open': 8694.24124712, 'high': 8719.44583815, 'low': 8650.76841592, 'close': 8667.85584522}, {'date': 1521931500, 'open': 8667.83364934, 'high': 8683.19046025, 'low': 8613.02673386, 'close': 8630.0}, {'date': 1521932400, 'open': 8630.0, 'high': 8653.33548722, 'low': 8610.81133606, 'close': 8653.33548722}]
—---------------------------------------------------------------------------------------------------------------------------------—
timestamp x =  1521933310
Расчет свечей из кэша :
data1 = [{'date': 1521930600, 'open': 8694.24124712, 'high': 8719.44583815, 'low': 8650.76841592, 'close': 8667.85584522}, {'date': 1521931500, 'open': 8667.83364934, 'high': 8683.19046025, 'low': 8613.02673386, 'close': 8630.0}, {'date': 1521932400, 'open': 8630.0, 'high': 8653.33548722, 'low': 8610.81133606, 'close': 8653.33548722}, {'date': 1521933300, 'open': 8653.13572438, 'high': 8653.13572438, 'low': 8653.13572438, 'close': 8653.13572438}]
cand2_st =  1521933300
cand2_end =  1521933310

data2= [{'date': 1521933300, 'open': 8653.13572438, 'high': 8653.13572438, 'low': 8653.13572438, 'close': 8653.13572438}]

Удаляем последнюю свечу
data1 = [{'date': 1521930600, 'open': 8694.24124712, 'high': 8719.44583815, 'low': 8650.76841592, 'close': 8667.85584522}, {'date': 1521931500, 'open': 8667.83364934, 'high': 8683.19046025, 'low': 8613.02673386, 'close': 8630.0}, {'date': 1521932400, 'open': 8630.0, 'high': 8653.33548722, 'low': 8610.81133606, 'close': 8653.33548722}, {'date': 1521933300, 'open': 8653.13572438, 'high': 8653.13572438, 'low': 8653.13572438, 'close': 8653.13572438}]

Добавим последню свечу
Если data2 не пустой
Список в работу целиком :
data1 = [{'date': 1521930600, 'open': 8694.24124712, 'high': 8719.44583815, 'low': 8650.76841592, 'close': 8667.85584522}, {'date': 1521931500, 'open': 8667.83364934, 'high': 8683.19046025, 'low': 8613.02673386, 'close': 8630.0}, {'date': 1521932400, 'open': 8630.0, 'high': 8653.33548722, 'low': 8610.81133606, 'close': 8653.33548722}, {'date': 1521933300, 'open': 8653.13572438, 'high': 8653.13572438, 'low': 8653.13572438, 'close': 8653.13572438}]


# candel_polo_5x.py
import time
import json
import requests
import urllib, http.client
import hmac, hashlib
import mysql.connector
import sys
import os, errno
import calendar
import numpy
import talib

from datetime import datetime

#Начало и конец свечей PERIOD1  # get_ticks (cand1_st, cand1_end, PERIOD1)
#MACD=26
MACD=2

PERIOD = 15 # минут
cand1_st = calendar.timegm((2018, 3, 24, 22, 0, 0, 0, 0, 0)) # время UTC
cand1_end = calendar.timegm((2018, 3, 25, 2, 0, 0, 0, 0, 0)) # время UTC

#1518628155 Начало базы 2018-02-14 20:09:15
#print('Начало базы', datetime.fromtimestamp(1518628155))
#Установим дату и время начала тестирования
#time_start = (2018, 1, 1, 0, 0, 0, 0, 0, 0) #Время UTC
time_start = (2018, 3, 24, 23, 0, 0, 0, 0, 0) #Время UTC

#timestampstart = time.mktime(time_start) #Локальное время
timestampstart = calendar.timegm(time_start) # время UTC
x=timestampstart
#x=1509494400
#x=1509494399
#x=1521932451
#x=1521932400
#x=1521932401
#x=1521933300
#x=1521933299
x=1521933300

print('Начало тестирования utc ', datetime.utcfromtimestamp(timestampstart))
#Установим дату и время завершения тестирования
#time_end = (2018, 3, 20, 0, 0, 0, 0, 0, 0) #Время UTC
time_end = (2018, 3, 25, 1, 0, 0, 0, 0, 0) #Время UTC
#time_end = (2018, 3, 13, 15, 0, 0, 0, 0, 0) #Время UTC
#time_end = (2018, 3, 20, 5, 0, 0, 0, 0, 0) #Время UTC
#timestampend = time.mktime(time_end) #Локальное время
timestampend = calendar.timegm(time_end) # время UTC
print('Заввершение тестирования utc ', datetime.utcfromtimestamp(timestampend))
y=timestampend

USE_LOG = True
DEBUG = False # True - выводить отладочную информацию, False - писать как можно меньше
numpy.seterr(all='ignore')


# Свой класс исключений
class ScriptError(Exception):
    pass
class ScriptQuitCondition(Exception):
    pass
    
def is_nan(x):
    return (x is numpy.nan or x != x)


# Получаем данные, необходимые для построения индикаторов
#def get_ticks(pair):
def get_sql(st, end, PER):
    #global y
    #global x
    #_SQL = """select * from trade"""
    #x=int(time.time())
    #print('y = ',y)
    #print(datetime.fromtimestamp(y))
    pr = PER * 60
    #x= y - pr*50  #Для построения MACD требуется примерно 50 периодов свечей
    #_SQL = """select * from trade where date between 1519318790 and 1519318800; """
    _SQL = """SELECT
                    FLOOR(MIN(`date`)/%s)*%s AS date,
                    SUBSTRING_INDEX(MIN(CONCAT(`date`, '_', id, '_', rate)), '_', -1) AS `open`,
                    MAX(rate) AS high,
                    MIN(rate) AS low,
                    SUBSTRING_INDEX(MAX(CONCAT(`date`, '_', id, '_', rate)), '_', -1) AS `close`
              FROM trade
              WHERE date >= %s and date <= %s
              GROUP BY FLOOR(`date`/%s)
              ORDER BY date"""

    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="polo")
    #db = mysql.connector.connect(host="10.8.1.1", user="u", passwd="secret", db="exmo")
    cur = db.cursor()
    try:
        cur.execute(_SQL,(pr,pr,st,end,pr))
        sdata=[]
        for item in cur.fetchall():
            sdata.append({'date':int(item[0]),'open':float(item[1]),'high':float(item[2]),'low':float(item[3]),'close':float(item[4])})
    except Exception as e:
        log(e)
    cur.close()
    db.close()
    #print(sdata)
    return sdata

# Выводит всякую информацию на экран, самое важное скидывает в Файл log.txt
def log(*args):
    if USE_LOG:
        l = open("./candel_polo.txt", 'a', encoding='utf-8')
        print(datetime.now(), *args, file=l)
        #print(datetime.fromtimestamp(y+3*60*60), *args, file=l) #Локальное время
        #print(datetime.utcfromtimestamp(y), *args, file=l)  #UTC

        l.close()
    print(datetime.now(),' ', *args)
    #print(datetime.fromtimestamp(y+3*60*60),' ', *args) #Локальное время
    #print(datetime.utcfromtimestamp(y),' ', *args) #UTC

def get_ticks (d, data, flg):
    global PERIOD
    global MACD
    # d текщее время на которое расчитывается свеча
    # data список предварительно рассчитанные свечи
    DEBUG = True
    if flg: #flg = True для ускорения используем кэш предрасчитанные свечи в списке data
        data1=[] #перегрузим  сюда свечи  до времени d с учетом запаса для расчета MACD
        for offset, elem in enumerate(data):
            #if True:
            if (data[offset]['date'] <=d) and (data[offset]['date'] >= (d - PERIOD*MACD*2*60)):
                data1.append(data[offset]) #не пропускаем последнюю свечу!
        cand2_st = data1[-1]['date'] # из последней свечи возьмем возьмем начала периода для расчета неполной свечи
        cand2_end = d # время UTC
        data2=get_sql(cand2_st, cand2_end, PERIOD) #расчет неполной свечи на момент d
        data1.pop() #удалим последнюю, полную закрытую свечу
        if len(data2)>0: # при расчете свечи на момент d может вернуться пустой список (если сделок не было)
            data1.append(data2[-1])
        if DEBUG: #отладка
            print()
            print('Расчет свечей из кэша :')
            print('data1 =', data1)
            print('cand2_st = ', cand2_st)
            print('cand2_end = ', cand2_end)
            print()
            print('data2=',data2)
            print()
            print("Удаляем последнюю свечу")
            print('data1 =', data1)
            print()
            print('Добавим последню свечу')
            print('Если data2 не пустой')
            print('Список в работу целиком :')
            print('data1 =', data1)
        return data1
    else: #flg = False свечи рассчитываются напрямую запросом sql
        cand2_st = d - PERIOD*MACD*2*60 # время UTC
        cand2_end = d # время UTC
        data2=get_sql(cand2_st, cand2_end, PERIOD)
        if DEBUG:# отладка
            print()
            print('Тоже напрямую через SQL :')
            print('cand2_st = ', cand2_st)
            print('cand2_end = ', cand2_end)
            print()
            print('data2 =', data2)
        return data2



log('свечи PERIOD = ',PERIOD, ' мин')
#log('начало запроса', datetime.utcfromtimestamp(x))
#log('окончание запроса', datetime.utcfromtimestamp(y))
#print('Начало запроса',datetime.now()) #UTC
data=get_sql(cand1_st, cand1_end, PERIOD)
#print(data)
#print('Конец запроса', datetime.now()) #UTC
#print(data)
print('текущее время x',datetime.utcfromtimestamp(x)) #UTC
print('timestamp x = ',x)

#while True:
data1=get_ticks(x, data, True)
#data1=get_ticks(x, data, False)
x=1521933310
data1=get_ticks(x, data, True)


#print(data1[-1])
#print(data1)
#x = x +3600

#x=x+1
#data2=get_sql(x-100, x, PERIOD)
#print(data2)

Заполнение базы plx

#sql_pol.1.4.py
#import numpy
#import talib
import requests
import json
import time
import calendar
import mysql.connector
import sys
from datetime import datetime
#from matplotlib.finance import candlestick2_ohlc
#i#mport matplotlib.animation as animation
#import matplotlib.pyplot as plt
#import matplotlib.ticker as ticker
from datetime import datetime
k=0
NO_DATA = False

def get_date(str_date):
    #https://pythonworld.ru/moduli/modul-time.html
    #print(str_date)
    t1=time.strptime(str_date,'%Y-%m-%d %H:%M:%S')
    #print(t1)
    t2 = calendar.timegm(t1)
    #print(t2)
    #print(datetime.utcfromtimestamp(t2))
    return t2


def get_polo():
    global NO_DATA
    global k
    global st_time
    global end_time
    pair = 'USDT_BTC'
    time.sleep(0.2)
    #chart_data={}
    #manual http://docs.python-requests.org/en/master/user/advanced/#request-and-response-objects
    while True:
        try:
            log('requests.get')
            #response  = requests.get('https://poloniex.com/public?command=returnTradeHistory&currencyPair=%s&start=%s&end=%s' % (pair,st_time,end_time), timeout = None)
            response  = requests.get('https://poloniex.com/public?command=returnTradeHistory&currencyPair=%s&start=%s&end=%s' % (pair,st_time,end_time), timeout = 5)
            log('response.status_code =', response.status_code)
            if response.status_code == 200:
                break
            else:
                log('response.status_code =', response.status_code)
        except Exception as e:
            log(e)
    chart_data = json.loads(response.text)
    k=-1
    if type(chart_data) is list:
        k = len(chart_data)
    #print('st_time = ', st_time)
    #print('end_time = ', end_time)
    #print('k = ',k)
    print(chart_data[-1])
    return chart_data


def update_trade(data):
    PAIR = 'BTC_USD'
    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="polo")
    cur = db.cursor()
    #[{'globalTradeID': 355563163, 'tradeID': 20847088, 'date': '2018-03-20 17:31:49', 'type': 'buy', 'rate': '8775.87720002', 'amount': '0.00131316', 'total': '11.52413090'}]   
    #print(data)
    try:
        for item in reversed(data):
            _SQL = """insert ignore into trade
                      (gtrade_id, trade_id, date, type, rate, amount, total)
                      values
                      (%s,%s,%s,%s,%s,%s,%s)"""
            cur.execute(_SQL, (item['globalTradeID'], item['tradeID'], get_date(item['date']), item['type'], item['rate'], item['amount'],item['total']))
            db.commit()
    except Exception as e:
        log(e)
    cur.close()
    db.close()


def verify_trade():
    global st_time
    global end_time
    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="polo")
    cur = db.cursor()
    try:
        _SQL = """select count(1) FROM trade
                  WHERE (date >=  %s and date <= %s)"""
        cur.execute(_SQL,(st_time, end_time))
        arr = cur.fetchall()
        #print(arr)
        #print('число записей ', arr[0][0])
        db.commit()
        return int(arr[0][0])
    except Exception as e:
        log(e)
    cur.close()
    db.close()

def update_verify():
    global st_time
    global end_time
    global k
    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="polo")
    cur = db.cursor()
    try:
        _SQL = """insert ignore into  verify
                  (st_time, end_time, count)
                  values (%s,%s,%s)"""
        cur.execute(_SQL, (st_time, end_time, k))
        db.commit()
    except Exception as e:
        log(e)
    cur.close()
    db.close()

def get_end_time():
    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="polo")
    cur = db.cursor()
    try:
        _SQL = """select end_time from  verify
                  order by end_time desc limit 1"""
        cur.execute(_SQL)
        arr = cur.fetchall()
        #print(arr)
        #print('число записей ', arr[0][0])
        db.commit()
        return int(arr[0][0])
    except Exception as e:
        log(e)
    cur.close()
    db.close()

def count_verify():
    db = mysql.connector.connect(host="localhost", user="u", passwd="secret", db="polo")
    cur = db.cursor()
    try:
        _SQL = """select count(1) FROM verify"""
        cur.execute(_SQL)
        arr = cur.fetchall()
        #print(arr)
        #print('число записей ', arr[0][0])
        db.commit()
        return int(arr[0][0])
    except Exception as e:
        log(e)
    cur.close()
    db.close()

def log(*args):
    #if USE_LOG:
    l = open("./sql_pol.txt", 'a', encoding='utf-8')
    print(datetime.now(), *args, file=l)
    #print(datetime.fromtimestamp(y), *args, file=l) #Локальное время
    #print(datetime.utcfromtimestamp(y), *args, file=l) #UTC
    l.close()
    print(datetime.now(),' ', *args)
    #print(datetime.fromtimestamp(y+3*60*60),' ', *args)
    #print(datetime.utcfromtimestamp(y),' ', *args)


   
#Установим дату и время начала заполнения
# UTC
time_start = (2017, 1, 1, 0, 0, 0, 0, 0, 0)  #Время UTC
timestampstart = calendar.timegm(time_start) # время UTC
#Установим дату и время завершения заполнения
#UTC
if False: #True -заданное время  False текущее
    time_end = (2018, 3, 23, 20, 0, 0, 0, 0, 0) #Время UTC
    timestampend = calendar.timegm(time_end) # время UTC
else:
    timestampend  = time.time()
print('Время завершения выполнения', datetime.utcfromtimestamp(timestampend))


timeplus = 3600
st_time=timestampstart
log('count_verify()= ', count_verify())
if count_verify() > 0:
    log('get_end_time() = ', get_end_time())
    st_time=get_end_time() + 1
    log('Продолжаем работу c ', datetime.utcfromtimestamp(st_time))
log('Начало')
# Бесконечный цикл процесса - основная логика
#update_mysql(get_polo())
#if False:
if True:
    while True:
        #i=1
        #while i<5:
        try:
            if st_time > timestampend:
                log('Завершение заполнения базы', datetime.fromtimestamp(timestampend))
                sys.exit()
            #print('st_time = ', st_time)
            end_time=st_time+timeplus
            #print('end_time = ', end_time)
            i = 0
            while  i < 10 :
                try:
                    Flag = False
                    data=get_polo()
                    if type(data) is list:
                        Flag = True
                        if len(data) > 0:
                            update_trade(data)
                            count=verify_trade()
                            log('Верифицировано!') #Добавляем в sql запись
                            log('с ', datetime.utcfromtimestamp(st_time))
                            log('по ', datetime.utcfromtimestamp(end_time))
                            log('Количество записей ',k)
                            update_verify()
                            k=0
                            break
                        else:
                            log('Список нулевой длины  len(data) :',len(data))
                    else:
                        Flag = False
                        print('type(data) : ', type(data))
                    i = i + 1
                except Exception as e:
                    log(e)
                    time.sleep(1)
            if not Flag :
                log('Аварийное Завершение заполнения базы', datetime.fromtimestamp(st_time))
                log('Попытки получить данные из интернета неудачны')
                sys.exit()
            if k  > 0 :
                update_trade(data)
                count=verify_trade()
            else:
                count = 0
            if count == k :
                log('Верифицировано!') #Добавляем в sql запись
                log('с ', datetime.utcfromtimestamp(st_time))
                log('по ', datetime.utcfromtimestamp(end_time))
                #print('st_time = ', st_time)
                #print('end_time = ', end_time)
                log('Количество записей ',k)
                update_verify()
                k=0
            else:
                log('Аварийное Завершение заполнения базы', datetime.fromtimestamp(st_time))
                log('Не совпадение количества записе!')
                sys.exit()
            st_time=end_time+1 #Предполагаем что правая  граница  на polonix
            time.sleep(1)
            #i=i+1
        except Exception as e:
            log(e)

Настройка базы

https://poloniex.com/public?command=returnTradeHistory&currencyPair=USDT_BTC&start=1518628155&end=1518629000

$ sudo mysql -u root -p
(Можно задать пароль)

MariaDB [(none)]> create database polo;

Задать учетную запись u для базы polo с паролем secret

MariaDB [(none)]> grant all on polo.* to 'u' identified by 'secret';

MariaDB [(none)]> quit

$ mysql -u u -p polo

MariaDB [exmo]> create table trade (
id int auto_increment primary key,
ts timestamp default current_timestamp,
gtrade_id int not null,
trade_id int not null,
date int not null,
type varchar(4) not null,
rate decimal(30,8) not null,
amount decimal(30,8) not null,
total decimal(30,8) not null );

MariaDB [polo]> CREATE UNIQUE INDEX gtrade_id ON trade(gtrade_id);

MariaDB [polo]> CREATE UNIQUE INDEX trade_id ON trade(trade_id);

MariaDB [polo]> CREATE INDEX date ON trade(date);
MariaDB [polo]> CREATE INDEX rate ON trade(rate);

MariaDB [polo]> describe trade;

+-----------+---------------+------+-----+-------------------+----------------+
| Field     | Type          | Null | Key | Default           | Extra          |
+-----------+---------------+------+-----+-------------------+----------------+
| id        | int(11)       | NO   | PRI | NULL              | auto_increment |
| ts        | timestamp     | NO   |     | CURRENT_TIMESTAMP |                |
| gtrade_id | int(11)       | NO   | UNI | NULL              |                |
| trade_id  | int(11)       | NO   | UNI | NULL              |                |
| date      | int(11)       | NO   | MUL | NULL              |                |
| type      | varchar(4)    | NO   |     | NULL              |                |
| rate      | decimal(30,8) | NO   | MUL | NULL              |                |
| amount    | decimal(30,8) | NO   |     | NULL              |                |
| total     | decimal(30,8) | NO   |     | NULL              |                |
+-----------+---------------+------+-----+-------------------+----------------+

9 rows in set (0.00 sec)

$ mysql -u u -p polo



MariaDB [exmo]> create table verify ( 

id int auto_increment primary key,

ts timestamp default current_timestamp,

st_time int not null,

end_time int not null,

count int not null);

MariaDB [polo]> CREATE UNIQUE INDEX end_time ON verify(end_time);

MariaDB [polo]> describe verify;
+----------+-----------+------+-----+-------------------+----------------+
| Field    | Type      | Null | Key | Default           | Extra          |
+----------+-----------+------+-----+-------------------+----------------+
| id       | int(11)   | NO   | PRI | NULL              | auto_increment |
| ts       | timestamp | NO   |     | CURRENT_TIMESTAMP |                |
| st_time  | int(11)   | NO   |     | NULL              |                |
| end_time | int(11)   | NO   | UNI | NULL              |                |
| count    | int(11)   | NO   |     | NULL              |                |
+----------+-----------+------+-----+-------------------+----------------+
5 rows in set (0.00 sec)
 

MariaDB [polo]> delete from  verify; 

MariaDB [polo]> delete from  trade;
Query OK, 15 rows affected (0.00 sec)
 
python3 sql_pol.py
k =  13
[{'globalTradeID': 355582604, 'tradeID': 20851900, 'date': '2018-03-20 18:33:30',
 'type': 'buy', 'rate': '8805.27999977', 'amount': '0.01230000', 'total': '108.30494399'},
 {'globalTradeID': 355582602, 'tradeID': 20851899, 'date': '2018-03-20 18:33:29',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00017037', 'total': '1.50010785'},
 {'globalTradeID': 355582601, 'tradeID': 20851898, 'date': '2018-03-20 18:33:29',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00017037', 'total': '1.50010785'},
 {'globalTradeID': 355582599, 'tradeID': 20851897, 'date': '2018-03-20 18:33:29',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00017037', 'total': '1.50010785'},
 {'globalTradeID': 355582597, 'tradeID': 20851896, 'date': '2018-03-20 18:33:29',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00017037', 'total': '1.50010785'},
 {'globalTradeID': 355582593, 'tradeID': 20851895, 'date': '2018-03-20 18:33:28',
 'type': 'buy', 'rate': '8805.27999978', 'amount': '0.00085355', 'total': '7.51574674'},
 {'globalTradeID': 355582583, 'tradeID': 20851894, 'date': '2018-03-20 18:33:26',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00028395', 'total': '2.50017975'},
 {'globalTradeID': 355582581, 'tradeID': 20851893, 'date': '2018-03-20 18:33:26',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00028395', 'total': '2.50017975'},
 {'globalTradeID': 355582579, 'tradeID': 20851892, 'date': '2018-03-20 18:33:26',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00017037', 'total': '1.50010785'},
 {'globalTradeID': 355582578, 'tradeID': 20851891, 'date': '2018-03-20 18:33:26',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00028395', 'total': '2.50017975'},
 {'globalTradeID': 355582577, 'tradeID': 20851890, 'date': '2018-03-20 18:33:26',
 'type': 'sell', 'rate': '8805.00000000', 'amount': '0.00028395', 'total': '2.50017975'},
 {'globalTradeID': 355582576, 'tradeID': 20851889, 'date': '2018-03-20 18:33:26',
 'type': 'buy', 'rate': '8805.27999980', 'amount': '0.00400478', 'total': '35.26320923'},
 {'globalTradeID': 355582571, 'tradeID': 20851888, 'date': '2018-03-20 18:33:25',
 'type': 'buy', 'rate': '8805.27999980', 'amount': '0.00136569', 'total': '12.02528284'}]

MariaDB [polo]> select * from trade;
MariaDB [polo]> select * from trade;
+----+---------------------+-----------+----------+------------+------+---------------+------------+--------------+
| id | ts                  | gtrade_id | trade_id | date       | type | rate          | amount     | total        |
+----+---------------------+-----------+----------+------------+------+---------------+------------+--------------+
| 52 | 2018-03-20 21:33:36 | 355582571 | 20851888 | 1521570805 | buy  | 8805.27999980 | 0.00136569 |  12.02528284 |
| 53 | 2018-03-20 21:33:36 | 355582576 | 20851889 | 1521570806 | buy  | 8805.27999980 | 0.00400478 |  35.26320923 |
| 54 | 2018-03-20 21:33:36 | 355582577 | 20851890 | 1521570806 | sell | 8805.00000000 | 0.00028395 |   2.50017975 |
| 55 | 2018-03-20 21:33:36 | 355582578 | 20851891 | 1521570806 | sell | 8805.00000000 | 0.00028395 |   2.50017975 |
| 56 | 2018-03-20 21:33:36 | 355582579 | 20851892 | 1521570806 | sell | 8805.00000000 | 0.00017037 |   1.50010785 |
| 57 | 2018-03-20 21:33:36 | 355582581 | 20851893 | 1521570806 | sell | 8805.00000000 | 0.00028395 |   2.50017975 |
| 58 | 2018-03-20 21:33:36 | 355582583 | 20851894 | 1521570806 | sell | 8805.00000000 | 0.00028395 |   2.50017975 |
| 59 | 2018-03-20 21:33:36 | 355582593 | 20851895 | 1521570808 | buy  | 8805.27999978 | 0.00085355 |   7.51574674 |
| 60 | 2018-03-20 21:33:36 | 355582597 | 20851896 | 1521570809 | sell | 8805.00000000 | 0.00017037 |   1.50010785 |
| 61 | 2018-03-20 21:33:36 | 355582599 | 20851897 | 1521570809 | sell | 8805.00000000 | 0.00017037 |   1.50010785 |
| 62 | 2018-03-20 21:33:36 | 355582601 | 20851898 | 1521570809 | sell | 8805.00000000 | 0.00017037 |   1.50010785 |
| 63 | 2018-03-20 21:33:36 | 355582602 | 20851899 | 1521570809 | sell | 8805.00000000 | 0.00017037 |   1.50010785 |
| 64 | 2018-03-20 21:33:36 | 355582604 | 20851900 | 1521570810 | buy  | 8805.27999977 | 0.01230000 | 108.30494399 |
+----+---------------------+-----------+----------+------------+------+---------------+------------+--------------+
15 rows in set (0.00 sec)

MariaDB [polo]> SELECT COUNT(1) FROM trade;
+----------+
| COUNT(1) |
+----------+
|     3846 |
+----------+
1 row in set (0.00 sec)
  

Чтобы экспортировать БД

$ mysqldump -u u -p polo > polo-dump.sql

Импортировать базу пароль: secret (пользователь u)
  

Чтобы импортировать БД
В первый раз нужно ее создать:

$ sudo mysql -u root -p
(Можно задать пароль)

MariaDB [(none)]> create database polo;

Задать учетную запись u для базы polo с паролем secret

MariaDB [(none)]> grant all on polo.* to 'u' identified by 'secret';

MariaDB [(none)]> quit

$ mysql -u u -p polo

$ mysql -u u -p polo < polo-dump.sql

Некоторые команды делать не нужно: 

MariaDB [polo]> select * from trade;
Empty set (0.01 sec)
 

MariaDB [polo]> delete from  trade;
Query OK, 13 rows affected (0.02 sec)
 

MariaDB [polo]> show tables;
+----------------+
| Tables_in_polo |
+----------------+
| trade          |
+----------------+
1 row in set (0.00 sec)

MariaDB [polo]> drop table trade;
Query OK, 0 rows affected (0.00 sec)


MariaDB [polo]> SHOW TABLES IN polo;
+----------------+
| Tables_in_polo |
+----------------+
| trade          |
+----------------+