Как сериализовать результат SqlAlchemy в JSON?


193

В Django есть несколько хороших автоматических сериализаций моделей ORM, возвращаемых из DB в формат JSON.

Как сериализовать результат запроса SQLAlchemy в формат JSON?

Я пытался, jsonpickle.encodeно он сам кодирует объект запроса. Я пытался, json.dumps(items)но это возвращает

TypeError: <Product('3', 'some name', 'some desc')> is not JSON serializable

Неужели так сложно сериализовать объекты SQLAlchemy ORM в JSON / XML? Нет ли для этого сериализатора по умолчанию? В настоящее время очень распространена задача сериализации результатов запроса ORM.

Что мне нужно, так это просто вернуть JSON или XML представление данных результата запроса SQLAlchemy.

Результат запроса объектов SQLAlchemy в формате JSON / XML необходим для использования в javascript datagird (JQGrid http://www.trirand.com/blog/ )


Это обходной путь, который работает для меня. введите ссылку здесь
октаэдро

Ответы:


129

Плоская реализация

Вы можете использовать что-то вроде этого:

from sqlalchemy.ext.declarative import DeclarativeMeta

class AlchemyEncoder(json.JSONEncoder):

    def default(self, obj):
        if isinstance(obj.__class__, DeclarativeMeta):
            # an SQLAlchemy class
            fields = {}
            for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:
                data = obj.__getattribute__(field)
                try:
                    json.dumps(data) # this will fail on non-encodable values, like other classes
                    fields[field] = data
                except TypeError:
                    fields[field] = None
            # a json-encodable dict
            return fields

        return json.JSONEncoder.default(self, obj)

а затем преобразовать в JSON, используя:

c = YourAlchemyClass()
print json.dumps(c, cls=AlchemyEncoder)

Он будет игнорировать поля, которые не кодируются (установите для них значение «Нет»).

Он не расширяет отношения автоматически (поскольку это может привести к самоссылке и циклу навсегда).

Рекурсивная, некруглая реализация

Однако, если вы предпочитаете цикл навсегда, вы можете использовать:

from sqlalchemy.ext.declarative import DeclarativeMeta

def new_alchemy_encoder():
    _visited_objs = []

    class AlchemyEncoder(json.JSONEncoder):
        def default(self, obj):
            if isinstance(obj.__class__, DeclarativeMeta):
                # don't re-visit self
                if obj in _visited_objs:
                    return None
                _visited_objs.append(obj)

                # an SQLAlchemy class
                fields = {}
                for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:
                    fields[field] = obj.__getattribute__(field)
                # a json-encodable dict
                return fields

            return json.JSONEncoder.default(self, obj)

    return AlchemyEncoder

А затем кодировать объекты с помощью:

print json.dumps(e, cls=new_alchemy_encoder(), check_circular=False)

Это закодирует всех детей, и всех их детей, и всех их детей ... Потенциально, в основном, закодируйте всю вашу базу данных. Когда он достигает чего-то, что было закодировано ранее, он будет кодировать его как «Нет».

Рекурсивная, возможно круговая, выборочная реализация

Другая альтернатива, возможно, лучше, это возможность указать поля, которые вы хотите расширить:

def new_alchemy_encoder(revisit_self = False, fields_to_expand = []):
    _visited_objs = []

    class AlchemyEncoder(json.JSONEncoder):
        def default(self, obj):
            if isinstance(obj.__class__, DeclarativeMeta):
                # don't re-visit self
                if revisit_self:
                    if obj in _visited_objs:
                        return None
                    _visited_objs.append(obj)

                # go through each field in this SQLalchemy class
                fields = {}
                for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:
                    val = obj.__getattribute__(field)

                    # is this field another SQLalchemy object, or a list of SQLalchemy objects?
                    if isinstance(val.__class__, DeclarativeMeta) or (isinstance(val, list) and len(val) > 0 and isinstance(val[0].__class__, DeclarativeMeta)):
                        # unless we're expanding this field, stop here
                        if field not in fields_to_expand:
                            # not expanding this field: set it to None and continue
                            fields[field] = None
                            continue

                    fields[field] = val
                # a json-encodable dict
                return fields

            return json.JSONEncoder.default(self, obj)

    return AlchemyEncoder

Теперь вы можете позвонить с помощью:

print json.dumps(e, cls=new_alchemy_encoder(False, ['parents']), check_circular=False)

Например, чтобы расширить только поля SQLAlchemy, называемые «родители».


это отличный ответ, однако я получаю "не могу закодировать" BaseQuery "всякий раз, когда он затрагивает отношения с
неплоскими

1
@SashaB Как насчет более точного нацеливания на случаи, когда отношения повторяются? Например, если у меня есть online_orderи то address, и другое связано с user, но online_orderтакже имеет отношение к address. Если бы я хотел сериализовать все это, я бы включил addressв него fields_to_expand, но я не хотел бы избыточно сериализовать addressиз-за его отношения к обоим userи online_order.
Хрустящий

2
@BenKilah Позвольте мне предположить, что вы используете Flask-SqlAlchemy, и ваши модели наследуются от db.Model, а не от Base. Если это так, измените for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:его следующим образом for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata' and not x.startswith('query')]:. Имейте в виду, что это решение не позволит вам иметь свойство / отношения с именем 'query'
Pakman

так же, как я, но гораздо сложнее. stackoverflow.com/questions/7102754/…
Тян

2
Вы можете использовать мое решение github.com/n0nSmoker/SQLAlchemy-serializer
n0nSmoker

273

Вы можете просто вывести свой объект в виде словаря:

class User:
   def as_dict(self):
       return {c.name: getattr(self, c.name) for c in self.__table__.columns}

А затем вы используете User.as_dict()для сериализации вашего объекта.

Как объясняется в разделе Конвертировать объект строки sqlalchemy в python dict


2
@charlax, как бы я исправил DateTime? Используя это, я получаю, что «datetime.datetime (2013, 3, 22, 16, 50, 11) не сериализуем в формате JSON», когда я делаю json.dumps
Asken

1
Это ответственность JSONEncoderобъекта. Вы можете создать его подкласс, чтобы определить свой собственный кодер для некоторого объекта, включая datetime. Обратите внимание, что Flask, например, встроенная поддержка даты и времени в формате JSON (с последней версией).
Чарлакс

3
Если вы используете «декларативный» метод sqlalchemy, вы можете добавить что-то подобное в пользовательский базовый класс - это очень удобно, так как вы можете затем вызвать my_orm_object.toDict () для любого имеющегося у вас объекта ORM. Точно так же вы можете определить метод .toJSON (), который использует ваш метод toDict и пользовательский кодировщик для обработки дат,
больших двоичных

7
также поддерживать дату и время:return {c.name: unicode(getattr(self, c.name)) for c in self.__table__.columns}
Шохам

1
Это не работает, если ваши переменные класса не совпадают с именами столбцов. Есть идеи, как получить имена классов?
Джеймс Берк

55

Вы можете преобразовать RowProxy в dict следующим образом:

 d = dict(row.items())

Затем сериализуйте это в JSON (вам нужно будет указать кодировщик для таких вещей, как datetimeзначения). Это не так сложно, если вы просто хотите одну запись (и не полную иерархию связанных записей).

json.dumps([(dict(row.items())) for row in rs])

1
Это работает для моего пользовательского запроса sql с db.engine.connect () как con: rs = con.execute (sql)
JZ.

1
Это намного проще и работает. В чем разница между этим ответом и принятым ответом?
Sundeep

46

Я рекомендую использовать зефир . Это позволяет вам создавать сериализаторы для представления экземпляров вашей модели с поддержкой отношений и вложенных объектов.

Вот усеченный пример из их документов. Возьмите модель ORM Author:

class Author(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    first = db.Column(db.String(80))
    last = db.Column(db.String(80))

Схема зефира для этого класса строится так:

class AuthorSchema(Schema):
    id = fields.Int(dump_only=True)
    first = fields.Str()
    last = fields.Str()
    formatted_name = fields.Method("format_name", dump_only=True)

    def format_name(self, author):
        return "{}, {}".format(author.last, author.first)

... и используется так:

author_schema = AuthorSchema()
author_schema.dump(Author.query.first())

... будет производить вывод, как это:

{
        "first": "Tim",
        "formatted_name": "Peters, Tim",
        "id": 1,
        "last": "Peters"
}

Взгляните на их полный пример Flask-SQLAlchemy .

Библиотека под названием marshmallow-sqlalchemyспециально объединяет SQLAlchemy и зефир. В этой библиотеке схема для Authorмодели, описанной выше, выглядит следующим образом:

class AuthorSchema(ModelSchema):
    class Meta:
        model = Author

Интеграция позволяет выводить типы полей из Columnтипов SQLAlchemy .

Зефир-sqlalchemy здесь.


12
Я также нашел marshmallow-sqlalchemy.readthedocs.io/en/latest, который упрощает генерацию схемы
Foo L

46

Python 3.7+ и Flask 1.1+ могут использовать встроенный пакет dataclasses

from dataclasses import dataclass
from datetime import datetime
from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy


app = Flask(__name__)
db = SQLAlchemy(app)


@dataclass
class User(db.Model):
  id: int
  email: str

  id = db.Column(db.Integer, primary_key=True, auto_increment=True)
  email = db.Column(db.String(200), unique=True)


@app.route('/users/')
def users():
  users = User.query.all()
  return jsonify(users)  


if __name__ == "__main__":
  users = User(email="user1@gmail.com"), User(email="user2@gmail.com")
  db.create_all()
  db.session.add_all(users)
  db.session.commit()
  app.run()

/users/Маршрут теперь будет возвращать список пользователей.

[
  {"email": "user1@gmail.com", "id": 1},
  {"email": "user2@gmail.com", "id": 2}
]

Автосериализация связанных моделей

@dataclass
class Account(db.Model):
  id: int
  users: User

  id = db.Column(db.Integer)
  users = db.relationship(User)  # User model would need a db.ForeignKey field

Ответ jsonify(account)будет таким.

{  
   "id":1,
   "users":[  
      {  
         "email":"user1@gmail.com",
         "id":1
      },
      {  
         "email":"user2@gmail.com",
         "id":2
      }
   ]
}

Перезаписать JSON Encoder по умолчанию

from flask.json import JSONEncoder


class CustomJSONEncoder(JSONEncoder):
  "Add support for serializing timedeltas"

  def default(o):
    if type(o) == datetime.timedelta:
      return str(o)
    elif type(o) == datetime.datetime:
      return o.isoformat()
    else:
      return super().default(o)

app.json_encoder = CustomJSONEncoder      

1
Это похоже на правильный вид простого. Это также работает для десериализации?
Ender2050

Вы можете преобразовать словарь анализируемого JSON в модель, используя распаковку аргумента ключевого слова:data = request.json['user']; user = User(**data)
Том

3
Обратите внимание, что id: int = Columnэто сработает, но id = Columnне сработает, похоже, вам нужно объявить статическую типизацию для json, чтобы сериализовать поле, в противном случае вы получите пустой {}объект.
Амбруаз Рабье

1
Это сработало для меня, почему это не принятый ответ? Я часами играю в app_context, чтобы заставить его работать с Flask-Marshmallow.
Ник Дат Ле

1
У меня тоже сработало. Обратите внимание , что если вы на Python 3.6, вы хотите просто установить пакет: pipenv install dataclasses. И тогда это будет работать просто отлично.
АлександрH

14

В пакете Flask-JsonTools есть реализация базового класса JsonSerializableBase для ваших моделей.

Использование:

from sqlalchemy.ext.declarative import declarative_base
from flask.ext.jsontools import JsonSerializableBase

Base = declarative_base(cls=(JsonSerializableBase,))

class User(Base):
    #...

Теперь Userмодель магически сериализуема.

Если ваш фреймворк не Flask, вы можете просто взять код


2
Это решает только половину проблемы, поскольку сериализует только одну строку. Как сериализовать весь результат запроса?
Стив Беннетт

@SteveBennett использует jsonapi jsontools для кодирования ответа. Это автоматически
закодирует

У меня очень простая модель sqlalchemy, и я получаю: TypeError: <ORM.State объект в 0x03577A50> не сериализуем в формате JSON
Matej

1
В конечном итоге это сработало, явно вызвав __json __ () для моего модельного объекта: return my_object .__ json __ ()
Matej

Библиотека не работает с Flask 1.0 и выше, так как import flask.ext.whateverбольше не поддерживается в Flask 1.0.
Адарш Мадреча,

14

Из соображений безопасности вы никогда не должны возвращать все поля модели. Я предпочитаю выборочно выбирать их.

JSON КОЛБА в кодирующем теперь поддерживает UUID, DateTime и отношения (и добавляемый queryи query_classдля flask_sqlalchemy db.Modelкласса). Я обновил кодировщик следующим образом:

Приложение / json_encoder.py

    from sqlalchemy.ext.declarative import DeclarativeMeta
    from flask import json


    class AlchemyEncoder(json.JSONEncoder):
        def default(self, o):
            if isinstance(o.__class__, DeclarativeMeta):
                data = {}
                fields = o.__json__() if hasattr(o, '__json__') else dir(o)
                for field in [f for f in fields if not f.startswith('_') and f not in ['metadata', 'query', 'query_class']]:
                    value = o.__getattribute__(field)
                    try:
                        json.dumps(value)
                        data[field] = value
                    except TypeError:
                        data[field] = None
                return data
            return json.JSONEncoder.default(self, o)

app/__init__.py

# json encoding
from app.json_encoder import AlchemyEncoder
app.json_encoder = AlchemyEncoder

При этом я могу при желании добавить __json__свойство, которое возвращает список полей, которые я хочу кодировать:

app/models.py

class Queue(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    song_id = db.Column(db.Integer, db.ForeignKey('song.id'), unique=True, nullable=False)
    song = db.relationship('Song', lazy='joined')
    type = db.Column(db.String(20), server_default=u'audio/mpeg')
    src = db.Column(db.String(255), nullable=False)
    created_at = db.Column(db.DateTime, server_default=db.func.now())
    updated_at = db.Column(db.DateTime, server_default=db.func.now(), onupdate=db.func.now())

    def __init__(self, song):
        self.song = song
        self.src = song.full_path

    def __json__(self):
        return ['song', 'src', 'type', 'created_at']

Я добавляю @jsonapi к своему представлению, возвращаю список результатов, и затем мой вывод выглядит следующим образом:

[

{

    "created_at": "Thu, 23 Jul 2015 11:36:53 GMT",
    "song": 

        {
            "full_path": "/static/music/Audioslave/Audioslave [2002]/1 Cochise.mp3",
            "id": 2,
            "path_name": "Audioslave/Audioslave [2002]/1 Cochise.mp3"
        },
    "src": "/static/music/Audioslave/Audioslave [2002]/1 Cochise.mp3",
    "type": "audio/mpeg"
}

]

Прекрасный! Еще раз, докажите, что иногда вам не нужен полный пакет для каждой глупой маленькой задачи - что изучение DSL может быть сложнее, чем делать это «сложным» способом. Я посмотрел на множество пакетов JSON и REST, прежде чем приземлиться здесь. Правда, это по- прежнему требует пакет, flask_jsontools (добавить @jsonapiк @app.routeв views.py и т.д.), но я люблю простоту этого. Я думаю, что это дешевый Flask, добавленный datetime, но не date, поэтому я добавил его сам в json_encoder.py : value=...^ if isinstance(value, date):^ data[field] = datetime.combine(value, time.min).isoformat()^ else:^try:...
juanitogan

11

Вы можете использовать самоанализ SqlAlchemy так:

mysql = SQLAlchemy()
from sqlalchemy import inspect

class Contacts(mysql.Model):  
    __tablename__ = 'CONTACTS'
    id = mysql.Column(mysql.Integer, primary_key=True)
    first_name = mysql.Column(mysql.String(128), nullable=False)
    last_name = mysql.Column(mysql.String(128), nullable=False)
    phone = mysql.Column(mysql.String(128), nullable=False)
    email = mysql.Column(mysql.String(128), nullable=False)
    street = mysql.Column(mysql.String(128), nullable=False)
    zip_code = mysql.Column(mysql.String(128), nullable=False)
    city = mysql.Column(mysql.String(128), nullable=False)
    def toDict(self):
        return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }

@app.route('/contacts',methods=['GET'])
def getContacts():
    contacts = Contacts.query.all()
    contactsArr = []
    for contact in contacts:
        contactsArr.append(contact.toDict()) 
    return jsonify(contactsArr)

@app.route('/contacts/<int:id>',methods=['GET'])
def getContact(id):
    contact = Contacts.query.get(id)
    return jsonify(contact.toDict())

Получите вдохновение от ответа здесь: Конвертируйте объект строки sqlalchemy в python dict


5

Более подробное объяснение. В вашей модели добавьте:

def as_dict(self):
       return {c.name: str(getattr(self, c.name)) for c in self.__table__.columns}

Это str()для Python 3, поэтому при использовании Python 2 используйте unicode(). Это должно помочь десериализировать даты. Вы можете удалить его, если не имеете дела с ними.

Теперь вы можете запросить базу данных, как это

some_result = User.query.filter_by(id=current_user.id).first().as_dict()

First()необходимо, чтобы избежать странных ошибок. as_dict()теперь будет десериализовать результат. После десериализации он готов к обращению в json

jsonify(some_result)

3

Это не так просто. Я написал код для этого. Я все еще работаю над этим, и он использует фреймворк MochiKit. Он в основном транслирует составные объекты между Python и Javascript, используя прокси и зарегистрированные JSON-конвертеры.

Сторона браузера для объектов базы данных - db.js. Для него нужен базовый источник прокси Python в proxy.js .

На стороне Python есть базовый прокси-модуль . Затем, наконец, объектный кодировщик SqlAlchemy в webserver.py . Это также зависит от экстракторов метаданных, найденных в файле models.py .


Довольно сложно с первого взгляда ... Что мне нужно - это получить результат запроса объектов SQLAlchemy в формате JSON / XML, чтобы использовать его в javascript datagird (JQGrid trirand.com/blog )
Zelid

Иногда проблемы сложнее, чем вы думаете на первый взгляд ... Это обрабатывает объекты, возвращаемые как внешние ключи, и пытается избежать бесконечной рекурсии, которая происходит с глубоко вложенными отношениями. Однако вы, вероятно, могли бы написать несколько пользовательских запросов, которые возвращают только базовые типы, и сериализовать их с помощью simplejson напрямую.
Кит

1
Правильно, может быть, я действительно пойду с запросом на наличие диктов с помощью SQLAlchemy и воспользуюсь преимуществами ORM, выполняющими только действия сохранения / обновления.
Зелид

3

В то время как первоначальный вопрос возвращается некоторое время назад, количество ответов здесь (и мой собственный опыт) позволяют предположить, что это нетривиальный вопрос с множеством различных подходов различной сложности с различными компромиссами.

Вот почему я создал библиотеку SQLAthanor, которая расширяет декларативную ORM SQLAlchemy с настраиваемой поддержкой сериализации / десериализации , на которую вы, возможно, захотите взглянуть.

Библиотека поддерживает:

  • Python 2.7, 3.4, 3.5 и 3.6.
  • SQLAlchemy версии 0.9 и выше
  • сериализация / десериализация в / из JSON, CSV, YAML и Python dict
  • сериализация / десериализация столбцов / атрибутов, отношений, гибридных свойств и прокси-серверов ассоциаций
  • включение и отключение сериализации для определенных форматов и столбцов / отношений / атрибутов (например, вы хотите поддерживать входящее password значение, но никогда не включать исходящее )
  • обработка перед сериализацией и после десериализации (для проверки или приведения типа)
  • довольно простой синтаксис, который является и Pythonic и полностью совместим с собственным подходом SQLAlchemy

Вы можете ознакомиться с (я надеюсь!) Исчерпывающими документами здесь: https://sqlathanor.readthedocs.io/en/latest

Надеюсь это поможет!


2

Пользовательские сериализация и десериализация.

from_json (метод класса) создает объект Model на основе данных json.

«Десериализация» может быть вызвана только в экземпляре и объединить все данные из json в экземпляр модели.

"serialize" - рекурсивная сериализация

Свойство __write_only__ необходимо для определения свойств только для записи (например, «password_hash»).

class Serializable(object):
    __exclude__ = ('id',)
    __include__ = ()
    __write_only__ = ()

    @classmethod
    def from_json(cls, json, selfObj=None):
        if selfObj is None:
            self = cls()
        else:
            self = selfObj
        exclude = (cls.__exclude__ or ()) + Serializable.__exclude__
        include = cls.__include__ or ()
        if json:
            for prop, value in json.iteritems():
                # ignore all non user data, e.g. only
                if (not (prop in exclude) | (prop in include)) and isinstance(
                        getattr(cls, prop, None), QueryableAttribute):
                    setattr(self, prop, value)
        return self

    def deserialize(self, json):
        if not json:
            return None
        return self.__class__.from_json(json, selfObj=self)

    @classmethod
    def serialize_list(cls, object_list=[]):
        output = []
        for li in object_list:
            if isinstance(li, Serializable):
                output.append(li.serialize())
            else:
                output.append(li)
        return output

    def serialize(self, **kwargs):

        # init write only props
        if len(getattr(self.__class__, '__write_only__', ())) == 0:
            self.__class__.__write_only__ = ()
        dictionary = {}
        expand = kwargs.get('expand', ()) or ()
        prop = 'props'
        if expand:
            # expand all the fields
            for key in expand:
                getattr(self, key)
        iterable = self.__dict__.items()
        is_custom_property_set = False
        # include only properties passed as parameter
        if (prop in kwargs) and (kwargs.get(prop, None) is not None):
            is_custom_property_set = True
            iterable = kwargs.get(prop, None)
        # loop trough all accessible properties
        for key in iterable:
            accessor = key
            if isinstance(key, tuple):
                accessor = key[0]
            if not (accessor in self.__class__.__write_only__) and not accessor.startswith('_'):
                # force select from db to be able get relationships
                if is_custom_property_set:
                    getattr(self, accessor, None)
                if isinstance(self.__dict__.get(accessor), list):
                    dictionary[accessor] = self.__class__.serialize_list(object_list=self.__dict__.get(accessor))
                # check if those properties are read only
                elif isinstance(self.__dict__.get(accessor), Serializable):
                    dictionary[accessor] = self.__dict__.get(accessor).serialize()
                else:
                    dictionary[accessor] = self.__dict__.get(accessor)
        return dictionary

2

Вот решение, которое позволяет вам выбрать отношения, которые вы хотите включить в свой вывод, настолько глубоко, насколько вы хотели бы. ПРИМЕЧАНИЕ. Это полная перезапись, в которой в качестве аргумента используется аргумент dict / str, а не список. исправляет некоторые вещи ..

def deep_dict(self, relations={}):
    """Output a dict of an SA object recursing as deep as you want.

    Takes one argument, relations which is a dictionary of relations we'd
    like to pull out. The relations dict items can be a single relation
    name or deeper relation names connected by sub dicts

    Example:
        Say we have a Person object with a family relationship
            person.deep_dict(relations={'family':None})
        Say the family object has homes as a relation then we can do
            person.deep_dict(relations={'family':{'homes':None}})
            OR
            person.deep_dict(relations={'family':'homes'})
        Say homes has a relation like rooms you can do
            person.deep_dict(relations={'family':{'homes':'rooms'}})
            and so on...
    """
    mydict =  dict((c, str(a)) for c, a in
                    self.__dict__.items() if c != '_sa_instance_state')
    if not relations:
        # just return ourselves
        return mydict

    # otherwise we need to go deeper
    if not isinstance(relations, dict) and not isinstance(relations, str):
        raise Exception("relations should be a dict, it is of type {}".format(type(relations)))

    # got here so check and handle if we were passed a dict
    if isinstance(relations, dict):
        # we were passed deeper info
        for left, right in relations.items():
            myrel = getattr(self, left)
            if isinstance(myrel, list):
                mydict[left] = [rel.deep_dict(relations=right) for rel in myrel]
            else:
                mydict[left] = myrel.deep_dict(relations=right)
    # if we get here check and handle if we were passed a string
    elif isinstance(relations, str):
        # passed a single item
        myrel = getattr(self, relations)
        left = relations
        if isinstance(myrel, list):
            mydict[left] = [rel.deep_dict(relations=None)
                                 for rel in myrel]
        else:
            mydict[left] = myrel.deep_dict(relations=None)

    return mydict

так, например, используя человека / семью / дома / комнаты ... превращая его в JSON, все, что вам нужно, это

json.dumps(person.deep_dict(relations={'family':{'homes':'rooms'}}))

Это хорошо, я думаю, просто поместить в ваш базовый класс, чтобы все объекты имели его. Я оставлю вам кодировку JSON ...
Тахо

Обратите внимание, что эта версия получит все списочные отношения, поэтому будьте осторожны, предоставляя связи с кучей предметов ...
Тахо

1
def alc2json(row):
    return dict([(col, str(getattr(row,col))) for col in row.__table__.columns.keys()])

Я думал, что поиграю в маленький гольф с этим.

К вашему сведению: я использую automap_base, так как у нас есть отдельно разработанная схема в соответствии с требованиями бизнеса. Я только что начал использовать SQLAlchemy сегодня, но в документации говорится, что automap_base является расширением декларативной_базы, которая, кажется, является типичной парадигмой в ORM SQLAlchemy, поэтому я считаю, что это должно работать.

Ему не нравятся следующие внешние ключи для решения Tjorriemorrie , но он просто сопоставляет столбцы со значениями и обрабатывает типы Python с помощью str () - значений столбцов. Наши значения состоят из Python datetime.time и decimal.Decimal, результаты типа класса, поэтому он выполняет свою работу.

Надеюсь, это поможет любому прохожему!


1

Я знаю, что это довольно старый пост. Я принял решение, данное @SashaB, и изменил его в соответствии с моими потребностями.

Я добавил следующие вещи к нему:

  1. Список игнорируемых полей: список полей, которые нужно игнорировать при сериализации
  2. Список замены полей: словарь, содержащий имена полей, которые должны быть заменены значениями при сериализации.
  3. Удаленные методы и BaseQuery становятся сериализованными

Мой код выглядит следующим образом:

def alchemy_json_encoder(revisit_self = False, fields_to_expand = [], fields_to_ignore = [], fields_to_replace = {}):
   """
   Serialize SQLAlchemy result into JSon
   :param revisit_self: True / False
   :param fields_to_expand: Fields which are to be expanded for including their children and all
   :param fields_to_ignore: Fields to be ignored while encoding
   :param fields_to_replace: Field keys to be replaced by values assigned in dictionary
   :return: Json serialized SQLAlchemy object
   """
   _visited_objs = []
   class AlchemyEncoder(json.JSONEncoder):
      def default(self, obj):
        if isinstance(obj.__class__, DeclarativeMeta):
            # don't re-visit self
            if revisit_self:
                if obj in _visited_objs:
                    return None
                _visited_objs.append(obj)

            # go through each field in this SQLalchemy class
            fields = {}
            for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata' and x not in fields_to_ignore]:
                val = obj.__getattribute__(field)
                # is this field method defination, or an SQLalchemy object
                if not hasattr(val, "__call__") and not isinstance(val, BaseQuery):
                    field_name = fields_to_replace[field] if field in fields_to_replace else field
                    # is this field another SQLalchemy object, or a list of SQLalchemy objects?
                    if isinstance(val.__class__, DeclarativeMeta) or \
                            (isinstance(val, list) and len(val) > 0 and isinstance(val[0].__class__, DeclarativeMeta)):
                        # unless we're expanding this field, stop here
                        if field not in fields_to_expand:
                            # not expanding this field: set it to None and continue
                            fields[field_name] = None
                            continue

                    fields[field_name] = val
            # a json-encodable dict
            return fields

        return json.JSONEncoder.default(self, obj)
   return AlchemyEncoder

Надеюсь, это поможет кому-то!


1

Используйте встроенный сериализатор в SQLAlchemy:

from sqlalchemy.ext.serializer import loads, dumps
obj = MyAlchemyObject()
# serialize object
serialized_obj = dumps(obj)

# deserialize object
obj = loads(serialized_obj)

Если вы переносите объект между сеансами, не забудьте отсоединить объект от текущего сеанса с помощью session.expunge(obj). Чтобы прикрепить его снова, просто сделайте session.add(obj).


Отличный, но не конвертируется в JSON.
Blakev

2
Для JSON 'сериализации' проверьте зефир-sqlalchemy . Определенно лучшее решение, когда вы выставляете объекты клиентам. marshmallow-sqlalchemy.readthedocs.io
chribsen

Модуль сериализатора подходит только для структур запросов. Он не нужен для: экземпляров пользовательских классов. Они не содержат ссылок на механизмы, сеансы или конструкции выражений в типичном случае и могут быть сериализованы напрямую.
Томас

1

следующий код будет сериализовать результат sqlalchemy в json.

import json
from collections import OrderedDict


def asdict(self):
    result = OrderedDict()
    for key in self.__mapper__.c.keys():
        if getattr(self, key) is not None:
            result[key] = str(getattr(self, key))
        else:
            result[key] = getattr(self, key)
    return result


def to_array(all_vendors):
    v = [ ven.asdict() for ven in all_vendors ]
    return json.dumps(v) 

Вызывая веселье,

def all_products():
    all_products = Products.query.all()
    return to_array(all_products)

1

AlchemyEncoder замечательный, но иногда терпит неудачу с десятичными значениями. Вот улучшенный кодер, который решает десятичную проблему -

class AlchemyEncoder(json.JSONEncoder):
# To serialize SQLalchemy objects 
def default(self, obj):
    if isinstance(obj.__class__, DeclarativeMeta):
        model_fields = {}
        for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:
            data = obj.__getattribute__(field)
            print data
            try:
                json.dumps(data)  # this will fail on non-encodable values, like other classes
                model_fields[field] = data
            except TypeError:
                model_fields[field] = None
        return model_fields
    if isinstance(obj, Decimal):
        return float(obj)
    return json.JSONEncoder.default(self, obj)

1

При использовании sqlalchemy для подключения к БД I это простое решение, которое легко настраивается. Используйте панд.

import pandas as pd
import sqlalchemy

#sqlalchemy engine configuration
engine = sqlalchemy.create_engine....

def my_function():
  #read in from sql directly into a pandas dataframe
  #check the pandas documentation for additional config options
  sql_DF = pd.read_sql_table("table_name", con=engine)

  # "orient" is optional here but allows you to specify the json formatting you require
  sql_json = sql_DF.to_json(orient="index")

  return sql_json

1
step1:
class CNAME:
   ...
   def as_dict(self):
       return {item.name: getattr(self, item.name) for item in self.__table__.columns}

step2:
list = []
for data in session.query(CNAME).all():
    list.append(data.as_dict())

step3:
return jsonify(list)

3
Дампы кода без каких-либо объяснений редко бывают полезными. Переполнение стека касается обучения, а не предоставления фрагментов для слепого копирования и вставки. Пожалуйста, отредактируйте свой вопрос и объясните, как он работает лучше, чем предоставленный ОП.
Крис

0

Под Flask это работает и обрабатывает поля времени данных, превращая поле типа
'time': datetime.datetime(2018, 3, 22, 15, 40)в
"time": "2018-03-22 15:40:00":

obj = {c.name: str(getattr(self, c.name)) for c in self.__table__.columns}

# This to get the JSON body
return json.dumps(obj)

# Or this to get a response object
return jsonify(obj)

0

Встроенные дроссели сериализатора с utf-8 не могут декодировать недопустимый начальный байт для некоторых входов. Вместо этого я пошел с:

def row_to_dict(row):
    temp = row.__dict__
    temp.pop('_sa_instance_state', None)
    return temp


def rows_to_list(rows):
    ret_rows = []
    for row in rows:
        ret_rows.append(row_to_dict(row))
    return ret_rows


@website_blueprint.route('/api/v1/some/endpoint', methods=['GET'])
def some_api():
    '''
    /some_endpoint
    '''
    rows = rows_to_list(SomeModel.query.all())
    response = app.response_class(
        response=jsonplus.dumps(rows),
        status=200,
        mimetype='application/json'
    )
    return response

0

Может быть, вы можете использовать такой класс

from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy import Table


class Custom:
    """Some custom logic here!"""

    __table__: Table  # def for mypy

    @declared_attr
    def __tablename__(cls):  # pylint: disable=no-self-argument
        return cls.__name__  # pylint: disable= no-member

    def to_dict(self) -> Dict[str, Any]:
        """Serializes only column data."""
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

Base = declarative_base(cls=Custom)

class MyOwnTable(Base):
    #COLUMNS!

При этом все объекты имеют to_dictметод


0

Используя некоторые необработанные sql и неопределенные объекты, я использовал, cursor.descriptionчтобы получить то, что я искал:

with connection.cursor() as cur:
    print(query)
    cur.execute(query)
    for item in cur.fetchall():
        row = {column.name: item[i] for i, column in enumerate(cur.description)}
        print(row)

-2

Мой дубль, использующий (слишком много?) Словарей:

def serialize(_query):
    #d = dictionary written to per row
    #D = dictionary d is written to each time, then reset
    #Master = dictionary of dictionaries; the id Key (int, unique from database) 
    from D is used as the Key for the dictionary D entry in Master
    Master = {}
    D = {}
    x = 0
    for u in _query:
        d = u.__dict__
        D = {}
        for n in d.keys():
           if n != '_sa_instance_state':
                    D[n] = d[n]
        x = d['id']
        Master[x] = D
    return Master

Запуск с flask (включая jsonify) и flask_sqlalchemy для печати выводов в формате JSON.

Вызовите функцию с помощью jsonify (serialize ()).

Работает со всеми запросами SQLAlchemy, которые я пробовал до сих пор (работает SQLite3)

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.