<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jordan Bae on Medium]]></title>
        <description><![CDATA[Stories by Jordan Bae on Medium]]></description>
        <link>https://medium.com/@doosikbae?source=rss-2dd1d38cdcab------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*jqIvP7g_TYZfhoFnUISfRA.jpeg</url>
            <title>Stories by Jordan Bae on Medium</title>
            <link>https://medium.com/@doosikbae?source=rss-2dd1d38cdcab------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 20:12:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@doosikbae/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[넷플릭스-규칙없음]]></title>
            <link>https://medium.com/@doosikbae/%EB%84%B7%ED%94%8C%EB%A6%AD%EC%8A%A4-%EA%B7%9C%EC%B9%99%EC%97%86%EC%9D%8C-14e629f19abd?source=rss-2dd1d38cdcab------2</link>
            <guid isPermaLink="false">https://medium.com/p/14e629f19abd</guid>
            <category><![CDATA[스타트업]]></category>
            <category><![CDATA[기업문화]]></category>
            <dc:creator><![CDATA[Jordan Bae]]></dc:creator>
            <pubDate>Sat, 21 Sep 2024 06:45:41 GMT</pubDate>
            <atom:updated>2024-09-21T06:46:34.898Z</atom:updated>
            <content:encoded><![CDATA[<h3>개요</h3><p>넷플릭스의 기업 문화에 대한 책으로 자율과 책임을 기반으로 운영되는 넷플릭스 문화를 설명하는 책이다. 넷플릭스라는 회사의 브랜드 파워뿐만 아니라 개발자들 사이에서도 ‘연봉이 가장 높은 회사’, ‘성과 안 나오면 바로 해고되는 회사’로 유명했기 때문에 주변에 많은 사람들이 책이 출간되자마자 읽었던 책이다. 예전에 한 번 읽다가 ‘이게 우리나라에서 될까?’ 하는 물음표와 함께 접었던 책을 이유 없이 꺼내 들어 끝까지 읽었다.</p><p>대기업이나 중견기업에서 일해본 사람이라면 비효율적인 프로세스로 혀를 차지 않은 사람이 없을 것이다. LG에서 일할 때 구매팀에 구매 요청을 하러 전화하고, 자리에 찾아가고 했던 것을 기억하면 정말…..모든 프로세스와 비효율에는 이유가 있지만 ‘이게 맞나’라는 생각이 항상 들었다. 이 책에서 설명하는 것처럼 회사의 제품이나 팀의 성격에 따라서 규칙과 통제가 필수적인 곳도 있지만, 속도와 창의성이 중요한 팀에서는 넷플릭스 문화는 정말정말 강력한 ‘성장 엔진’인 것 같다.</p><h3>모든 것의 전제는 높은 ‘인재밀도’</h3><p>높은 ‘인재밀도’가 먼저다. 낮은 ‘인재밀도’의 회사에서 규칙이 없으면 어떻게 될지는…상상하기도 싫다.</p><p>스타트업이든 대기업이든 높은 ‘인재밀도’를 유지하는 것은 다양한 이유로 무척이나 어렵다. 특히, 나는 채용이 중요하다고 생각하는데, 그 이유는 뛰어난 인재는 자기 객관화를 잘한다. 그렇기 때문에 회사와 잘 안 맞거나 퍼포먼스가 안 나오는 경우 잘 인정할 수 있다. 또, 우리나라에서는 해고가 어렵기 때문에 채용이 더욱 중요한 것 같다. 넷플릭스는 업계 최고 수준으로 대우해 주고 이에 맞는 책임을 지게 함으로써 좋은 인재들을 데려오고, 이탈을 막는다.</p><h3>자유와 책임</h3><p>최고의 인재를 데려다가 어떤 업무에 대한 자율성을 주고 책임을 지게 하지 않는 건 엄청난 낭비일 것이다. 아무리 뛰어난 인재라도 수동적인 환경에서는 수동적으로 일하게 된다. 업무를 리드하고 중요한 결정을 내리게 하면 뛰어난 인재는 스스로 몰입하고 최선을 다한다. 물론 실력이 부족한 사람에게 아직 감당할 수 없는 책임을 주는 건 무책임한 행동이겠지만, 넷플릭스는 높은 수준의 인재들이 있는 곳이기 때문에 가능하다.</p><h3>문화를 지탱하는 Detail</h3><p>어떤 규칙이든 이를 뒷받침하는 다양한 방법과 교육이 없으면 잘 유지되지 않는다. 기업의 문화라면 당연히 이를 지탱하기 위한 엄청난 Detail이 필요하다. 넷플릭스와 같은 자율과 책임을 기반으로 하는 문화를 만들려면 해당 문화를 뒷받침하기 위한 자세한 정책들과 교육이 필요하다. 높은 수준의 인재만 데려다 놓는다고 끝나는 것이 아니라, 해당 문화를 글로 명시하고 리더들이 먼저 그렇게 행동해야만 실제 문화가 될 수 있다. 포인트는 맥락을 짚어 줌으로써 자율성을 해치지 않으면서 행동으로 보여주는 거다.</p><ul><li>휴가/경비 사용 및 솔직한 피드백 솔선수범</li><li>영수증 리뷰</li><li>키퍼 테스트</li><li>다양한 교육</li><li>….</li></ul><h3>마무리</h3><p>이 책을 읽으면서 넷플릭스에서 일하는 상상을 하면서, 이런 문화에서 일하기 위해서는 하드 스킬과 소프트 스킬 그리고 업무 태도까지 많이 성장해야겠다는 생각을 했다. 또, 어떻게 하면 내가 일하는 곳에서 좋은 부분을 적용할 수 있을까 하는 생각을 하게 된다. 다시 생각해도 정말 대단하다…! 아키텍처, 코드 스타일 바꾸는 것도 정말 어려운데 조직 문화라니..!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=14e629f19abd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How does Django manage DB connections?]]></title>
            <link>https://medium.com/django-unleashed/how-does-django-manage-db-connections-4c1a009cec91?source=rss-2dd1d38cdcab------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c1a009cec91</guid>
            <category><![CDATA[django]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Jordan Bae]]></dc:creator>
            <pubDate>Sat, 20 Jan 2024 06:14:51 GMT</pubDate>
            <atom:updated>2024-01-20T06:14:51.372Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/598/1*LzqKf1Zy6WQbRsWvaeTVkw.png" /><figcaption>Django</figcaption></figure><p>❗️ This article is based on Django 5.0. The sections where I analyzed the internal code are my interpretations, and there may be misunderstandings</p><h3><strong>How does Django creates DB connection</strong></h3><p>“One of the inconvenient aspects of switching from Django to another framework is having to explicitly manage the DB connection.</p><p>For example, when using Flask with SQLAlchemy, you need to create and manage the database connection as follows.”</p><pre>app.config[&#39;SQLALCHEMY_DATABASE_URI&#39;] = &#39;sqlite:///example.db&#39;<br>db = SQLAlchemy(app)<br><br># add user API<br>@app.route(&#39;/user&#39;, methods=[&#39;POST&#39;])<br>def add_user():<br>    data = request.get_json()<br>    new_user = User(name=data[&#39;name&#39;])<br>    db.session.add(new_user)<br>    db.session.commit()<br>    return jsonify({&#39;message&#39;: &#39;User added successfully&#39;}), 201</pre><p>“As you can see in this code, when using SQLAlchemy, you need to explicitly create a database session, commit and close the session after performing operations. This provides developers with clear control over database connection management, but at the same time, it has the downside of requiring additional code writing.</p><p>In contrast, in Django, the creation and management of database connections are handled internally and automatically. When using Django’s ORM and executing a QuerySet, Django automatically creates a database connection, and the Old Connection is closed when the HTTP request starts and ends (I will explain more about this below). This relieves developers from worrying about creating and managing database connections.</p><p>The way Django automatically manages database connections greatly simplifies development, but it also raises curiosity about how this process actually works. Understanding in detail how Django’s database connection management system is structured and how it operates efficiently can be helpful in gaining a deeper understanding of Django! In this article, we’ll examine how Django internally creates and terminates DB Connections in its internal code, and share settings to improve application performance by reusing DB connections.</p><p>Let’s now take a closer look at how DB Connections are created in Django!”</p><h3>Misunderstandings About Django Connection Creation</h3><p>Django connections are actually established inside the worker thread only when the first query is executed in a situation where there is no connection. Often, people misunderstand that a connection is made for each HTTP request because it is sometimes written in Django documentation, but more accurately, the connection is created not when the HTTP request arrives, but when SQL is executed by QuerySet in the Request’s Handler (View). (That is, if there is no code that executes a query in Middleware or Handler, a connection is not created.)</p><blockquote>Persistent connections avoid the overhead of reestablishing a connection to the database in each HTTP request. They’re controlled by the CONN_MAX_AGE parameter which defines the maximum lifetime of a connection. It can be set independently for each database.</blockquote><p>! Of course, as mentioned above, even if there is no direct query in the view, if DB lookup is required for authentication or if ATOMIC_REQUESTS is set to True, a DB connection may be created for each request to create a transaction.</p><p>FYI) If you want to test this aspect, you should use gunicorn to run the wsgi.py file, not manage.py runserver. This is because the operating mechanism of runserver works differently</p><h3>Creation of DB Connection in Django</h3><p>Yes, to reiterate, the DB Connection is established when the first query is executed in a situation where there is no connection. As an example, when the result of a QuerySet needs to return the DB Select result as an object, the connection is created at the time of executing the SQL if there is no existing connection.</p><p>Let’s verify this through the code!</p><blockquote><strong>Let’s suppose we execute len(User.objects.all()) .</strong></blockquote><ol><li>The above code calls the __len__() magic method of the QuerySet class, which in turn calls the _fetch_all() method, and then it invokes self._iterable_class (which is ModelIterable).</li></ol><pre># db/models/query.py<br>class QuerySet(AltersData):<br>    &quot;&quot;&quot;Represent a lazy database lookup for a set of objects.&quot;&quot;&quot;<br><br>    def __init__(self, model=None, query=None, using=None, hints=None):<br>        self.model = model<br>        self._db = using<br>        self._hints = hints or {}<br>        self._query = query or sql.Query(self.model)<br>        self._result_cache = None<br>        self._sticky_filter = False<br>        self._for_write = False<br>        self._prefetch_related_lookups = ()<br>        self._prefetch_done = False<br>        self._known_related_objects = {}  # {rel_field: {pk: rel_obj}}<br>        # _fetch_all() 에서 return하는 속성<br>        self._iterable_class = ModelIterable<br>        self._fields = None<br>        self._defer_next_filter = False<br>        self._deferred_filter = None<br>    ....<br>    def __len__(self):<br>        self._fetch_all()<br>        return len(self._result_cache)<br>    <br>    def _fetch_all(self):<br>        if self._result_cache is None:<br>            self._result_cache = list(self._iterable_class(self))<br>        if self._prefetch_related_lookups and not self._prefetch_done:<br>            self._prefetch_related_objects()</pre><p>2. The self._fetch_all() method triggers the invocation of the __iter__ magic method of the ModelIterable class. This step is responsible for generating and actually executing the SQL.</p><pre># db/models/query.py<br>class ModelIterable(BaseIterable):<br>    &quot;&quot;&quot;Iterable that yields a model instance for each row.&quot;&quot;&quot;<br><br>    def __iter__(self):<br>        queryset = self.queryset<br>        db = queryset.db<br>        compiler = queryset.query.get_compiler(using=db)<br>        # Execute the query. This will also fill compiler.select, klass_info,<br>        # and annotations.<br>        results = compiler.execute_sql(<br>            chunked_fetch=self.chunked_fetch, chunk_size=self.chunk_size<br>        )</pre><p>3. Inside `compiler.execute_sql()`, the `BaseDatabaseWrapper.cursor()` is called, and within this, `BaseDatabaseWrapper.connect()` is invoked. This is the part that actually creates the DB Connection. Let’s take a closer look at this part.</p><ul><li>The `BaseDatabaseWrapper.cursor()` method called inside `execute_sql()` is where a cursor is created to execute queries in the database. This method calls `ensure_connection`.</li></ul><pre>def execute_sql(<br>        self, result_type=MULTI, chunked_fetch=False, chunk_size=GET_ITERATOR_CHUNK_SIZE<br>    ):<br>        &quot;&quot;&quot;<br>  ...<br>        &quot;&quot;&quot;<br>        result_type = result_type or NO_RESULTS<br>        try:<br>            sql, params = self.as_sql()<br>            if not sql:<br>                raise EmptyResultSet<br>        except EmptyResultSet:<br>            if result_type == MULTI:<br>                return iter([])<br>            else:<br>                return<br>        if chunked_fetch:<br>            cursor = self.connection.chunked_cursor()<br>        else:<br>            cursor = self.connection.cursor()<br>       .....</pre><ul><li>The BaseDatabaseWrapper.ensure_connection() method checks if the current database connection is valid and, if the connection is missing or closed, it calls connect. Please remember this part well!!</li></ul><pre>class BaseDatabaseWrapper:<br>    @async_unsafe<br>    def cursor(self):<br>        &quot;&quot;&quot;Create a cursor, opening a connection if necessary.&quot;&quot;&quot;<br>        return self._cursor()<br><br>    def _cursor(self, name=None):<br>        self.close_if_health_check_failed()<br>        self.ensure_connection()<br>        with self.wrap_database_errors:<br>            return self._prepare_cursor(self.create_cursor(name))<br>   ...<br>   @async_unsafe<br>    def ensure_connection(self):<br>        &quot;&quot;&quot;Guarantee that a connection to the database is established.&quot;&quot;&quot;<br>        if self.connection is None:<br>            with self.wrap_database_errors:<br>                self.connect()</pre><ul><li>The `BaseDatabaseWrapper.connect()` method is what actually establishes the database connection.</li></ul><pre>class BaseDatabaseWrapper:<br>   ...<br>  @async_unsafe<br>    def connect(self):<br>        &quot;&quot;&quot;Connect to the database. Assume that the connection is closed.&quot;&quot;&quot;<br>        # Check for invalid configurations.<br>        self.check_settings()<br>        # In case the previous connection was closed while in an atomic block<br>        self.in_atomic_block = False<br>        self.savepoint_ids = []<br>        self.atomic_blocks = []<br>        self.needs_rollback = False<br>        # Reset parameters defining when to close/health-check the connection.<br>        self.health_check_enabled = self.settings_dict[&quot;CONN_HEALTH_CHECKS&quot;]<br>        max_age = self.settings_dict[&quot;CONN_MAX_AGE&quot;]<br>        self.close_at = None if max_age is None else time.monotonic() + max_age<br>        self.closed_in_transaction = False<br>        self.errors_occurred = False<br>        # New connections are healthy.<br>        self.health_check_done = True<br>        # Establish the connection<br>        conn_params = self.get_connection_params()<br>        self.connection = self.get_new_connection(conn_params)<br>        self.set_autocommit(self.settings_dict[&quot;AUTOCOMMIT&quot;])<br>        self.init_connection_state()<br>        connection_created.send(sender=self.__class__, connection=self)<br><br>        self.run_on_commit = []</pre><p>If we delve a bit deeper, the DB connection is created in the get_new_connection method, which is implemented in the respective DB (MySQL, Postgres, etc.) Wrapper classes.</p><p>To summarize once more, when our created QuerySet executes SQL, if there is no connection, it is created at that moment. Now we have understood how DB connections are created in Django. Next, let’s check when these DB connections are closed.</p><h3>When Do DB Connections Close?</h3><p>“We have seen that in Django, a connection is created in the Thread’s local object when the actual SQL is executed and there is no connection. So, when does the DB Connection close?</p><p>If the Django developer does not explicitly close the connection, Django terminates the Old Connection at the start and end of an HTTP Request.</p><p>If we look at `django/db/__init__.py`, we can find the following code.”</p><pre># For backwards compatibility. Prefer connections[&#39;default&#39;] instead.<br>connection = ConnectionProxy(connections, DEFAULT_DB_ALIAS)<br><br><br>......<br><br># Register an event to reset transaction state and close connections past<br># their lifetime.<br>def close_old_connections(**kwargs):<br>    for conn in connections.all(initialized_only=True):<br>        conn.close_if_unusable_or_obsolete()<br><br><br>signals.request_started.connect(close_old_connections)<br>signals.request_finished.connect(close_old_connections)</pre><p>Django executes the function `close_old_connections` both before starting and after completing a view handler for an HTTP request.</p><p>The `close_old_connections` function is responsible for closing Old connections that have been created. In detail, it closes connections in cases like the following. In other words, Old connections can be considered as belonging to the following cases:</p><ul><li>When the current session’s autocommit setting is different from the global setting.<br>- When an error has occurred and `is_usable` is False.<br>- When `self.close_at` exists and is less than the current time (this part will be covered in more detail in the following section).</li></ul><pre># db/backends/base/base.py<br><br>class BaseDatabaseWrapper:<br>   ...  <br>   def close_if_unusable_or_obsolete(self):<br>        &quot;&quot;&quot;<br>        Close the current connection if unrecoverable errors have occurred<br>        or if it outlived its maximum age.<br>        &quot;&quot;&quot;<br>        if self.connection is not None:<br>            self.health_check_done = False<br>            # If the application didn&#39;t restore the original autocommit setting,<br>            # don&#39;t take chances, drop the connection.<br>            if self.get_autocommit() != self.settings_dict[&quot;AUTOCOMMIT&quot;]:<br>                self.close()<br>                return<br><br>            # If an exception other than DataError or IntegrityError occurred<br>            # since the last commit / rollback, check if the connection works.<br>            if self.errors_occurred:<br>                if self.is_usable():<br>                    self.errors_occurred = False<br>                    self.health_check_done = True<br>                else:<br>                    self.close()<br>                    return<br><br>            if self.close_at is not None and time.monotonic() &gt;= self.close_at:<br>                self.close()<br>                return</pre><p>“As we have seen, Django terminates old connections at the start and end of an HTTP request, preventing the reuse of already closed connections.”</p><h3>Reusing DB Connections with CONN_MAX_AGE Setting!</h3><p>To summarize the above content, Django creates a connection when executing SQL if there is no existing connection. We confirmed this in the `BaseDatabaseWrapper.ensure_connection()`.</p><p>Therefore, in Django, if a DB Connection exists, it can be reused, which means that if the connection is not closed, it can be reused.</p><p>Conclusion: We can reuse DB Connections by adjusting the part where the connection is closed. Looking once again at the code for creating a connection and closing old connections, it is as follows:</p><p>If `self.close_at` is greater than the current time, we can reuse the DB Connection. The `self.close_at` is set to the current time plus `CONN_MAX_AGE`! In other words, we can reuse the DB Connection we want through the `CONN_MAX_AGE` setting.</p><pre>class BaseDatabaseWrapper:<br>    @async_unsafe<br>    def connect(self):<br>        &quot;&quot;&quot;Connect to the database. Assume that the connection is closed.&quot;&quot;&quot;<br>        # Check for invalid configurations.<br>        self.check_settings()<br>        # In case the previous connection was closed while in an atomic block<br>        self.in_atomic_block = False<br>        self.savepoint_ids = []<br>        self.atomic_blocks = []<br>        self.needs_rollback = False<br>        # Reset parameters defining when to close/health-check the connection.<br>        self.health_check_enabled = self.settings_dict[&quot;CONN_HEALTH_CHECKS&quot;]<br>    # 이 부분을 잘 봐주세요!<br>        max_age = self.settings_dict[&quot;CONN_MAX_AGE&quot;]<br>        self.close_at = None if max_age is None else time.monotonic() + max_age<br><br>   def close_if_unusable_or_obsolete(self):<br>        &quot;&quot;&quot;<br>        Close the current connection if unrecoverable errors have occurred<br>        or if it outlived its maximum age.<br>        &quot;&quot;&quot;<br>        if self.connection is not None:<br>            self.health_check_done = False<br>            # If the application didn&#39;t restore the original autocommit setting,<br>            # don&#39;t take chances, drop the connection.<br>            if self.get_autocommit() != self.settings_dict[&quot;AUTOCOMMIT&quot;]:<br>                self.close()<br>                return<br><br>            # If an exception other than DataError or IntegrityError occurred<br>            # since the last commit / rollback, check if the connection works.<br>            if self.errors_occurred:<br>                if self.is_usable():<br>                    self.errors_occurred = False<br>                    self.health_check_done = True<br>                else:<br>                    self.close()<br>                    return<br><br>            if self.close_at is not None and time.monotonic() &gt;= self.close_at:<br>                self.close()<br>                return</pre><p>In summary, you can set `CONN_MAX_AGE` to define the maximum lifespan of a connection for each database. When `CONN_MAX_AGE` is set, Django will close the connection at the start of each request if the connection has reached its maximum lifespan.</p><p>The reason to set `CONN_MAX_AGE` is that databases can terminate inactive connections after a certain period (for MySQL, this is the `wait_timeout`). When the database terminates a connection, Django may not be aware of this, and if a query is executed, a ‘Lost Connection’ error can occur. To prevent Django from attempting to use a connection that has been terminated by the database server, `CONN_MAX_AGE` should be set to a value lower than the database’s `wait_timeout`. (However, this issue may only affect sites with very low traffic, and it would impact at most one request per worker thread.)</p><blockquote>“The MySQL `wait_timeout` defines how long to keep MySQL client connections active. If no client sends a request to the server within the specified time (in seconds) set by the `wait_timeout` value, the server will terminate that client connection.”</blockquote><h3>Ending</h3><p>In this article, we explored how Django internally manages DB Connections. If there are any parts of the content that you think I may have misunderstood, please feel free to let me know through comments or email. It seems that there are fewer Django-related articles and use cases recently, which I personally find regrettable. I will try to post more content that could be helpful regarding Django from time to time.</p><p>Persistent connections avoid the overhead of reestablishing a connection to the database in each HTTP request. They are controlled by the CONN_MAX_AGE parameter, which defines the maximum lifetime of a connection. It can be set independently for each database.<br>! Of course, as mentioned above, even if there is no direct query in the view, if DB lookup is required for authentication or if ATOMIC_REQUESTS is set to True, a DB connection may be created for each request to create a transaction.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c1a009cec91" width="1" height="1" alt=""><hr><p><a href="https://medium.com/django-unleashed/how-does-django-manage-db-connections-4c1a009cec91">How does Django manage DB connections?</a> was originally published in <a href="https://medium.com/django-unleashed">Django Unleashed</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[초기 스타트업에서 Data Engineer는 어떤 일을 하나요?]]></title>
            <link>https://medium.com/verticah/%EC%B4%88%EA%B8%B0-%EC%8A%A4%ED%83%80%ED%8A%B8%EC%97%85%EC%97%90%EC%84%9C-data-engineer%EB%8A%94-%EC%96%B4%EB%96%A4-%EC%9D%BC%EC%9D%84-%ED%95%98%EB%82%98%EC%9A%94-8caf7bb9c458?source=rss-2dd1d38cdcab------2</link>
            <guid isPermaLink="false">https://medium.com/p/8caf7bb9c458</guid>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[venture-debt]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[data]]></category>
            <dc:creator><![CDATA[Jordan Bae]]></dc:creator>
            <pubDate>Wed, 05 Jul 2023 09:56:34 GMT</pubDate>
            <atom:updated>2023-07-10T10:43:53.197Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*KV5Zrf6nsIZ5kh_uRMuG3A.png" /></figure><p>안녕하세요. 저는 Verticah에서 Head of Data로 일하고 있는 Jordan입니다.</p><p>회사의 기술 블로그에 첫 번째 글로 초기 스타트업에서 데이터 엔지니어로 어떤 일을 하고 있는지를 소개해 보려고 합니다.</p><p>저희 팀은 현재 11명의 구성원으로 이루어진 Seed 투자를 받은 초기 스타트업으로 혁신 성장기업의 자금 조달 방식을 혁신하자는 비전 아래 <a href="https://revenue.market/ko/">Revenue Market</a>이라는 미래의 매출을 판매할 수 있는 벤처 대출 플랫폼을 만들고 있습니다.</p><h3>Why an early-stage team needs a data guy</h3><p>많은 회사들이 데이터 관련 직무를 회사가 어느 정도 성장한 후(A 시리즈 이후)에 채용합니다. 하지만, 데이터와 관련된 인프라나 구조는 변경하는 데 큰 비용이 들 뿐만 아니라, 데이터를 고려하지 않고 기업을 운영하는 습관이 관성이 되어 데이터 조직을 구성한 후에도 Data-Driven 문화로 전환하기 어렵습니다.</p><p>더 중요한 부분으로 데이터를 기반으로 한 제품 기획, 세일즈, 그리고 마케팅은 회사의 성장을 빠르게 만드는 데 큰 도움을 줄 수 있습니다. 또한, 서비스의 특성에 따라 데이터를 기반으로 하는 서비스라면 데이터 엔지니어가 제품을 직접 개발하는 데 참여할 수도 있습니다. 제가 Verticah에 합류한 이유도 이와 관련되어 있습니다.</p><p>Verticah에서는 데이터 엔지니어로서 데이터 플랫폼을 구축하는 업무 외에도, 회사를 평가하는 신용 모델 분석 서비스를 개발하고 있으며, 이를 고도화할 수 있는 백테스팅 서비스와 같은 분석 도구를 데이터 팀에서 개발하고 있습니다.</p><h3><strong>Data Platform 구축</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mNMZtRn5mUcSgRdH.png" /></figure><p>Data Platform은 다양한 대규모의 데이터를 수집, 저장, 관리, 분석하고 거버넌스 할 수 있는 종합적인 시스템을 의미합니다. 그렇기 때문에 다양한 계층과 소프트웨어로 구성되어 있습니다. 기존의 전통적인 단일 웨어하우스와 다른 점은 각각의 레이어를 분리하고 보다 다양한 데이터 및 확장가능하도록 구성했다는 점입니다.</p><p>제가 입사 한 후 가장 먼저 진행한 프로젝트로 현재 모든 구성요소들을 구성하지는 못했지만 기본적인 요소들을 아래와 같이 구성하였습니다.</p><p><strong>Data Ingestion</strong></p><ul><li>DB: AWS DMS + Airflow</li><li>External Data: Airflow</li><li>Third-party Application: Fivetran</li></ul><p><strong>Storage/Processing</strong></p><ul><li>S3: RDB의 CDC 데이터</li><li>BigQuery: 모든 Raw Data 및 Mart Data</li></ul><p><strong>Data Pipeline</strong></p><ul><li>Orchestration: Airflow (kubernetes)</li><li>Computing: Pandas, BigQuery</li></ul><p><strong>Transformation/Modeling</strong></p><ul><li>Enrich, Mart : Airflow</li></ul><p><strong>Data Utilization</strong></p><ul><li>Reverse ETL: Airflow</li><li>BI: metabase</li></ul><p><strong>Data Observability</strong></p><ul><li>자체 Data-Checker (source와 target의 row수를 비교)</li><li><a href="https://www.metaplane.dev/">Metaplane</a></li></ul><p><strong>Data Catalog</strong></p><ul><li>현재는 따로 구축되어 있지는 않고, Metabase의 기능을 이용해 table meta정보만 관리.</li></ul><h3><strong>Analytics Product</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UU-9IkR17lyj0j9Ecvxnqg.png" /><figcaption>분석 DAG</figcaption></figure><p>데이터 플랫폼 만큼이나 가장 신경 쓰는 부분은 Analytics Product입니다.</p><p>이 서비스는 서버와 연결되어 있고, 분석 요청을 받아서 회사의 신용평가 및 다양한 분석을 진행하는 서비스입니다.</p><p>초기부터 분석 파이프라인을 어떻게 관리할지에 대한 고민이 많았으며, 가장 고민이 많았던 서비스인 만큼 짧은 시간 동안 많은 변화가 있었습니다. 레베뉴마켓에는 다양한 분석 서비스가 존재하는데 다양한 데이터로부터 지표를 만들고 스코어링 및 Criteria와 비교가 필요합니다. 동기식으로 동작하지는 않더라도 복잡한 분석 Workflow를 관리하면서 어느 정도 빠른 분석 결과를 확인해야 했으며, 아래와 같은 변천사를 거쳐 발전했습니다. (아직도 발전할 부분이 많습니다…)</p><ul><li>Version 1: SQS + Lambda → 복잡한 분석 과정을 관리하기 어렵고 코드 관리가 어려움.</li><li>Version 2: SQS + Airflow → Airflow를 쓸데 없이 SQS message 폴링해야 함.</li><li>Version 3: SQS + Lambda (Airflow 분석 DAG trigger) + Airflow (Kubernetes Executor) → Kubernetes pod의 initializing 시간이 오래 걸려 불편함.</li><li>Version 4: SQS + Lambda (Airflow 분석 DAG trigger) + Airflow (CeleryKubernetes Executor)</li></ul><p>이 밖에도 다양한 분석 모듈 및 클래스들을 다양한 금융 상품에 적용 가능하고 확장 가능하도록 만들고, 가독성이 좋고 정확한 코드 및 높은 테스트 커버리지를 유지하기 위해 많은 노력을 하고 있습니다.</p><h3><strong>Dashboard (BI)</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/1*Duq9vHUgdS1O4r-z7Qa-Iw.png" /><figcaption>지표를 보여 드릴 수는 없지만 빠르게 성장 중 입니다!</figcaption></figure><p>Metabase로 다양한 대시보드 및 지표들을 시각화하고 분석하고 있습니다.</p><p>대표적인 지표인 Revenue, Profit margin, Operating Income외에도 금융권 지표인 Loss Rate, DL, NPL 등 50여개 이상의 지표를 대시보드화해서 구축 중입니다. 또, 간단한 대시보드의 documentation을 추가해서 최소한의 Governance적인 부분도 챙기고 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5SUQJY7sXJTEx6RTT5_FEQ.png" /><figcaption>외부 회사들의 데이터를 수집해 고객 발굴에도 사용 중입니다.</figcaption></figure><p>metabase로 회사 내의 지표를 모니터링 할 뿐 아니라 Sales, Risk Domain에서 고객을 발굴하고 Monitoring하는데도 사용중입니다.</p><h3><strong>Hiring</strong></h3><p>서비스가 발전함에 따라서 데이터와 관련된 서비스가 늘어나고 데이터 플랫폼의 고도화 및 수행해야 할 업무가 많아졌습니다. 또한, 고객이 증가함에 따라 신용평가 모델의 고도화를 위한 백테스팅 툴 및 데이터 분석에 필요한 다양한 Engine (ML, Matching logic 등)이 필요해졌습니다. 개발 속도를 높이기 위해서는 새로운 동료가 필요하여 직접 채용을 진행했습니다. 초기 스타트업에서 좋은 분을 Inbound로 채용하는 것은 불가능하다는 것을 알기에 주변 지인 뿐만 아니라 링크드인, 리멤버 등 다양한 채용 플랫폼에서 Outbound로 지원자를 탐색했습니다.</p><p>2달의 고생 끝에 결국 좋은 분들을 모시게 되었고, 채용 과정 동안 배운 것들이 정말 많았습니다. (그 동안 면접관 으로만 참여하면서 좋은 분들이 지원하지 않는다고 툴툴 되었던 저의 과거가… 늦었지만 HR 분들께 감사합니다!)</p><h3>ETC</h3><ul><li>Machine learning 스터디</li><li>BI tool 교육</li><li>Ad-hoc analysis 및 data extraction</li><li>…</li></ul><h3>앞으로 갈 길</h3><p>아주 바쁜 6개월이었지만 좋은 팀 동료들 덕분에 많이 성장하고 즐거운 시간이었습니다!</p><p>Verticah 데이터 팀은 다양한 금융 상품의 신용 평가 모델을 자동화하고 고도화하기 위해 데이터 플랫폼을 구축하는 것뿐만 아니라 분석을 위한 백테스팅 툴, 분석 서비스 등 다양한 제품을 개발해야 합니다. 또한, Machine Learning을 도입하여 더 빠르고 정확한 분석을 위한 개발을 진행 중입니다.</p><p>Verticah는 현재 <a href="https://verticah.career.greetinghr.com/">다양한 직군</a>을 채용 중입니다! 꼭 채용 중인 포지션이 아니더라도 관심이 있으시다면 커피챗 신청주세요!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8caf7bb9c458" width="1" height="1" alt=""><hr><p><a href="https://medium.com/verticah/%EC%B4%88%EA%B8%B0-%EC%8A%A4%ED%83%80%ED%8A%B8%EC%97%85%EC%97%90%EC%84%9C-data-engineer%EB%8A%94-%EC%96%B4%EB%96%A4-%EC%9D%BC%EC%9D%84-%ED%95%98%EB%82%98%EC%9A%94-8caf7bb9c458">초기 스타트업에서 Data Engineer는 어떤 일을 하나요?</a> was originally published in <a href="https://medium.com/verticah">Verticah</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Django DB Transaction 3편 — DB Transaction Test 코드 작성하기.]]></title>
            <link>https://medium.com/@doosikbae/django-db-transaction-3%ED%8E%B8-db-transaction-test-%EC%BD%94%EB%93%9C-%EC%9E%91%EC%84%B1%ED%95%98%EA%B8%B0-e7363a084834?source=rss-2dd1d38cdcab------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7363a084834</guid>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[dbms]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Jordan Bae]]></dc:creator>
            <pubDate>Fri, 04 Feb 2022 08:25:49 GMT</pubDate>
            <atom:updated>2023-07-05T10:04:07.169Z</atom:updated>
            <content:encoded><![CDATA[<h3>Django DB Transaction 3편 — DB Transaction Test 코드 작성하기.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AWXtLk9LhmAo3qcF7Rd2Yg.png" /><figcaption>DB Transaction makes safe system.</figcaption></figure><h3>Introduction</h3><p>안녕하세요. 1편과 2편에 이어서 마지막 편으로 Django에서 DB Transaction과 관련된 코드들의 테스트 코드를 작성하는 방법에 대해서 포스팅 해보려고 합니다.</p><p>아직 1편과 2편을 읽지 않으신 분이 계신다면 먼저 읽고 오시는 것을 추천드립니다. Django에서 DB Transaction을 어떻게 사용하는지 그리고 실제 DB에서 어떤 동작이 일어나는지를 이해하시고 이번 글을 읽으시면 이해하기 쉽고 더 도움이 될 거라고 생각합니다.</p><p><strong>지난 글</strong></p><p><a href="https://medium.com/@doosikbae/django-db-transaction-1%ED%8E%B8-request%EC%99%80-db-transaction-%EB%AC%B6%EA%B8%B0-feat-atomic-requests-5bf976d2a33c">Django DB Transaction(트랜잭션) 1편 — Request와 DB Transaction 묶기(Feat. ATOMIC_REQUESTS)</a></p><p><a href="https://medium.com/@doosikbae/django-db-transaction-2%ED%8E%B8-%EB%AA%85%EC%8B%9C%EC%A0%81%EC%9C%BC%EB%A1%9C-transaction%ED%99%9C%EC%9A%A9%ED%95%98%EA%B8%B0-feat-savepoint-53075301b3f5?p=53075301b3f5">Django DB Transaction 2편 — 명시적으로 transaction 활용하기. (feat. savepoint)</a></p><p>그럼 본격적으로 1,2편에서 살펴본 DB Transaction과 관련된 기능들을 어떻게 테스트할지에 대한 이야기를 시작해보도록 하겠습니다.</p><p><strong>*주의 이 글은 Django4.0 및 MySQL5.7 기준의 글입니다.*</strong></p><h3>Django’s TestCase</h3><p>Django에서 지원하는 TestCase는 아래와 같은 Hierarchy를 가지고 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/0*jEK7ICatbNXvRmPg.png" /><figcaption><a href="https://docs.djangoproject.com/en/4.0/topics/testing/tools/#django.test.TestCase">https://docs.djangoproject.com/en/4.0/topics/testing/tools/#django.test.TestCase</a></figcaption></figure><p>우리가 집중적으로 볼 부분은 Transaction과 관련된 부분입니다. 그렇기 때문에 Database에 관련된 기능을 구현한 TransactionTestCase와 TransactionTestCase를 상속받은 TestCase가 transaction과 관련해서 어떻게 동작하는지 살펴볼 것 입니다. TransactionTestCase와 TestCase는 테스트 간의 데이터를 reset하는 방법을 제외하고는 동일합니다.</p><p><strong>TransactionTestCase</strong></p><ul><li><strong>테스트 수행 후에 모든 테이블을 truncate 합니다.</strong></li><li>테스트에서 Transaction의 commit이나 rollback을 관찰 할 수 있다.</li><li>단점은 각 테스트 간의 모든 테이블 지워야 하므로 테스트 시간이 오래 걸린다.</li></ul><p><strong>TestCase</strong></p><p>-<strong>테스트 수행 후에 모든 테이블을 truncate하지 않고, 각 test를 transaction으로 처리하여 test 수행 후에 transaction을 rollback합니다. 우리가 ATOMIC_REQUESTS를 사용하여 request handler의 시작 전에 transaction을 시작하고, response를 반환 후에 commit or rollback을 하던 것 과 같은 전략입니다</strong>. 즉, TestCase안에서는 tranaction.atomic block이나 atomic_request 설정이 savepoint로 동작하게 됩니다. 이 방법의 장점은 성능입니다. (truncate보다 transaction rollback이 빠릅니다.)</p><p>-&gt; 하지만, savepoint가 있기 때문에 같은 DB connection의 transaction 안에서는 부분별로 transaction이 잘 동작하는지 확인할 수도 있습니다. 아래 예제 코드를 통해서 살펴볼 예정입니다. 하지만, 어쨌든 실제 Production과는 다르게 동작하므로 이 부분은 주의해야 될 것 같습니다.</p><h3>예제 코드로 실제 동작 살펴보기</h3><p>1,2 편에서 사용했던 코드를 계속 사용하겠습니다.</p><p>먼저 models.py, serializers.py, views.py 코드입니다. 아래 코드는 안 보셔도 되고 다만 아래와 같은 코드를 테스트하는 것이 때문에 참고만 하시면 됩니다.</p><pre># models.py<br>from django.db import models<br>from django.contrib.auth.models import User<br><br><br>class Company(models.Model):<br>    ticker = models.CharField(max_length=16)<br>    name = models.CharField(max_length=64)<br><br><br>class Account(models.Model):<br>    owner = models.ForeignKey(User, on_delete=models.PROTECT, db_constraint=False)<br><br>    created_dt = models.DateTimeField(auto_now_add=True)<br>    updated_dt = models.DateTimeField(auto_now=True)<br><br>    def __repr__(self):<br>        return f&quot;{self.owner} Account&quot;<br><br><br>class Shares(models.Model):<br>    account = models.ForeignKey(Account, on_delete=models.PROTECT, db_constraint=False)<br>    company = models.ForeignKey(Company, on_delete=models.CASCADE, db_constraint=False)<br>    amount = models.PositiveBigIntegerField()<br><br>    created_dt = models.DateTimeField(auto_now_add=True)<br>    updated_dt = models.DateTimeField(auto_now=True)<br><br>    class Meta:<br>        unique_together = [[&#39;account&#39;, &#39;company&#39;]]<br><br><br>class SharesTransfer(models.Model):<br>    account_from = models.ForeignKey(<br>        Account, on_delete=models.PROTECT, db_constraint=False, related_name=&#39;account_from&#39;<br>    )<br>    account_to = models.ForeignKey(<br>        Account, on_delete=models.PROTECT, db_constraint=False, related_name=&#39;account_to&#39;<br>    )<br>    company = models.ForeignKey(Company, on_delete=models.PROTECT, db_constraint=False)<br>    amount = models.PositiveBigIntegerField()<br><br>    created_dt = models.DateTimeField(auto_now_add=True)<br>    updated_dt = models.DateTimeField(auto_now=True)<br><br><br># serializers.py<br>from django.db.models import F<br>from rest_framework import serializers<br><br>from .models import Shares, SharesTransfer<br><br><br>class SharesTransferSerializer(serializers.Serializer):<br>    # validation 은 생략<br>    account_from = serializers.IntegerField()<br>    account_to = serializers.IntegerField()<br>    company_id = serializers.IntegerField()<br>    amount = serializers.IntegerField()<br><br>    def create(self, validated_data, *args, **kwargs):<br>        # 보낸 사람의  주식을 줄인다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_from&#39;),<br>                              company_id=validated_data.get(&#39;company_id&#39;)) \<br>            .update(amount=F(&#39;amount&#39;) - validated_data.get(&#39;amount&#39;))<br>        # 받은 사람의 주식을 늘린다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_to&#39;), company_id=validated_data.get(&#39;company_id&#39;)) \<br>            .update(amount=F(&#39;amount&#39;) + validated_data.get(&#39;amount&#39;))<br>        # 전송내역을 저장한다.<br>        transfer = SharesTransfer.objects.create(<br>            account_from_id=validated_data.get(&#39;account_from&#39;),<br>            account_to_id=validated_data.get(&#39;account_to&#39;),<br>            company_id=validated_data.get(&#39;company_id&#39;),<br>            amount=validated_data.get(&#39;amount&#39;)<br>        )<br>        return transfer<br><br><br># views.py<br><br>from rest_framework import viewsets, permissions<br>from rest_framework.response import Response<br>from rest_framework import status<br><br>from .serializers import SharesTransferSerializer<br><br><br>def send_email():<br>    print(&#39;send_email_for_testing&#39;)<br><br><br>class ShareTransferViewSet(viewsets.GenericViewSet):<br>    permission_classes = [permissions.IsAuthenticated]<br>    serializer_class = SharesTransferSerializer<br>    lookup_field = &#39;id&#39;<br><br>    def create(self, request, *args, **kwargs):<br>        serializer = self.get_serializer(data=request.data)<br>        serializer.is_valid(raise_exception=True)<br><br>        serializer.save()<br>        # for transaction test<br>        send_email()<br>        return Response(&#39;success&#39;, status=status.HTTP_201_CREATED)</pre><p>위와 같은 API의 integration test를 작성해보겠습니다.</p><p>테스트 코드는 아래와 같습니다. 저희가 살펴 볼 테스트는 <strong>test_create_fail_with_exception_for_checking_transaction</strong> 입니다. 해당 테스트에서는 send_email에서 exception이 발생시켜서 request에 대한 response가 실패하도록 의도적으로 만들고 있습니다.</p><pre>from unittest.mock import patch<br><br>from django.urls import reverse<br>from django.test import TestCase, TransactionTestCase<br>from rest_framework import status<br>from rest_framework.test import APITestCase, APIClient<br>from django.contrib.auth.models import User<br>from trading import views<br><br>from trading.models import Account, Company, Shares, SharesTransfer<br><br><br>class ShareTransferViewSetTests(TestCase):<br>    @classmethod<br>    def setUpTestData(cls):<br>        super(ShareTransferViewSetTests, cls).setUpTestData()<br>        cls.username1, cls.password1 = &#39;tester&#39;, &#39;tester1234&#39;<br>        cls.username2, cls.password2 = &#39;tester2&#39;, &#39;tester12342&#39;<br><br>        cls.user1 = User.objects.create_user(username=cls.username1, password=cls.password1)<br>        cls.user2 = User.objects.create_user(username=cls.username2, password=cls.password2)<br><br>        # fixture dataset<br>        cls.company = Company.objects.create(ticker=&#39;AMZN&#39;, name=&#39;amazon&#39;)<br>        cls.account1 = Account.objects.create(owner=cls.user1)<br>        cls.account2 = Account.objects.create(owner=cls.user2)<br>        cls.shares1 = Shares.objects.create(account=cls.account1, company=cls.company, amount=100)<br>        cls.shares2 = Shares.objects.create(account=cls.account2, company=cls.company, amount=100)<br><br>    def setUp(self) -&gt; None:<br>        # for session authenticating<br>        self.client = APIClient()<br>        self.client.login(username=self.username1, password=self.password1)<br><br>    def test_create_success(self) -&gt; None:<br>        url = reverse(&#39;transfer-list&#39;)<br>        amount = 10<br>        data = {<br>            &quot;account_from&quot;: self.account1.id,<br>            &quot;account_to&quot;: self.account2.id,<br>            &quot;company_id&quot;: self.company.id,<br>            &quot;amount&quot;: amount<br>        }<br>        response = self.client.post(url, data=data, format=&#39;json&#39;)<br>        self.assertEqual(response.status_code, status.HTTP_201_CREATED)<br>        self.assertEqual(response.json(), &quot;success&quot;)<br><br>    @patch.object(views, &quot;send_email&quot;)<br>    def test_create_fail_with_exception_for_checking_transaction(self, mock_send_email):<br>        mock_send_email.side_effect = Exception(&quot;test error&quot;)<br>        url = reverse(&#39;transfer-list&#39;)<br>        amount = 10<br>        data = {<br>            &quot;account_from&quot;: self.account1.id,<br>            &quot;account_to&quot;: self.account2.id,<br>            &quot;company_id&quot;: self.company.id,<br>            &quot;amount&quot;: amount<br>        }<br>        before_shares1_amount = self.shares1.amount<br>        before_shares2_amount = self.shares2.amount<br><br>        with self.assertRaises(Exception):<br>            self.client.post(url, data=data, format=&#39;json&#39;)<br><br>        # checking transaction working well (http response와 묶여서 DB에 반영이 안됨)<br>        self.shares1.refresh_from_db()<br>        self.shares2.refresh_from_db()<br>        self.assertEqual(self.shares1.amount, before_shares1_amount)<br>        self.assertEqual(self.shares2.amount, before_shares2_amount)</pre><p>이를 통해서 아래와 같이 4가지 상황에 대해서 살펴볼 예정입니다.</p><p>- <a href="https://docs.djangoproject.com/en/4.0/ref/settings/#std:setting-DATABASE-ATOMIC_REQUESTS"><strong>ATOMIC_REQUESTS</strong></a>가 True일 때와 False일 때.</p><ul><li><strong>TestCase</strong>를 사용할 때 <strong>TransactionTestCase</strong>를 사용할 때.</li></ul><ol><li><strong>TestCase상속, ATOMIC_REQUESTS=True 일 때</strong></li></ol><p>TestCase를 사용했기 때문에 test시작 부분에서 autocommit=0으로 transaction을 시작하고, 마지막에 rollback하는 것을 볼 수 있다.</p><p><strong>테스트 결과: 성공</strong></p><p>Request 자체가 Savepoint로 묶여서 exception이 발생했으므로 rollback되어서 해당 트랜잭션내에서 바뀌지 않은것으로 처리됨. 하지만 실제 코드에서는 Transaction으로 묶이기 때문에 테스트는 성공하지만 실제와 다르게 동작한다는 단점이 있음.</p><p><strong>DB에 수행되는 SQL</strong></p><pre># test시작되는 부분<br>2022-02-02T07:28:17.550444Z      151 Query    SET autocommit=0<br>....<br># response가 시작되는 부분<br>2022-02-02T07:28:17.551444Z      151 Query    SAVEPOINT `s140327450969920_x6`<br>2022-02-02T07:28:17.553063Z      151 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`username` = &#39;tester&#39; LIMIT 21<br>2022-02-02T07:28:17.728785Z      151 Query    SELECT (1) AS `a` FROM `django_session` WHERE `django_session`.`session_key` = &#39;wu2y79xbx12kvvfg4u4f2dnbfbzlivf4&#39; LIMIT 1<br>2022-02-02T07:28:17.730312Z      151 Query    SAVEPOINT `s140327450969920_x7`<br>2022-02-02T07:28:17.731335Z      151 Query    INSERT INTO `django_session` (`session_key`, `session_data`, `expire_date`) VALUES (&#39;wu2y79xbx12kvvfg4u4f2dnbfbzlivf4&#39;, &#39;e30:1nFA3t:0qG48fhGDWhOHPkGIEk5g04yU4mhmtwqLp-YIPEIHkk&#39;, &#39;2022-02-16 07:28:17.729747&#39;)<br>2022-02-02T07:28:17.732274Z      151 Query    RELEASE SAVEPOINT `s140327450969920_x7`<br>2022-02-02T07:28:17.734348Z      151 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-02-02 07:28:17.733107&#39; AND `django_session`.`session_key` = &#39;wu2y79xbx12kvvfg4u4f2dnbfbzlivf4&#39;) LIMIT 21<br>2022-02-02T07:28:17.736300Z      151 Query    SELECT (1) AS `a` FROM `django_session` WHERE `django_session`.`session_key` = &#39;3m4sv2d4ib7gqzjq4wxvtltb4a8g9rfg&#39; LIMIT 1<br>2022-02-02T07:28:17.737414Z      151 Query    SAVEPOINT `s140327450969920_x8`<br>2022-02-02T07:28:17.738564Z      151 Query    INSERT INTO `django_session` (`session_key`, `session_data`, `expire_date`) VALUES (&#39;3m4sv2d4ib7gqzjq4wxvtltb4a8g9rfg&#39;, &#39;e30:1nFA3t:0qG48fhGDWhOHPkGIEk5g04yU4mhmtwqLp-YIPEIHkk&#39;, &#39;2022-02-16 07:28:17.736853&#39;)<br>2022-02-02T07:28:17.739538Z      151 Query    RELEASE SAVEPOINT `s140327450969920_x8`<br>2022-02-02T07:28:17.740950Z      151 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE `django_session`.`session_key` = &#39;wu2y79xbx12kvvfg4u4f2dnbfbzlivf4&#39; LIMIT 21<br>2022-02-02T07:28:17.742434Z      151 Query    DELETE FROM `django_session` WHERE `django_session`.`session_key` IN (&#39;wu2y79xbx12kvvfg4u4f2dnbfbzlivf4&#39;)<br>2022-02-02T07:28:17.744324Z      151 Query    UPDATE `auth_user` SET `last_login` = &#39;2022-02-02 07:28:17.743379&#39; WHERE `auth_user`.`id` = 1<br>2022-02-02T07:28:17.745561Z      151 Query    SAVEPOINT `s140327450969920_x9`<br>2022-02-02T07:28:17.746911Z      151 Query    UPDATE `django_session` SET `session_data` = &#39;.eJxVjEEOwiAQRe_C2hARB4pL956BDDODVA0kpV0Z726bdKHb_977bxVxmUtcukxxZHVRRh1-t4T0lLoBfmC9N02tztOY9KbonXZ9ayyv6-7-HRTsZa3zOTAaT-SZA3kBy56TdSk7czJCAg7FBkAYgHII4ehoAOtgNckZoz5fB6c4IA:1nFA3t:xI_WUQANWnZCwZ3_TsPHVojj53iQkEkDCNplsUHeijQ&#39;, `expire_date` = &#39;2022-02-16 07:28:17.745177&#39; WHERE `django_session`.`session_key` = &#39;3m4sv2d4ib7gqzjq4wxvtltb4a8g9rfg&#39;<br>2022-02-02T07:28:17.747660Z      151 Query    RELEASE SAVEPOINT `s140327450969920_x9`<br>2022-02-02T07:28:17.750790Z      151 Query    SAVEPOINT `s140327450969920_x10`<br>2022-02-02T07:28:17.752619Z      151 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-02-02 07:28:17.751501&#39; AND `django_session`.`session_key` = &#39;3m4sv2d4ib7gqzjq4wxvtltb4a8g9rfg&#39;) LIMIT 21<br>2022-02-02T07:28:17.754481Z      151 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 1 LIMIT 21<br>2022-02-02T07:28:17.757086Z      151 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 10) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1)<br>2022-02-02T07:28:17.759217Z      151 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 10) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1)<br>2022-02-02T07:28:17.760487Z      151 Query    INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (1, 2, 1, 10, &#39;2022-02-02 07:28:17.760093&#39;, &#39;2022-02-02 07:28:17.760164&#39;)<br>2022-02-02T07:28:17.761745Z      151 Query    RELEASE SAVEPOINT `s140327450969920_x10`<br>2022-02-02T07:28:17.763310Z      151 Query    ROLLBACK TO SAVEPOINT `s140327450969920_x6`<br># response가 끝나는 부분<br>2022-02-02T07:28:17.763980Z      151 Query    RELEASE SAVEPOINT `s140327450969920_x6`<br>....<br># 테스트 끝나는 부분<br>2022-02-02T07:28:17.863980Z      151 ROLLBACK<br>2022-02-02T07:28:17.874980Z      151 SET autocommit=1</pre><p><strong>2) TestCase상속, ATOMIC_REQUESTS=False 일 때</strong></p><p><strong>테스트 결과: 실패</strong></p><p>해당 트랜잭션내에서 select해서 phantom read하여 바뀐 것 처럼 보임. 하지만 다른 transaction에서 조회했을 때는 그래로이다.(isolation level별로 다르지만, 보통 우리는 READ UNCOMMITED는 사용하지 않기 때문에..)</p><p>TestCase class를 사용하면 이런 문제가 있다…(Transaction동작에 대해서 정확히 이해하기 힘듬.)</p><p>Error message</p><p>FAILED tests/trading/api/test_share_transfer_view_set.py::ShareTransferViewSetTests::test_create_fail_with_exception_for_checking_transaction — AssertionError: 90 != 100</p><p><strong>DB에 실행되는 SQL</strong></p><pre># Test 시작부분<br>2022-02-02T07:36:52.656242Z      160 Query    SET autocommit=0<br>2022-02-02T07:36:52.896786Z      160 Query    INSERT INTO `auth_user` (`password`, `last_login`, `is_superuser`, `username`, `first_name`, `last_name`, `email`, `is_staff`, `is_active`, `date_joined`) VALUES (&#39;pbkdf2_sha256$260000$bxFgW9t5ASFHwLNKVpnSXZ$ZoX/UECeECQ/MXQ9zGuZhclxegf/17vH+MOK9as3UlY=&#39;, NULL, 0, &#39;tester&#39;, &#39;&#39;, &#39;&#39;, &#39;&#39;, 0, 1, &#39;2022-02-02 07:36:52.657499&#39;)<br>2022-02-02T07:36:53.123421Z      160 Query    INSERT INTO `auth_user` (`password`, `last_login`, `is_superuser`, `username`, `first_name`, `last_name`, `email`, `is_staff`, `is_active`, `date_joined`) VALUES (&#39;pbkdf2_sha256$260000$crb0qlMQEvlzA8i0y9wLRJ$DHm4UktINgeYHp9txkvTRI5wZ8nrFoXWLnvRypKZ6oc=&#39;, NULL, 0, &#39;tester2&#39;, &#39;&#39;, &#39;&#39;, &#39;&#39;, 0, 1, &#39;2022-02-02 07:36:52.898442&#39;)<br>2022-02-02T07:36:53.125970Z      160 Query    INSERT INTO `trading_company` (`ticker`, `name`) VALUES (&#39;AMZN&#39;, &#39;amazon&#39;)<br>2022-02-02T07:36:53.127900Z      160 Query    INSERT INTO `trading_account` (`owner_id`, `created_dt`, `updated_dt`) VALUES (1, &#39;2022-02-02 07:36:53.127459&#39;, &#39;2022-02-02 07:36:53.127497&#39;)<br>2022-02-02T07:36:53.131761Z      160 Query    INSERT INTO `trading_account` (`owner_id`, `created_dt`, `updated_dt`) VALUES (2, &#39;2022-02-02 07:36:53.131104&#39;, &#39;2022-02-02 07:36:53.131260&#39;)<br>2022-02-02T07:36:53.135968Z      160 Query    INSERT INTO `trading_shares` (`account_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (1, 1, 100, &#39;2022-02-02 07:36:53.134858&#39;, &#39;2022-02-02 07:36:53.135043&#39;)<br>2022-02-02T07:36:53.138040Z      160 Query    INSERT INTO `trading_shares` (`account_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (2, 1, 100, &#39;2022-02-02 07:36:53.137689&#39;, &#39;2022-02-02 07:36:53.137739&#39;)<br>2022-02-02T07:36:53.142056Z      160 Query    SAVEPOINT `s139711800366912_x1`<br>2022-02-02T07:36:53.148378Z      160 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`username` = &#39;tester&#39; LIMIT 21<br>2022-02-02T07:36:53.342777Z      160 Query    SELECT (1) AS `a` FROM `django_session` WHERE `django_session`.`session_key` = &#39;dqnu7uq5edpix55dckwu5qp07osbuxck&#39; LIMIT 1<br>2022-02-02T07:36:53.346109Z      160 Query    SAVEPOINT `s139711800366912_x2`<br>2022-02-02T07:36:53.347949Z      160 Query    INSERT INTO `django_session` (`session_key`, `session_data`, `expire_date`) VALUES (&#39;dqnu7uq5edpix55dckwu5qp07osbuxck&#39;, &#39;e30:1nFACD:_6rx3SAb8VF8GaVx0-0QGMk9tIU97SQ6Nr2F53h4Brw&#39;, &#39;2022-02-16 07:36:53.345378&#39;)<br>2022-02-02T07:36:53.349293Z      160 Query    RELEASE SAVEPOINT `s139711800366912_x2`<br>2022-02-02T07:36:53.354769Z      160 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-02-02 07:36:53.350622&#39; AND `django_session`.`session_key` = &#39;dqnu7uq5edpix55dckwu5qp07osbuxck&#39;) LIMIT 21<br>2022-02-02T07:36:53.357048Z      160 Query    SELECT (1) AS `a` FROM `django_session` WHERE `django_session`.`session_key` = &#39;914zlc01k9aa40ci59gjs3pklewdxd0l&#39; LIMIT 1<br>2022-02-02T07:36:53.358841Z      160 Query    SAVEPOINT `s139711800366912_x3`<br>2022-02-02T07:36:53.360167Z      160 Query    INSERT INTO `django_session` (`session_key`, `session_data`, `expire_date`) VALUES (&#39;914zlc01k9aa40ci59gjs3pklewdxd0l&#39;, &#39;e30:1nFACD:_6rx3SAb8VF8GaVx0-0QGMk9tIU97SQ6Nr2F53h4Brw&#39;, &#39;2022-02-16 07:36:53.358372&#39;)<br>2022-02-02T07:36:53.361284Z      160 Query    RELEASE SAVEPOINT `s139711800366912_x3`<br>2022-02-02T07:36:53.362829Z      160 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE `django_session`.`session_key` = &#39;dqnu7uq5edpix55dckwu5qp07osbuxck&#39; LIMIT 21<br>2022-02-02T07:36:53.365066Z      160 Query    DELETE FROM `django_session` WHERE `django_session`.`session_key` IN (&#39;dqnu7uq5edpix55dckwu5qp07osbuxck&#39;)<br>2022-02-02T07:36:53.367996Z      160 Query    UPDATE `auth_user` SET `last_login` = &#39;2022-02-02 07:36:53.366915&#39; WHERE `auth_user`.`id` = 1<br>2022-02-02T07:36:53.369627Z      160 Query    SAVEPOINT `s139711800366912_x4`<br>2022-02-02T07:36:53.371325Z      160 Query    UPDATE `django_session` SET `session_data` = &#39;.eJxVjDsOwjAQBe_iGlnrT2wvJT1nsNY_HEC2FCcV4u4QKQW0b2bei3na1uq3kRc_J3Zmgp1-t0DxkdsO0p3arfPY27rMge8KP-jg157y83K4fweVRv3W2hYKU0EALVRBJRyCic7lIG0wIVkqjjJhsiCMUpNGqdAUnQs40BLY-wPUyzcf:1nFACD:kJm3I5Tqi0pU0Bwx_P8Yld6sl77R54-h1th4sBmaEWQ&#39;, `expire_date` = &#39;2022-02-16 07:36:53.369080&#39; WHERE `django_session`.`session_key` = &#39;914zlc01k9aa40ci59gjs3pklewdxd0l&#39;<br>2022-02-02T07:36:53.372449Z      160 Query    RELEASE SAVEPOINT `s139711800366912_x4`<br>2022-02-02T07:36:53.794596Z      160 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-02-02 07:36:53.793298&#39; AND `django_session`.`session_key` = &#39;914zlc01k9aa40ci59gjs3pklewdxd0l&#39;) LIMIT 21<br>2022-02-02T07:36:53.796508Z      160 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 1 LIMIT 21<br>2022-02-02T07:36:53.800786Z      160 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 10) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1)<br>2022-02-02T07:36:53.803011Z      160 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 10) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1)<br>2022-02-02T07:36:53.804832Z      160 Query    INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (1, 2, 1, 10, &#39;2022-02-02 07:36:53.804298&#39;, &#39;2022-02-02 07:36:53.804350&#39;)<br>2022-02-02T07:36:53.923034Z      160 Query    SELECT `trading_shares`.`id`, `trading_shares`.`account_id`, `trading_shares`.`company_id`, `trading_shares`.`amount`, `trading_shares`.`created_dt`, `trading_shares`.`updated_dt` FROM `trading_shares` WHERE `trading_shares`.`id` = 1 LIMIT 21<br>2022-02-02T07:36:53.925884Z      160 Query    SELECT `trading_shares`.`id`, `trading_shares`.`account_id`, `trading_shares`.`company_id`, `trading_shares`.`amount`, `trading_shares`.`created_dt`, `trading_shares`.`updated_dt` FROM `trading_shares` WHERE `trading_shares`.`id` = 2 LIMIT 21<br>2022-02-02T07:36:53.927645Z      160 Query    ROLLBACK TO SAVEPOINT `s139711800366912_x1`<br>2022-02-02T07:36:53.929016Z      160 Query    RELEASE SAVEPOINT `s139711800366912_x1`<br>2022-02-02T07:36:54.039679Z      160 Query    ROLLBACK<br># test가 끝나면서 rollback 됨.<br>2022-02-02T07:36:54.043014Z      160 Query    SET autocommit=1<br>2022-02-02T07:36:54.043808Z      160 Quit</pre><p><strong>3) TransactionTestCase상속, ATOMIC_REQUESTS=True 일 때</strong></p><p>우선 TransactionTestCase를 사용하면 setUpTestData class method를 사용할 수 없다. 테스트 별로 truncate table이 수행되기 때문에 transaction단위로 reset을 하는 TestCase 클래스에서 사용하는 class method이기 때문이다.</p><p>그래서 아래와 같이 각 test 별로 실행하는 setUp 메서드에 초기 데이터를 생성하는 코드를 넣어야 한다.</p><pre>def setUp(self) -&gt; None:<br>    self.username1, self.password1 = &#39;tester&#39;, &#39;tester1234&#39;<br>    self.username2, self.password2 = &#39;tester2&#39;, &#39;tester12342&#39;<br><br>    self.user1 = User.objects.create_user(username=self.username1, password=self.password1)<br>    self.user2 = User.objects.create_user(username=self.username2, password=self.password2)<br><br>    # fixture dataset<br>    self.company = Company.objects.create(ticker=&#39;AMZN&#39;, name=&#39;amazon&#39;)<br>    self.account1 = Account.objects.create(owner=self.user1)<br>    self.account2 = Account.objects.create(owner=self.user2)<br>    self.shares1 = Shares.objects.create(account=self.account1, company=self.company, amount=100)<br>    self.shares2 = Shares.objects.create(account=self.account2, company=self.company, amount=100)<br><br>    # for session authenticating<br>    self.client = APIClient()<br>    self.client.login(username=self.username1, password=self.password1)</pre><p><strong>테스트 결과: 성공</strong></p><p>실제 우리의 production 환경에서 동작하는대로 response handler 시작 부분에서 transaction이 사작된다.</p><p>그리고 exception이 발생했기 때문에 마지막에 rollback까지 되서 예상대로 동작한 것을 확인할 수 있다.</p><p>또, 위에서 살펴본 것 처럼 테스트 후 모든 테이블을 지우는 것을 확인할 수 있다.</p><p><strong>DB에 실행되는 SQL</strong></p><pre># response 시작<br>2022-02-02T08:02:40.964740Z      173 Query    SET autocommit=0<br>2022-02-02T08:02:40.967756Z      173 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-02-02 08:02:40.966071&#39; AND `django_session`.`session_key` = &#39;pg91k1gjinhmlvk6682g51lkswhj3osk&#39;) LIMIT 21<br>2022-02-02T08:02:40.970325Z      173 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 1 LIMIT 21<br>2022-02-02T08:02:40.976146Z      173 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 10) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1)<br>2022-02-02T08:02:40.979589Z      173 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 10) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1)<br>2022-02-02T08:02:40.981169Z      173 Query    INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (1, 2, 1, 10, &#39;2022-02-02 08:02:40.980863&#39;, &#39;2022-02-02 08:02:40.980912&#39;)<br># response과정에서 exception이 발생해서 rollback<br>2022-02-02T08:02:40.982168Z      173 Query    ROLLBACK<br>2022-02-02T08:02:40.985510Z      173 Query    SET autocommit=1<br>2022-02-02T08:02:41.093587Z      173 Query    SELECT `trading_shares`.`id`, `trading_shares`.`account_id`, `trading_shares`.`company_id`, `trading_shares`.`amount`, `trading_shares`.`created_dt`, `trading_shares`.`updated_dt` FROM `trading_shares` WHERE `trading_shares`.`id` = 1 LIMIT 21<br>2022-02-02T08:02:41.096286Z      173 Query    SELECT `trading_shares`.`id`, `trading_shares`.`account_id`, `trading_shares`.`company_id`, `trading_shares`.`amount`, `trading_shares`.`created_dt`, `trading_shares`.`updated_dt` FROM `trading_shares` WHERE `trading_shares`.`id` = 2 LIMIT 21<br>2022-02-02T08:02:41.109058Z      173 Query    SHOW FULL TABLES<br>2022-02-02T08:02:41.111276Z      173 Query    SET autocommit=0<br>2022-02-02T08:02:41.112189Z      173 Query    SET FOREIGN_KEY_CHECKS = 0<br># test 수행 후 모든 테이블 truncate<br>2022-02-02T08:02:41.113296Z      173 Query    DELETE FROM `django_admin_log`<br>2022-02-02T08:02:41.114220Z      173 Query    DELETE FROM `auth_user_groups`<br>2022-02-02T08:02:41.115417Z      173 Query    DELETE FROM `auth_user_user_permissions`<br>2022-02-02T08:02:41.116899Z      173 Query    DELETE FROM `django_session`<br>2022-02-02T08:02:41.117968Z      173 Query    DELETE FROM `event_analyticsevent`<br>2022-02-02T08:02:41.118550Z      173 Query    DELETE FROM `trading_sharestransfer`<br>2022-02-02T08:02:41.119253Z      173 Query    DELETE FROM `auth_group_permissions`</pre><h4>4) TransactionTestCase상속, ATOMIC_REQUESTS=False 일 때</h4><p><strong>테스트 결과: 실패</strong></p><p>FAILED tests/trading/api/test_share_transfer_view_set.py::ShareTransferViewSetTests::test_create_fail_with_exception_for_checking_transaction — AssertionError: 90 != 100</p><p>동작하는 테스트 코드는 위와 같다. 크게 예상과는 다를 것이 없다. 트랜잭션으로 묶이는 부분이 없기 때문에 response에서 exception이 발생했지만 DB에는 잘 반영되는 것을 볼 수 있다. TestCase도 ATOMIC_REQUEST=False일 때 실패했지만 정확한 동작은 다르다. 이번에는 다른 transaction에서 조회하더라도 같은 결과를 볼 수 있다.</p><p><strong>DB에 실행되는 SQL</strong></p><pre># autocommit=1 이기 때문에 sql마다 바로 commit됨.<br>2022-02-02T08:05:15.729538Z      178 Query    SET autocommit=1<br>2022-02-02T08:05:15.734923Z      178 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-02-02 08:05:15.733374&#39; AND `django_session`.`session_key` = &#39;04mlonkuwc55gaqugd0sere8drm9ytbu&#39;) LIMIT 21<br>2022-02-02T08:05:15.737274Z      178 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 3 LIMIT 21<br>2022-02-02T08:05:15.740741Z      178 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 10) WHERE (`trading_shares`.`account_id` = 3 AND `trading_shares`.`company_id` = 2)<br>2022-02-02T08:05:15.746461Z      178 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 10) WHERE (`trading_shares`.`account_id` = 4 AND `trading_shares`.`company_id` = 2)<br>2022-02-02T08:05:15.750595Z      178 Query    INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (3, 4, 2, 10, &#39;2022-02-02 08:05:15.750129&#39;, &#39;2022-02-02 08:05:15.750191&#39;)<br>2022-02-02T08:05:15.758022Z      178 Query    SHOW FULL TABLES<br>2022-02-02T08:05:15.759777Z      178 Query    SET autocommit=0<br>2022-02-02T08:05:15.760336Z      178 Query    SET FOREIGN_KEY_CHECKS = 0<br># 각 테스트 수행 후 테이블 truncate<br>2022-02-02T08:05:15.761808Z      178 Query    DELETE FROM `django_session`<br>2022-02-02T08:05:15.762884Z      178 Query    DELETE FROM `blog_post`<br>2022-02-02T08:05:15.763526Z      178 Query    DELETE FROM `django_admin_log`</pre><h3>마무리</h3><p>이번 편에서는 Django에서 제공하는 TestClass들을 활용해서 Transaction과 관련된 테스트를 진행해 봤습니다. 정확한 Transaction의 동작을 테스트 하기 위해서 TransactionTestCase를 사용하는 것이 좋습니다. 하지만, 정확한 이해를 하고 있다는 것을 바탕으로는 TestCase class로도 어느 정도까지는 Savepoint를 활용하여 테스트가 가능합니다.</p><h3>Django DB Transaction 포스팅 마무리</h3><p>이 번 편을 마지막으로 Django DB Transaction과 관련된 포스팅을 마치려고 합니다. 원래는 4편으로 나눠서 쓰려고 했는데 SAVEPOINT가 2편에 같이 포스팅하면서 3편으로 줄었습니다. Django에서 지원하는 DB Transaction과 관련된 부분을 잘 전달하려고 노력했는데 생각보다 글을 잘 작성하는 것도 어렵고, 정리하다보면 제가 모르는 부분도 많이 있어서 부족한 부분이 많은 것 같습니다. Django 공식 문서가 정말 정리가 잘 되어 있기 때문에 중간에 이해가 안 가시는 부분이 있으면 같이 참고하셔도 좋을 듯 합니다. 제가 조금 신경 쓴 부분은 실제 Database에서 어떻게 동작하는지를 최대한 같이 설명하려고 노력했습니다. 읽어 주셔서 감사하고, 혹시 글과 관련되서 궁금한 점이나 잘 못된 부분을 알려주시면 반영하도록 하겠습니다! 또, Django와 관련된 공유나 활동(스터디, 발표등)들이 많이 생기면 좋겠다는 생각을 하고 있는데 관심있는 분들은 알려주세요!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7363a084834" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Django DB Transaction 2편 — 명시적으로 transaction활용하기. (feat. savepoint)]]></title>
            <link>https://medium.com/@doosikbae/django-db-transaction-2%ED%8E%B8-%EB%AA%85%EC%8B%9C%EC%A0%81%EC%9C%BC%EB%A1%9C-transaction%ED%99%9C%EC%9A%A9%ED%95%98%EA%B8%B0-feat-savepoint-53075301b3f5?source=rss-2dd1d38cdcab------2</link>
            <guid isPermaLink="false">https://medium.com/p/53075301b3f5</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[dbms]]></category>
            <category><![CDATA[mysql]]></category>
            <dc:creator><![CDATA[Jordan Bae]]></dc:creator>
            <pubDate>Fri, 04 Feb 2022 08:15:32 GMT</pubDate>
            <atom:updated>2023-07-05T10:05:02.186Z</atom:updated>
            <content:encoded><![CDATA[<h3>Django DB Transaction 2편 — 명시적으로 transaction활용하기. (feat. savepoint)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AWXtLk9LhmAo3qcF7Rd2Yg.png" /><figcaption>DB Transaction makes safe system.</figcaption></figure><h3>Introduction</h3><p>안녕하세요. 1편 <a href="https://medium.com/@doosikbae/django-db-transaction-1%ED%8E%B8-request%EC%99%80-db-transaction-%EB%AC%B6%EA%B8%B0-feat-atomic-requests-5bf976d2a33c">Django Transaction(트랜잭션) 1편 — Request와 DB Transaction 묶기(Feat. ATOMIC_REQUESTS)</a></p><p>에 이어서 2편으로 명시적으로 Django에서 DB transaction을 활용하는 방법에 대해서 포스팅해보려고 합니다.</p><p>1편에서는 전체적으로 Django에서 DB Transaction을 어떻게 사용하는지와 HTTP Request단위로 DB Transaction을 어떻게 묶는지를 살펴봤었습니다.</p><p>1편 내용을 조금 더 살펴보면 Django에서는 default로 autocommit=1 로 설정되어 있고, ATOMIC_REQUEST 변수나 django.db.transaction으로 transaction을 관리했었습니다. 그 중에서 ATOMIC_REQUEST가 True이면 HTTP Request Handler가 시작될 때 transaction이 시작되서 response를 성공적으로 보내고 Commit을 하게 되어 HTTP의 응답과 DB Transaction이 묶여서 동작하는 것을 살펴봤습니다.</p><p><strong>2편에서는 Django 에서 DB Transaction을 명시적으로 시작하고, 트랜잭션 안에서 savepoint를 사용해서 좀 더 작은 작업 단위로 묶어서 처리하는 방법에 대해서 살펴볼 예정입니다.</strong> <strong>특히, savepoint과 관련된 부분은 예제코드와 실제 Raw SQL이 어떻게 실행되는지 까지 살펴보도록 하겠습니다.</strong></p><p><strong>주의! 이 글에서 DB는 MySQL 5.7 기준입니다.</strong></p><h3>명시적으로 Transaction 활용하기</h3><p>Django에서는 DB Transaction을 관리하기 위한 하나의 API를 제공합니다.</p><p><strong>atomic(using=None, savepoint=True, durable=False)</strong></p><p>atomic는 해당 block안에서 데이터베이스의 transaction을 시작하고 commit해주거나 exception이 발생하면 rollback 해주는 역할을 합니다.</p><p>매개 변수를 살펴보면 아래와 같습니다.</p><ul><li>using: database를 선택하는 매개 변수. (명시하지 않으면 ‘default‘ db를 사용하게 됩니다.)</li><li>savepoint: transaction안에서의 일부분만 rollback이 가능하게 해주는 statement입니다. savepoint를 사용할지 여부. (이 글 아랫부분에서 다룹니다.)</li><li>durable: transaction이 가장 outer에 있어야 할 경우 사용합니다. durable=True인 경우 atomic block이 다른 atomic block안에 nested 되면 RuntimeError를 발생시켜서 가장시켜서 가장 바깥쪽에 있도록 보장합니다.</li></ul><p><strong>atomic을 사용하는 방법은 크게 두 가지 입니다.</strong></p><ul><li>context manager</li><li>decorator</li></ul><pre><strong># context manager 형식 </strong>   <br><strong>def</strong> <strong>create</strong>(self, request, *args, **kwargs):     <br>    serializer = self.get_serializer(data=request.data)               <br>    serializer.is_valid(raise_exception=True)      <br>    <strong>with</strong> transaction.atomic():         <br>        serializer.save()     <br>    <strong>raise</strong> Exception(&#39;데이터는 저장되었지만, Controller 에러&#39;)     <br>    <strong>return</strong> Response(&#39;success&#39;, status=HTTP_201_CREATED)   </pre><pre><br><strong># decorator 형식  <br></strong>@transaction.atomic()<br>def create(self, validated_data, *args, **kwargs):<br>        # 보낸 사람의  주식을 줄인다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_from&#39;), company_id=validated_data.get(&#39;company_id&#39;))\<br>            .update(amount=F(&#39;amount&#39;) - validated_data.get(&#39;amount&#39;))<br>        # 받은 사람의 주식을 늘린다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_to&#39;), company_id=validated_data.get(&#39;company_id&#39;))\<br>            .update(amount=F(&#39;amount&#39;) + validated_data.get(&#39;amount&#39;))<br>        # 전송내역을 저장한다.<br>        transfer = SharesTransfer.objects.create(<br>            account_from_id=validated_data.get(&#39;account_from&#39;),<br>            account_to_id=validated_data.get(&#39;account_to&#39;),<br>            company_id=validated_data.get(&#39;company_id&#39;),<br>            amount=validated_data.get(&#39;amount&#39;)<br>        )<br>        return transfer</pre><p>저는 개인적으로는 controller(django에서 view)나 service layer에서 처리해주는 것을 선호합니다. 왜냐하면 어떤 함수를 가져다 사용할 때 매번 체크하기 어렵기 때문에 service layer든 controller든 한 곳에서 관리하는 것을 선호하기 때문입니다.</p><h3>예제를 통해 동작 살펴보기</h3><p>context manager를 사용해서 controller에서 테스트를 해보겠습니다.</p><p>대부분의 코드는 1편에서 사용했던 코드 입니다. 혹시, 코드가 갑자기 나와서 이해가 어려우시면 <a href="https://medium.com/@doosikbae/django-db-transaction-1%ED%8E%B8-request%EC%99%80-db-transaction-%EB%AC%B6%EA%B8%B0-feat-atomic-requests-5bf976d2a33c">1편</a>을 가볍게 읽고 오시는 것을 추천드립니다.</p><pre>class ShareTransferViewSet(viewsets.GenericViewSet):<br>    permission_classes = [permissions.IsAuthenticated]<br>    serializer_class = SharesTransferSerializer<br>    lookup_field = &#39;id&#39;<br><br>    def create(self, request, *args, **kwargs):<br>        serializer = self.get_serializer(data=request.data)<br>        serializer.is_valid(raise_exception=True)<br><br>        serializer.save()<br>        <strong>with</strong> transaction.atomic():         <br>            serializer.save()     <br>        <strong>raise</strong> Exception(&#39;데이터는 저장되었지만, Controller 에러&#39;)<br>        return Response(&#39;success&#39;, status=status.HTTP_201_CREATED)</pre><p>위와 같이 코드를 변경해서 <strong>serializer.save() </strong>이 부분만 transaction으로 묶어주었습니다.</p><p>DRF 에서 지원하는 Web GUI를 이용해서 Request를 보냅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oisc2qHI2Vt8j6MF7lsXjg.png" /><figcaption>1번 계좌에서 2번 계좌로 1주 전송</figcaption></figure><p>예상대로 아래와 같이 Exception이 raise되었습니다. 그리고 Response는 에러 메시지가 왔지만 데이터베이스에는 모두 잘 저장 되었습니다. 다행인 점은 3개의 쿼리가 하나의 트랜잭션으로 묶였기 때문에 각 테이블간의 데이터의 integrity는 깨지지 않았습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*t9j9hjEWMc7rMxr-.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*30H-jw7Ux4u1ft0r.png" /><figcaption>trading_sharestransfer테이블</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qkXWK-UHGyDgj6OBbJIvnw.png" /><figcaption><strong>trading_shares 테이블</strong></figcaption></figure><p>첫 번째 Posting글과는 다르게 Http Request의 handler자체를 트랜잭션으로 묶지 않아서 사용자에게 보여지는 integrity는 깨질 수 있습니다. (Ex. handler안에서 거래완료 이메일이 전송됨 등의 다른 로직과의 integrity를 의미합니다.)</p><p>하지만, 최소한의 DB 테이블 간의 데이터 정합성은 지켰습니다. <strong>DB Transaction의 원래 목적은 데이터의 정합성을 지키는 일입니다.</strong> HTTP 요청 핸들러 자체를 트랜잭션으로 묶는것도 단점이 많이 있기 때문에(1편에서 다뤘었음) 이렇게 DB 테이블이나 다른 데이터 저장소간에 정합성을 지키면서 transaction을 작게 가져가는 방법도 있습니다. 사실 다른 부분에서 exception이 발생하는 경우는 테스트코드나 Sentry같은 에러 모니터링 서비스로 바로 발견해서 고칠 수 있기 때문에 상황에 맞게 사용하는 것이 좋다고 생각합니다.</p><h3>Nested block으로 Savepoint 활용하기</h3><p>transaction함수는 nested 방식으로도 활용할 수 있습니다.(실제 DB에서는 transaction안에서 savepoint로 동작합니다. savepoint에 대한 설명은 뒤에!)</p><p>즉, transaction blcok에서 또 transaction block을 생성 할 수 있습니다.</p><p>예시 코드로 ATOMIC_REQUEST=True로 하고, controller안에서 transaction을 또 하나 사용합니다.</p><p>즉, ATOMIC_REQUEST로 인한 Transaction안에서 또 하나의 transaction block이 하나 더 있습니다.</p><pre># settings.py<br>DATABASES = {<br>    &#39;default&#39;: {<br>        &#39;ENGINE&#39;: &#39;django.db.backends.mysql&#39;,<br>        &#39;NAME&#39;: os.environ.get(&#39;DJANGO_DB_NAME&#39;, &#39;djangosample&#39;),<br>        &#39;USER&#39;: os.environ.get(&#39;DJANGO_DB_USERNAME&#39;, &#39;root&#39;),<br>        &#39;PASSWORD&#39;: os.environ.get(&#39;DJANGO_DB_PASSWORD&#39;, &#39;example&#39;),<br>        &#39;HOST&#39;: os.environ.get(&#39;DJANGO_MYSQL_HOST&#39;, &#39;localhost&#39;),<br>        &#39;PORT&#39;: os.environ.get(&#39;DJANGO_DB_PORT&#39;, &#39;3306&#39;),<br>        &#39;ATOMIC_REQUESTS&#39;: True<br>    },<br>}</pre><pre># views.py<br>def create(self, request, *args, **kwargs):     <br>    serializer = self.get_serializer(data=request.data)               <br>    serializer.is_valid(raise_exception=True)      <br>    with transaction.atomic():         <br>        serializer.save()     <br>    raise Exception(&#39;데이터는 저장되었지만, Controller 에러&#39;)     <br>    return Response(&#39;success&#39;, status=HTTP_201_CREATED)</pre><p>이번에는 위에 요청에서 조금 변경하여 2번 account에서 1번 account로 11주를 전송해보는 테스트를 해보면 예상대로 에러가 발생합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uzEcrc61Xlvb3iC2LKFhiQ.png" /></figure><p>과연 데이터들은 변경이 되었을까요?</p><p>먼저, 실제 실행되는 SQL을 살펴보겠습니다.</p><pre># connection initialization<br>2022-01-14T13:18:56.422318Z    17 Query SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED</pre><pre># atomic_requests=True이기 때문에 handler 시작할 때 transaction이 시작.<br>2022-01-14T13:18:56.423206Z    17 Query SET autocommit=0 2022-01-14T13:18:56.431882Z    17 Query SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-01-14 13:18:56.430715&#39; AND `django_session`.`session_key` = &#39;7wp4h1d3porowvfdewfldqskiiucyh4r&#39;) LIMIT 21 <br>2022-01-14T13:18:56.434546Z    17 Query SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 1 LIMIT 21 </pre><pre># view 내부의 transaction block<br>2022-01-14T13:18:56.436768Z    17 Query SAVEPOINT `s140426989328128_x1` <br>2022-01-14T13:18:56.439410Z    17 Query UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 11) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1) <br>2022-01-14T13:18:56.441327Z    17 Query UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 11) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1) <br>2022-01-14T13:18:56.442605Z    17 Query INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (2, 1, 1, 11, &#39;2022-01-14 13:18:56.442145&#39;, &#39;2022-01-14 13:18:56.442190&#39;) 2022-01-14T13:18:56.444955Z    17 Query RELEASE SAVEPOINT `s140426989328128_x1` <br>2022-01-14T13:18:56.447180Z    17 Query ROLLBACK <br>2022-01-14T13:18:56.449048Z    17 Query SET autocommit=1</pre><p>handler시작 부분에 autocommit=0으로 Set되고 Commit이 되지 않았기 때문에 아무런 데이터의 변경도 적용되지 않습니다.</p><p><strong>즉, outer에 있는 transaction이 끝나기 전에 exception이 발생하면 inner에 transaction block이 잘 수행되더라도 반영되지 않습니다. </strong>SAVEPOINT statement는 조금 뒤에서 살펴보겠습니다.</p><p>이번에는 <strong>ATOMIC_REQUESTS가 0이 었을 때</strong>를 먼저 한 번 살펴보면 아래와 같습니다.</p><p>SET automcommit=0 statement가 auth_user select 쿼리 밑에서 실행됩니다.</p><ul><li>&gt; 참고로 맨위에는 장고에서 connection을 생성할 때 transaction isolation level 을 설정 하는 부분입니다. (Django 에서 connection을 맺을 때 마다 실행됩니다.)</li></ul><pre>2022-01-14T13:13:06.564198Z    13 Query SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED<br>2022-01-14T13:13:06.565020Z    13 Query SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-01-14 13:13:06.559760&#39; AND `django_session`.`session_key` = &#39;7wp4h1d3porowvfdewfldqskiiucyh4r&#39;) LIMIT 21<br>2022-01-14T13:13:06.566854Z    13 Query SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 1 LIMIT 21<br>2022-01-14T13:13:06.569175Z    13 Query SET autocommit=0<br>2022-01-14T13:13:06.572830Z    13 Query UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 5) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1)<br>2022-01-14T13:13:06.576571Z    13 Query UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 5) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1)<br>2022-01-14T13:13:06.578648Z    13 Query INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (2, 1, 1, 5, &#39;2022-01-14 13:13:06.578168&#39;, &#39;2022-01-14 13:13:06.578217&#39;)<br>2022-01-14T13:13:06.580844Z    13 Query COMMIT<br>2022-01-14T13:13:06.583488Z    13 Query SET autocommit=1</pre><p>두 개의 상황에서의 각각 Raw SQL을 살펴보면 <strong>가장 바깥에 있는 transaction block은 SET autocommit=0을 실행하지만, inner transaction block은 SAVEPOINT statement를 시작하는 부분</strong>이라는 것을 알 수 있습니다.</p><p>SAVEPOINT에 대해서 더 자세히 알아보기 위해서 공식 문서의 예제인 outer 부분이 아닌 inner부분에서 exception이 발생했을 때 inner block에서 try, exception구문을 사용해서 outer block의 다른 부분들을 잘 반영할 수 있는 예제를 살펴보겠습니다.</p><pre><strong>from</strong> django.db <strong>import</strong> IntegrityError, transaction  </pre><pre><br>@transaction.atomic <br><strong>def</strong> <strong>viewfunc</strong>(request):     <br>    create_parent()      <br>    <strong>try</strong>:         <br>        <strong>with</strong> transaction.atomic():<br>            generate_relationships()     <br>    <strong>except</strong> IntegrityError:         <br>        handle_exception()     <br>    add_children()</pre><p><strong>여기서 inner transaction block에서 예외가 발생하지만 create_parent()와 add_children()는 잘 DB에 반영이 됩니다.</strong></p><p>어떻게 안쪽에 있는 transaction block에 있는 SQL들만 Rollback이 될 수 있을까요? 그건 바로 저희가 Raw SQL을 살펴봤을 때 봤던 savepoint statement를 사용하였기 때문입니다. 자세히 살펴본 분들은 파악하셨을 수도 있겠지만 atomic block nested되어 있을 때는 savepoint statement가 실행됩니다.</p><pre>2022-01-14T13:18:56.436768Z    17 Query SAVEPOINT `s140426989328128_x1` <br>2022-01-14T13:18:56.439410Z    17 Query UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 11) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1) <br>2022-01-14T13:18:56.441327Z    17 Query UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 11) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1) <br>2022-01-14T13:18:56.442605Z    17 Query INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (2, 1, 1, 11, &#39;2022-01-14 13:18:56.442145&#39;, &#39;2022-01-14 13:18:56.442190&#39;) 2022-01-14T13:18:56.444955Z    17 Query RELEASE SAVEPOINT `s140426989328128_x1`</pre><p>savepoint를 통해 전체 transaction이 아닌 savepoint 이후의 부분만 rollback을 할 수 있습니다. 위와 같은 예를 보기 위해서 예시를 하나 들어보겠습니다. view 코드를 아래처럼 변경했습니다.</p><pre># ATOMIC_REQUESTS<br>&#39;ATOMIC_REQUESTS&#39;: True<br><br># view 코드<br>class ShareTransferViewSet(viewsets.GenericViewSet):<br>    permission_classes = [permissions.IsAuthenticated]<br>    serializer_class = SharesTransferSerializer<br>    lookup_field = &#39;id&#39;<br><br>    def create(self, request, *args, **kwargs):<br>        serializer = self.get_serializer(data=request.data)<br>        serializer.is_valid(raise_exception=True)<br><br>        with transaction.atomic():<br>            serializer.save()<br>        try:<br>            with transaction.atomic():<br>                # dummy query for example<br>                SharesTransfer.objects.create(amount=1, account_from_id=1, account_to_id=2, company_id=1)<br>                raise Exception(&#39;savepoint를 이용해서 일부분은 반영이 되었음!&#39;)<br>        except Exception as e:<br>            print(e)<br>        return Response(&#39;success&#39;, status=HTTP_201_CREATED)</pre><p>그리고 1번 account에서 2번 account로 1번 company주식을 1주 보내겠습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ueokAELFTspHqd4GYG0QFA.png" /></figure><p>저희의 예상대로면 아래와 같은 순서로 쿼리가 실행될 것 입니다.</p><ol><li>request handler가 시작되면 새로 connection을 맺으면서 isolation level 설정.</li><li>ATOMIC_REQUESTS = True이기 때문에 SET autocoomit=0실행</li><li>기타 인증 관련된 쿼리</li><li>첫번 째 atomic block에서 savepoint 구문이 실행.</li><li>2개의 업데이트문과 1개의 insert문이 실행.</li><li>release savepoint 구문 실행</li><li>두번 째 atomic block에서 savepoint 구문이 실행.</li><li>dummy 쿼리 실행</li><li>ROLLBACK TO SAVEPOINT 구문 실행</li><li>두번 째 savepoint에 대한 release구문 실행.</li><li>commit</li><li>set commit=1</li></ol><p>결과를 확인해보면 아래와 같습니다</p><pre>2022-01-17T03:03:11.602531Z    45 Query    SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED<br>2022-01-17T03:03:11.603278Z       45 Query    SET autocommit=0<br>2022-01-17T03:03:11.612218Z       45 Query    SELECT `django_session`.`session_key`, `django_session`.`session_data`, `django_session`.`expire_date` FROM `django_session` WHERE (`django_session`.`expire_date` &gt; &#39;2022-01-17 03:03:11.610777&#39; AND `django_session`.`session_key` = &#39;tckamdxe8wb18ckng212s66lwu9sae23&#39;) LIMIT 21<br>2022-01-17T03:03:11.614256Z       45 Query    SELECT `auth_user`.`id`, `auth_user`.`password`, `auth_user`.`last_login`, `auth_user`.`is_superuser`, `auth_user`.`username`, `auth_user`.`first_name`, `auth_user`.`last_name`, `auth_user`.`email`, `auth_user`.`is_staff`, `auth_user`.`is_active`, `auth_user`.`date_joined` FROM `auth_user` WHERE `auth_user`.`id` = 1 LIMIT 21<br>2022-01-17T03:03:11.616545Z       45 Query    SAVEPOINT `s139971393275648_x1`<br>2022-01-17T03:03:11.618084Z       45 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` - 1) WHERE (`trading_shares`.`account_id` = 1 AND `trading_shares`.`company_id` = 1)<br>2022-01-17T03:03:11.619770Z       45 Query    UPDATE `trading_shares` SET `amount` = (`trading_shares`.`amount` + 1) WHERE (`trading_shares`.`account_id` = 2 AND `trading_shares`.`company_id` = 1)<br>2022-01-17T03:03:11.621195Z       45 Query    INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (1, 2, 1, 1, &#39;2022-01-17 03:03:11.620751&#39;, &#39;2022-01-17 03:03:11.620872&#39;)<br>2022-01-17T03:03:11.621943Z       45 Query    RELEASE SAVEPOINT `s139971393275648_x1`<br>2022-01-17T03:03:11.622648Z       45 Query    SAVEPOINT `s139971393275648_x2`<br>2022-01-17T03:03:11.623438Z       45 Query    INSERT INTO `trading_sharestransfer` (`account_from_id`, `account_to_id`, `company_id`, `amount`, `created_dt`, `updated_dt`) VALUES (1, 2, 1, 1, &#39;2022-01-17 03:03:11.623168&#39;, &#39;2022-01-17 03:03:11.623208&#39;)<br>2022-01-17T03:03:11.624212Z       45 Query    ROLLBACK TO SAVEPOINT `s139971393275648_x2`<br>2022-01-17T03:03:11.628485Z       45 Query    RELEASE SAVEPOINT `s139971393275648_x2`<br>2022-01-17T03:03:11.629442Z       45 Query    COMMIT<br>2022-01-17T03:03:11.631757Z       45 Query    SET autocommit=1</pre><p>또, 2번째 Inner atomic block은 실패했지만 바깥부분의 query와 첫번째 atomic block 쿼리는 잘 수행된 것을 확인할 수 있습니다.</p><p>혹시, savepoint와 관련된 부분이 더 궁금하신 분은 mysql 공식문서를 한 번 읽어보시는 것을 추천드립니다.</p><p><a href="https://dev.mysql.com/doc/refman/5.7/en/savepoint.html">MySQL :: MySQL 5.7 Reference Manual :: 13.3.4 SAVEPOINT, ROLLBACK TO SAVEPOINT, and RELEASE SAVEPOINT Statements</a></p><h3>Atomic block안에서 Exception을 Catch하지 않기</h3><p>공식문서에서는 atomic block 안에서 exception을 catch하는 것을 피하고 안내합니다.</p><pre># x 추천 하지 않음.<br>with transaction.atomic():<br>  try:<br>      # dummy query for example<br>      SharesTransfer.objects.create(amount=1, account_from_id=1, account_to_id=2, company_id=1)<br>      raise Exception(&#39;savepoint를 이용해서 일부분은 반영이 되었음!&#39;)<br>  except Exception as e:<br>       print(e)<br><br># O 추천하는 방법.<br>try:<br>    with transaction.atomic():<br>        # dummy query for example<br>        SharesTransfer.objects.create(amount=1, account_from_id=1, account_to_id=2, company_id=1)<br>        raise Exception(&#39;savepoint를 이용해서 일부분은 반영이 되었음!&#39;)<br>except Exception as e:<br>    print(e)</pre><p>그 이유는 block하나가 어떤 하나의 데이터베이스의 동작을 수행하는데 그 사이에 다른 코드들이 들어감으로써 Django에서는 모르는 동작이 추가된다는 것을 의미합니다. 소개해주는 예시를 살펴보면 atomic block 안에 exception을 catch해서 쿼리를 시도한다면 TransactionManagementError가 발생되게 됩니다. (rollback을 할 건데 쿼리를 시도했기 때문이라고 생각됩니다.)</p><h3>마무리</h3><p>이것으로 Django 에서 DB Transaction을 다루는 방법 중 하나인 transacton.atomic에 대한 포스팅을 마칩니다. 간단한 코드부터 savepoint의 역할 실제 Raw SQL까지 어떻게 실행되는지 살펴봤습니다. 읽어 주셔서 감사합니다. 도움이 되셨다면 좋아요와 응원 댓글 부탁드려요! 감사합니다!</p><h3>Reference</h3><p><a href="https://dev.mysql.com/doc/refman/5.7/en/savepoint.html"><strong>https://dev.mysql.com/doc/refman/5.7/en/savepoint.html</strong></a><strong><br></strong><a href="https://docs.djangoproject.com/en/4.0/topics/db/transactions/"><strong>https://docs.djangoproject.com/en/4.0/topics/db/transactions/</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=53075301b3f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Django DB Transaction 1편 — Request와 DB Transaction 묶기(Feat. ATOMIC_REQUESTS)]]></title>
            <link>https://medium.com/@doosikbae/django-db-transaction-1%ED%8E%B8-request%EC%99%80-db-transaction-%EB%AC%B6%EA%B8%B0-feat-atomic-requests-5bf976d2a33c?source=rss-2dd1d38cdcab------2</link>
            <guid isPermaLink="false">https://medium.com/p/5bf976d2a33c</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[dbms]]></category>
            <dc:creator><![CDATA[Jordan Bae]]></dc:creator>
            <pubDate>Fri, 04 Feb 2022 07:38:32 GMT</pubDate>
            <atom:updated>2022-02-04T07:38:32.281Z</atom:updated>
            <content:encoded><![CDATA[<h3>Django DB Transaction 1편 — Request와 DB Transaction 묶기(Feat. ATOMIC_REQUESTS)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*AWXtLk9LhmAo3qcF7Rd2Yg.png" /><figcaption>DB Transaction makes safe system.</figcaption></figure><h3><strong>Introudction</strong></h3><p>안녕하세요. 새해에는 Django와 관련된 글들을 많이 다뤄 보려고 합니다.</p><p>첫 번째로 Django에서 DB Transaction을 다루는 방법에 대해서 공부하고 글을 써보려고 합니다. Transaction은 DB에서 작업의 원자성을 보장하기 위해 제공되는 기능입니다. Transaction 자체에 대해서 궁금하신 분이 있으면 아래 글을 읽어 보시는 것을 추천합니다.</p><p><a href="https://brunch.co.kr/@skeks463/27">[DataBase] DB를 지탱하는 트랜잭션</a></p><p>총 아래와 같이 3편으로 나눠서 작성할 생각입니다.</p><p>1편 Request와 DB Transction 묶기<br>2편 명시적으로 DB Transaction과 savepoint활용하기<br>3편 DB Transaction과 관련된 테스트 케이스 작성하기</p><p>대부분의 내용은 공식문서의 내용이고 약간의 이해를 돕기위해서 코드 샘플을 만들어서 진행해 보려고 합니다.</p><p>부족한 글이지만 도움이 되셨으면 좋겠습니다.</p><h3>Django DB Transaction</h3><p>Django에서는 데이테베이스의 Transaction을 control할 수 있는 몇 가지 방법을 제공합니다. Transaction을 따로 control하는 설정이나 기능을 사용하지 않으면 기본적으로 <a href="https://docs.djangoproject.com/en/4.0/topics/db/transactions/#autocommit-details"><strong>autocommit</strong></a> mode로 동작합니다.</p><p>autocommit이 True인 경우는 각 쿼리에서 명시적으로 transaction을 시작하고 commit하지 않아도 됨을 의미합니다.</p><pre># autocommit=true   <br>delete <strong>from</strong> {table_name} where id=1   </pre><pre># 위의 쿼리는 아래처럼 동작합니다.  <br>start transaction;  <br>delete <strong>from</strong> {table_name} where id=1  <br>commit;</pre><pre>or </pre><pre>set autocommit=0;<br>delete <strong>from</strong> {table_name} where id=1<br>commit;</pre><p>Django에서 한 개이상의 쿼리를 트랜잭션을 handling하는 방법은 크게 두 가지 입니다.</p><ul><li><a href="https://docs.djangoproject.com/en/4.0/ref/settings/#std:setting-DATABASE-ATOMIC_REQUESTS"><strong>ATOMIC_REQUESTS</strong></a> 를 이용하여 request의 response의 hanlder(view)와 transaction을 묶는 방법</li><li><strong>django.db.transaction</strong> 을 사용하여 명시적으로 transaction을 핸들링 하는 방법.</li></ul><p>이번 글에서는 ATOMIC_REQUESTS를 이용해서 request의 response의 hanlder(view) 단위로 DB Transaction을 묶는 것에 대해서 알아보겠습니다.</p><h3>Sample Code</h3><p>예시 코드로는 간단하게 주식을 전달 할 수 있는 API를 만들었습니다. 1편 뿐만 아니라 2,3편에 쓰일 코드이니 한 번 보고 넘어가겠습니다.</p><p>아래 코드는 오직 transaction을 설명하기 위한 예시 코드로 인증이나 데이터의 validation등 대부분의 서비스에 필요한 로직은 모두 생략했습니다.</p><p>models.py은 아래와 같습니다.</p><pre>from django.db import models<br>from django.contrib.auth.models import User<br><br><br>class Company(models.Model):<br>    ticker = models.CharField(max_length=16)<br>    name = models.CharField(max_length=64)<br><br><br>class Account(models.Model):<br>    owner = models.ForeignKey(User, on_delete=models.PROTECT, db_constraint=False)<br><br>    created_dt = models.DateTimeField(auto_now_add=True)<br>    updated_dt = models.DateTimeField(auto_now=True)<br><br>    def __repr__(self):<br>        return f&quot;{self.owner} Account&quot;<br><br><br>class Shares(models.Model):<br>    account = models.ForeignKey(Account, on_delete=models.PROTECT, db_constraint=False)<br>    company = models.ForeignKey(Company, on_delete=models.CASCADE, db_constraint=False)<br>    amount = models.PositiveBigIntegerField()<br><br>    created_dt = models.DateTimeField(auto_now_add=True)<br>    updated_dt = models.DateTimeField(auto_now=True)<br><br>    class Meta:<br>        unique_together = [[&#39;account&#39;, &#39;company&#39;]]<br><br><br>class SharesTransfer(models.Model):<br>    account_from = models.ForeignKey(<br>        Account, on_delete=models.PROTECT, db_constraint=False, related_name=&#39;account_from&#39;<br>    )<br>    account_to = models.ForeignKey(<br>        Account, on_delete=models.PROTECT, db_constraint=False, related_name=&#39;account_to&#39;<br>    )<br>    company = models.ForeignKey(Company, on_delete=models.PROTECT, db_constraint=False)<br>    amount = models.PositiveBigIntegerField()<br><br>    created_dt = models.DateTimeField(auto_now_add=True)<br>    updated_dt = models.DateTimeField(auto_now=True)</pre><p>간단한게 django에서 제공하는 User 모델과 custom으로 만든 Account, Company, Shares, SharesTransfer 테이블이 있습니다.</p><p>SharesTransfer은 어떤 계좌에서 어떤 계좌로 어떤 회사의 주식이 얼만큼 전송했는지의 데이터를 저장하는 테이블입니다.</p><p>다음은view에서 사용하는 serializers.py의 코드입니다. 데이터를 받아서 저장하는 코드를 가지고 있습니다.</p><pre>from django.db.models import F<br>from rest_framework import serializers<br><br>from .models import Shares, SharesTransfer<br><br><br>class SharesTransferSerializer(serializers.Serializer):<br>    # validation 은 생략<br>    account_from = serializers.IntegerField()<br>    account_to = serializers.IntegerField()<br>    company_id = serializers.IntegerField()<br>    amount = serializers.IntegerField()<br><br>    def create(self, validated_data, *args, **kwargs):<br>        # 보낸 사람의  주식을 줄인다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_from&#39;), company_id=validated_data.get(&#39;company_id&#39;))\<br>            .update(amount=F(&#39;amount&#39;) - validated_data.get(&#39;amount&#39;))<br>        # 받은 사람의 주식을 늘린다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_to&#39;), company_id=validated_data.get(&#39;company_id&#39;))\<br>            .update(amount=F(&#39;amount&#39;) + validated_data.get(&#39;amount&#39;))<br>        # 전송내역을 저장한다.<br>        transfer = SharesTransfer.objects.create(<br>            account_from_id=validated_data.get(&#39;account_from&#39;),<br>            account_to_id=validated_data.get(&#39;account_to&#39;),<br>            company_id=validated_data.get(&#39;company_id&#39;),<br>            amount=validated_data.get(&#39;amount&#39;)<br>        )<br>        return transfer</pre><p>controller인 view 코드는 아래와 같습니다.</p><pre>from rest_framework import viewsets, permissions<br>from rest_framework.response import Response<br>from rest_framework import status<br><br>from .serializers import SharesTransferSerializer<br><br><br>class ShareTransferViewSet(viewsets.GenericViewSet):<br>    permission_classes = [permissions.IsAuthenticated]<br>    serializer_class = SharesTransferSerializer<br>    lookup_field = &#39;id&#39;<br><br>    def create(self, request, *args, **kwargs):<br>        serializer = self.get_serializer(data=request.data)<br>        serializer.is_valid(raise_exception=True)<br><br>        serializer.save()<br>        return Response(&#39;success&#39;, status=status.HTTP_201_CREATED)</pre><p>어려운 부분은 거의 없어서 자세한 설명은 생략할 생각입니다. 혹시, 궁금한 부분이 있으면 언제든지 편하게 댓글로 알려주세요!</p><p>API 요청을 받아서 serializer.save() 코드로 만들어준 create()함수를 호출합니다.(serializer의 save 메서드가 내부에서 create 메서드를 호출합니다.)</p><p>대표적인 Transaction 사용의예시인 은행 송금 처럼 주식 전송 기능 또한 제 계좌에서 나갔으면 반드시 누군가의 계좌에 들어가야 하고 또한 기록이 남아야 합니다.</p><p><strong>그래서 serializer의 create()함수는 꼭 하나의 transaction으로 묶여서 동작해야 합니다.</strong></p><p>그럼 이제 위의 예시로 코드로 위에서 얘기한 Django에서 제공하는 Transaction을 사용하는 두 가지 방법을 살펴보겠습니다. (다시 한 번 보시죠! 저희는 기억력이 짧으니깐요..ㅠ)</p><p>Django에서 한 개이상의 쿼리를 트랜잭션을 handling하는 방법은 크게 두 가지 입니다.</p><ul><li><a href="https://docs.djangoproject.com/en/4.0/ref/settings/#std:setting-DATABASE-ATOMIC_REQUESTS"><strong>ATOMIC_REQUESTS</strong></a> 를 이용하여 request단위로 transaction을 묶는 방법</li><li><strong>django.db.transaction</strong> 을 사용하여 명시적으로 transaction을 핸들링 하는 방법.</li></ul><h3>HTTP 요청과 transaction을 묶기.</h3><p>이 방법은 꽤나 큰 범위로 transaction을 묶었다고 생각할 수도 있지만 어떻게 보면 가장 깔끔합니다. 예를 들어서, 마지막 response를 return하기 바로 전 라인의 코드에서 에러가 나서 사용자에게 500 Error를 return했는데 실제 주식 전송이 되었다면? 조금 많이 당황스러울 수 있습니다. 그래서 조금 무겁긴 하지만 web service에서 아주 신뢰성이 중요한 작업에서는 request하나를 atomic하게 다뤄야 할 수 있습니다.</p><p>각 Request를 DB Transaction으로 핸들링 하기 위해서 하는 가장 흔한 방법은 <strong>ATOMIC_REQUESTS</strong>를 True로 설정하는 방법입니다.</p><pre>DATABASES = {<br>    &#39;default&#39;: {<br>        &#39;ENGINE&#39;: &#39;django.db.backends.mysql&#39;,<br>        &#39;NAME&#39;: os.environ.get(&#39;DJANGO_DB_NAME&#39;, &#39;djangosample&#39;),<br>        &#39;USER&#39;: os.environ.get(&#39;DJANGO_DB_USERNAME&#39;, &#39;root&#39;),<br>        &#39;PASSWORD&#39;: os.environ.get(&#39;DJANGO_DB_PASSWORD&#39;, &#39;example&#39;),<br>        &#39;HOST&#39;: os.environ.get(&#39;DJANGO_MYSQL_HOST&#39;, &#39;localhost&#39;),<br>        &#39;PORT&#39;: os.environ.get(&#39;DJANGO_DB_PORT&#39;, &#39;3306&#39;),<br>        &#39;ATOMIC_REQUESTS&#39;: True<br>    },<br>}</pre><p>위와 같이 database설정을 합니다.</p><p>현재 DB 데이터를 보면 아래와 같습니다. 1번 account는 1번 회사(amazon)의 주식을 98주 가지고 있고, 2번 account는 1번 회사(amazon)의 주식을 2주를 가지고 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5bc34-wQkxt9RTUyLDtaBQ.png" /><figcaption>Tableplus로 DB 데이터 확인</figcaption></figure><p>시원하게 1번이 2번에게 10주를 보내보겠습니다. (누가 저한테 아마존 10주만…)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bc89kv3QDmXMzgP3CaXvHQ.png" /><figcaption>DRF의 web UI이용.</figcaption></figure><p>예상대로 주식 수가 잘 변경 됐고, transfer 내역도 잘 생성됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S91Huqw-Z-zxj5-KaQqauw.png" /></figure><p>이제 한 번 <a href="https://docs.djangoproject.com/en/4.0/ref/settings/#std:setting-DATABASE-ATOMIC_REQUESTS">ATOMIC_REQUESTS</a> 설정이 잘 동작하는지 확인하기 위해서 아래처럼 raise()를 발생시켜봅니다.</p><pre>class SharesTransferSerializer(serializers.Serializer):<br>    # validation 은 생략<br>    account_from = serializers.IntegerField()<br>    account_to = serializers.IntegerField()<br>    company_id = serializers.IntegerField()<br>    amount = serializers.IntegerField()<br><br>    def create(self, validated_data, *args, **kwargs):<br>        # 보낸 사람의  주식을 줄인다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_from&#39;), company_id=validated_data.get(&#39;company_id&#39;))\<br>            .update(amount=F(&#39;amount&#39;) - validated_data.get(&#39;amount&#39;))<br>        # 받은 사람의 주식을 늘린다.<br>        Shares.objects.filter(account_id=validated_data.get(&#39;account_to&#39;), company_id=validated_data.get(&#39;company_id&#39;))\<br>            .update(amount=F(&#39;amount&#39;) + validated_data.get(&#39;amount&#39;))</pre><pre>        # 테스트를 위해서 예외 발생시키기.         <br>        <strong>raise</strong>(&#39;전송내역 저장 전에 에러 발생했지만 우린 request단위로 transaction을 묶었지!&#39;)<br>        # 전송내역을 저장한다.<br>        transfer = SharesTransfer.objects.create(<br>            account_from_id=validated_data.get(&#39;account_from&#39;),<br>            account_to_id=validated_data.get(&#39;account_to&#39;),<br>            company_id=validated_data.get(&#39;company_id&#39;),<br>            amount=validated_data.get(&#39;amount&#39;)<br>        )<br>        return transfer</pre><p>이제 테스트를 위해서 5주를 추가로 보내 봅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DW6Ns6W9JVEN_L2rok2PYw.png" /><figcaption>아마존 주식 5주 전송.</figcaption></figure><p>예상대로 에러가 발생합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g--hyuwCFZ_lwAHJYtMwsg.png" /></figure><p>하지만, 여전히 account1 은 88주를 보유 중입니다. Transaction으로 묶어준 보람이 있네요! 예상대로 전에 실행된 SQL이 rollback되어 아무런 변화가 일어나지 않은 것을 확인할 수 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x_psp5IYBmDqnLZ5Jz1yiw.png" /><figcaption>Transaction으로 묶어줬기 때문에 전에 실행된 SQL이 rollback됐습니다!.</figcaption></figure><p>이번에는 ‘ATOMIC_REQUESTS’: True 주석 처리해보고 테스트 해봅니다.</p><pre>DATABASES = {<br>    &#39;default&#39;: {<br>        &#39;ENGINE&#39;: &#39;django.db.backends.mysql&#39;,<br>        &#39;NAME&#39;: os.environ.get(&#39;DJANGO_DB_NAME&#39;, &#39;djangosample&#39;),<br>        &#39;USER&#39;: os.environ.get(&#39;DJANGO_DB_USERNAME&#39;, &#39;root&#39;),<br>        &#39;PASSWORD&#39;: os.environ.get(&#39;DJANGO_DB_PASSWORD&#39;, &#39;example&#39;),<br>        &#39;HOST&#39;: os.environ.get(&#39;DJANGO_MYSQL_HOST&#39;, &#39;localhost&#39;),<br>        &#39;PORT&#39;: os.environ.get(&#39;DJANGO_DB_PORT&#39;, &#39;3306&#39;),<br>        # &#39;ATOMIC_REQUESTS&#39;: True<br>    },<br>}</pre><p>똑같은 request를 했을 때.. 저희가 예상한 것 처럼 account 1는88주에서 83주로 5주가 줄고, account 2는 12 주에 17주로 5주 늘었습니다. 그리고 예상대로 transfer내역은 쌓이지 않았습니다.. 실제 서비스라면 아주 큰 문제입니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V5yxuEKXMcrYtN28X5lLow.png" /><figcaption>내 주식 어디갔어…</figcaption></figure><p>지금 보신것 처럼 DB의 transaction은 정말 중요한 개념입니다. 방금 처럼 동작한다면 저의 주식 전송 서비스는 바로 신뢰를 잃고 망할 것 입니다. 아주 간단한 설정으로 request에 대한 handler의 response를 성공적으로 return하고 아니냐에 따라서 DB의 transaction을 처리할 수 있습니다.</p><p><strong>조금 더 구체적으로 동작 과정을 살펴보면</strong></p><ol><li>view function을 호출하기 전에 DB에 “set autocommit=0” statement를 실행 됩니다..</li><li>view function이 성공적으로 response를 만들면 DB에 “commit” statement 실행합니다.그렇지 않고 Exception이 발생하면 “rollback” statement를 실행합니다.</li></ol><p><strong>만약에 모든 view가 아닌 일부 view에만 적용하고 싶다면</strong></p><p>-&gt; ATOMIC_REQUEST를 False로 하고,. view에 @<strong>transaction.atomic()</strong> 데코레이터를 추가하면 됩니다.</p><p><strong>반대로 일부 view만 적용하지 않는 것을 원하면</strong></p><ul><li>&gt; ATOMIC_REQUEST를 True로 하고,. view에 @<strong>transaction.non_atomic_requests()</strong> 데코레이터를 추가하면 됩니다.</li></ul><h3>주의 할 점</h3><p>처음에 이야기 나눈것 처럼 Request단위로 DB Transaction을 다루는 것은 큰 단위입니다. 특히 다른 서비스(redis, rabbitmq 등등)의 장애가 DB에 영향을 줄 수도 있습니다. DB의 transaction을 오래 열고 있으면 DB에 많은 부하가 발생합니다. isolation level에 따라서 차이가 있지만 MySQL의 innoDB 같은 경우에는 많은 버젼의 view를 관리하기 위해서 undo log를 purge할 수 없습니다. 이에 따란 DB의 overhead를 주의해야 합니다.</p><h3>정리</h3><p>이렇게 Request 단위로 DB Transaction을 관리하는 방법을 살펴봤습니다. 이해를 돕기위해서 예제 코드를 통해서 살펴봤습니다. 다음편에서도 예제 코드는 사용될 예정입니다. 생각보다 글이 길어졌습니다. 여기 까지 봐주셔서 감사합니다. 위에서 살펴본 것 처럼 Transaction을 제대로 관리하지 않으면 서비스의 특성에 따라 큰 사고를 불러올 수 있습니다.</p><h4>Reference</h4><p><a href="https://docs.djangoproject.com/en/4.0/topics/db/transactions/"><strong>https://docs.djangoproject.com/en/4.0/topics/db/transactions/</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5bf976d2a33c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>