python - কিভাবে এসএলএলএলকিমি ফলাফল JSON করতে serialize?




sqlalchemy (14)

একটি সমতল বাস্তবায়ন

আপনি এই মত কিছু ব্যবহার করতে পারেন:

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)

এটি এমন ক্ষেত্রগুলিকে উপেক্ষা করবে যা এনকোডেবেল নয় (তাদেরকে 'কোনটি' তে সেট করুন)।

এটি সম্পর্কগুলি স্বয়ংক্রিয়ভাবে প্রসারিত করে না (এটি স্ব-রেফারেন্সগুলিতে এবং সর্বদা লুপ হতে পারে)।

একটি recursive, অ-বৃত্তাকার বাস্তবায়ন

যদি, আপনি বরং চিরতরে লুপ চান তবে আপনি ব্যবহার করতে পারেন:

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)

এটি সমস্ত বাচ্চাদের, এবং তাদের সমস্ত বাচ্চাদের এবং তাদের সমস্ত সন্তানদের এনকোড করবে ... মূলত আপনার সম্পূর্ণ ডাটাবেসটি এনকোড করবে। যখন এটি এর আগে এনকোড করা কিছু পৌঁছায়, এটি এটি 'এনকোড' হিসাবে এনকোড করবে।

একটি recursive, সম্ভবত বৃত্তাকার, নির্বাচনী বাস্তবায়ন

আরেকটি বিকল্প, সম্ভবত ভাল, আপনি প্রসারিত করতে চান এমন ক্ষেত্রগুলি নির্দিষ্ট করতে সক্ষম হবেন:

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)

উদাহরণস্বরূপ, শুধুমাত্র 'বাবা-মা' নামক SQLACchemy ক্ষেত্রগুলি প্রসারিত করুন।

ডিজিও থেকে ডিআর থেকে JSON ফরম্যাটে ফিরে আসা ORM মডেলগুলির কিছু ভাল স্বয়ংক্রিয় সিরিয়ালাইজেশন রয়েছে।

এসকিউএলএলকিমিয়ের প্রশ্নের জেসন ফরম্যাটে ক্রমবর্ধমান কিভাবে?

আমি jsonpickle.encode চেষ্টা jsonpickle.encode কিন্তু এটি কোয়েরি বস্তু নিজেই এনকোড। আমি json.dumps(items) চেষ্টা কিন্তু এটি ফেরত

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

JSON / XML এ SQLACchemy ORM অবজেক্টগুলিকে সিরিয়ালাইজ করা কি সত্যিই কঠিন? এর জন্য কোন ডিফল্ট সিরিয়ালাইজার নেই? আজকাল ORM জিজ্ঞাস্য ফলাফল serialize এটি খুবই সাধারণ কাজ।

আমার যা দরকার তা হল সাকল্লিমির প্রশ্নের ফলাফলের JSON বা XML তথ্য উপস্থাপনের জন্য।

জাভাস্ক্রিপ্ট ড্যাটাগার্ডে (JQGrid http://www.trirand.com/blog/ ) ব্যবহার করার জন্য JSON / XML ফর্ম্যাটে SQLAlchemy অবজেক্টের অনুসন্ধানের ফলাফল প্রয়োজন।


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)

আপনি এই হিসাবে SqlAlchemy introspection ব্যবহার করতে পারেন:

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 সারি বস্তু পাইথন dict রূপান্তর করুন


আপনি একটি RowProxy একটি dict তে রূপান্তর করতে পারেন:

 d = dict(row.items())

তারপরে JSON এ সিরিয়ালাইজ করুন (আপনাকে datetime মানগুলির মতো জিনিসগুলির জন্য এনকোডার উল্লেখ করতে হবে) যদি আপনি কেবল একটি রেকর্ড চান (এবং সংশ্লিষ্ট রেকর্ডগুলির পূর্ণ শ্রেণীবিন্যাস না) এটি কঠিন নয়।

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

আমার গ্রহণ ব্যবহার (অনেক?) অভিধান:

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

JSON হিসাবে আউটপুট প্রিন্ট করার জন্য ফ্লাস্ক (জেএসএসআইআই সহ) এবং flask_sqlalchemy দিয়ে চলমান।

Jsonify সঙ্গে ক্রিয়া কল করুন (serialize ())।

সমস্ত SQLAlchemy প্রশ্নের সাথে কাজ করে আমি এখন পর্যন্ত চেষ্টা করেছি (SQLite3 চলমান)


আমি এই পুরানো পোস্ট বেশ জানি। আমি @ সাশাব দ্বারা প্রদত্ত সমাধান গ্রহণ করেছি এবং আমার প্রয়োজন অনুযায়ী সংশোধন করা হয়েছে।

আমি এটি নিম্নলিখিত জিনিস যোগ করেছেন:

  1. ক্ষেত্র অগ্রাহ্য তালিকা: serializing যখন ক্ষেত্রের একটি তালিকা উপেক্ষা করা হবে
  2. ক্ষেত্র তালিকা প্রতিস্থাপন: serializing যখন ক্ষেত্র নাম ধারণকারী একটি অভিধান মান দ্বারা প্রতিস্থাপিত করা।
  3. সরানো পদ্ধতি এবং বেসওয়্যার ক্রমবর্ধমান হচ্ছে

নিম্নরূপ আমার কোড:

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

এটা কেউ সাহায্য করে আশা করি!


আরো বিস্তারিত ব্যাখ্যা। আপনার মডেলের মধ্যে যোগ করুন:

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

str() পাইথন 3 এর জন্য তাই পাইথন 2 ব্যবহার করলে unicode() ব্যবহার করুন। এটা তারিখ deserialize সাহায্য করা উচিত। তাদের সাথে ডিল না করলে আপনি এটি মুছে ফেলতে পারেন।

আপনি এখন এই মত ডাটাবেস অনুসন্ধান করতে পারেন

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

First() অদ্ভুত ত্রুটি এড়াতে প্রয়োজন হয়। as_dict() এখন ফলাফল as_dict() হবে। Deserialization পরে, এটা জসন পরিণত করতে প্রস্তুত

jsonify(some_result)

আসল প্রশ্নটি কিছুক্ষণের মধ্যে ফিরে গেলে, এখানে উত্তরগুলির সংখ্যা (এবং আমার নিজের অভিজ্ঞতা) বিভিন্ন ট্রেড-অফগুলির সাথে বিভিন্ন জটিলতার বিভিন্ন পন্থাগুলির সাথে এটি একটি অ-তুচ্ছ প্রশ্ন।

এজন্যই আমি SQLAthanor লাইব্রেরী তৈরি করেছি যা SQLAthanor ঘোষনামূলক ORM কে কনফিগারযোগ্য সিরিয়ালাইজেশান / ডি-সিরিয়ালাইজেশনের সহায়তায় প্রসারিত করে যা আপনি দেখতে চাইতে পারেন।

গ্রন্থাগার সমর্থন করে:

  • পাইথন 2.7, 3.4, 3.5, এবং 3.6।
  • SQLAlchemy সংস্করণ 0.9 এবং উচ্চতর
  • JSON, CSV, YAML, এবং Python dict থেকে / থেকে সিরিয়ালাইজেশান / ডি-সিরিয়ালাইজেশন
  • সিরিয়ালাইজেশন / কলাম / গুণাবলী, সম্পর্ক, সংকর সম্পত্তি, এবং অ্যাসোসিয়েশন প্রক্সি ডি-সিরিয়ালাইজেশন
  • নির্দিষ্ট ফরম্যাট এবং কলাম / সম্পর্ক / গুণাবলীগুলির জন্য সিরিয়ালাইজেশন সক্রিয় এবং নিষ্ক্রিয় করা (উদাহরণস্বরূপ আপনি একটি অন্তর্বর্তী password মান সমর্থন করতে চান, তবে কোনও আউটবর্ড অন্তর্ভুক্ত করবেন না)
  • প্রাক-সিরিয়ালাইজেশন এবং পোস্ট-ডিসেরিয়ালাইজেশান মান প্রক্রিয়াকরণ (বৈধকরণ বা টাইপ জোরপূর্বক)
  • একটি চমত্কার সহজবোধ্য সিনট্যাক্স যা পাইথনিক উভয় এবং SQLAKCHEYI এর নিজস্ব পদ্ধতির সাথে সামঞ্জস্যপূর্ণ সামঞ্জস্যপূর্ণ

আপনি এখানে (আমি আশা করি) ব্যাপক ডক্সগুলি পরীক্ষা করতে পারি: https://sqlathanor.readthedocs.io/en/latest

আশাকরি এটা সাহায্য করবে!


এটা এত straighforward হয় না। আমি এই কাজ কিছু কোড লিখেছেন। আমি এখনও এটিতে কাজ করছি, এবং এটি MochiKit ফ্রেমওয়ার্ক ব্যবহার করে। এটি মূলত প্রক্সি এবং নিবন্ধিত JSON রূপান্তরকারী ব্যবহার করে পাইথন এবং জাভাস্ক্রিপ্টের মধ্যে যৌগিক বস্তুর অনুবাদ করে।

ডাটাবেস অবজেক্টের জন্য ব্রাউজারের দিকটি db.js এটি প্রক্সি.জেএসগুলিতে বেসিক পাইথন প্রক্সি উত্স proxy.js

পাইথনের পাশে বেস প্রক্সি মডিউল রয়েছে । অবশেষে webserver.py এ SqlAlchemy অবজেক্ট এনকোডার। এটি models.py ফাইলটিতে পাওয়া মেটাডেটা এক্সট্র্যাক্টরগুলির উপরও নির্ভর করে।


কাস্টম সিরিয়ালাইজেশন এবং deserialization।

"from_json" (ক্লাস পদ্ধতি) জson ডেটা ভিত্তিক একটি মডেল অবজেক্ট তৈরি করে।

"deserialize" শুধুমাত্র উদাহরণস্বরূপ বলা যেতে পারে, এবং জেসন থেকে মডেলের উদাহরণে সমস্ত তথ্য একত্রিত করতে পারে।

"serialize" - পুনরাবৃত্তি serialization

__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

নিরাপত্তার কারণে আপনাকে কখনোই সব মডেলের ক্ষেত্রগুলি ফেরত দিতে হবে না। আমি নির্বাচন করে তাদের পছন্দ করে নিন।

ফ্লাস এর জসন এনকোডিং এখন UUID, ডেটটাইম এবং সম্পর্কগুলিকে সমর্থন করে (এবং ফ্লাস_সাক্লালেকমি db.Model ক্লাসের জন্য যোগ করা query এবং query_class )। নিম্নরূপ আমি এনকোডার আপডেট করেছি:

অ্যাপ্লিকেশন / 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"
}

]

নির্মিত serializer utf-8 chokes কিছু ইনপুট জন্য অবৈধ শুরু বাইট ডিকোড করতে পারে না। পরিবর্তে, আমি সঙ্গে গিয়েছিলাম:

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

Flask-JsonTools প্যাকেজটি আপনার মডেলগুলির জন্য JsonSerializableBase বেস JsonSerializableBase ক্লাসের বাস্তবায়ন করেছে।

ব্যবহার:

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

Base = declarative_base(cls=(JsonSerializableBase,))

class User(Base):
    #...

এখন User মডেল magically serializable হয়।

আপনার কাঠামো ফ্লাস্ক না হয়, আপনি শুধু কোড দখল করতে পারেন


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

আমি এই এক সঙ্গে একটু কোড গলফ খেলা চাই।

FYI: আমি automap_base ব্যবহার automap_base কারণ আমাদের ব্যবসায়িক প্রয়োজনীয়তা অনুযায়ী আলাদাভাবে পরিকল্পিত স্কিমা আছে। আমি আজ সিকিএলচেমি ব্যবহার করে শুরু করেছি কিন্তু ডকুমেন্টেশন বলেছে যে automap_base declarative_base এর একটি এক্সটেনশান যা এসকিউএলএলকিমি ওআরএমের আদর্শ আদর্শ বলে মনে হয় তাই আমি বিশ্বাস করি এটি কাজ করা উচিত।

এটি Tjorriemorrie এর সমাধান Tjorriemorrie বিদেশী কীগুলি অনুসরণের সাথে অভিনব নয়, তবে এটি কলামের মানগুলিতে str () - এর দ্বারা পাইথন প্রকারগুলি মান এবং পরিচালনা করার জন্য কলামগুলির সাথে মেলে। আমাদের মান Python datetime.time এবং দশমিক গঠিত। দশমিক ক্লাস টাইপ ফলাফল তাই এটি কাজ পায়।

এই কোন passers দ্বারা সাহায্য করে!







sqlalchemy