updating and cleaning up documentation

Author: dantownsend

docs/src/piccolo/authentication/baseuser.rst

@@ -10,12 +10,10 @@ Inherit from ``BaseUser`` to create your own User table.
     from piccolo.extensions.user import BaseUser
 
 
-    class User(BaseUser):
+    class User(BaseUser, tablename="custom_user"):
+        pass
 
-        class Meta():
-            tablename = 'custom_user'
-
-.. hint:: A table name of `user` isn't allowed since it clashes with a keyword in Postgres - so override the ``tablename`` in ``Meta``, if you choose to name your class ``User``.
+.. hint:: A table name of `user` isn't allowed since it clashes with a keyword in Postgres - so override the ``tablename``, if you choose to name your class ``User``.
 
 login
 -----

docs/src/piccolo/engines/index.rst

@@ -6,12 +6,9 @@ Engines
 Engines are what execute the SQL queries. Each supported backend has its own
 engine (see  :ref:`EngineTypes`).
 
-Meta.db
--------
-
-It's important that each ``Table`` class knows which engine to use. This is set
-via the ``Meta.db`` attribute. There are two ways of doing this - setting it
-explicitly, or using ``engine_finder``.
+It's important that each ``Table`` class knows which engine to use. There are
+two ways of doing this - setting it explicitly via the ``db`` argument, or
+letting Piccolo find it using ``engine_finder``.
 
 Explicit
 --------
@@ -26,35 +23,17 @@ Explicit
     DB = SQLiteEngine(path='my_db.sqlite')
 
 
-    class MyTable(Table):
+    # Here we explicitly reference an engine:
+    class MyTable(Table, db=DB):
         name = Varchar()
 
-        class Meta:
-            # Here we explicitly reference an engine
-            db = DB
-
 
 engine_finder
 -------------
 
-By using ``engine_finder``, Piccolo will look for a file called
+By default Piccolo uses ``engine_finder``. Piccolo will look for a file called
 ``piccolo_conf.py`` on the path, and will try and import a ``DB`` variable,
-which defines the engine. This is the default behavior, if no ``Meta`` class is
-defined.
-
-.. code-block:: python
-
-    from piccolo.columns import Varchar
-    from piccolo.engine.finder import engine_finder
-    from piccolo.tables import Table
-
-
-    class MyTable(Table):
-        name = Varchar()
-
-        class Meta:
-            # Let Piccolo import the engine from a config file:
-            db = engine_finder()
+which defines the engine.
 
 Here's an example config file:
 

docs/src/piccolo/getting_started/sync_and_async.rst

@@ -47,7 +47,7 @@ A lot of the time, using the sync version works perfectly fine. Many of the
 examples use the sync version.
 
 Using the async version is useful for web applications which require high
-throughput, based on `ASGI frameworks </blog/introduction-to-asgi>`_.
+throughput, based on `ASGI frameworks <https://piccolo-orm.com/blog/introduction-to-asgi>`_.
 
 Explicit
 --------

docs/src/piccolo/query_types/index.rst

@@ -1,6 +1,9 @@
 Query Types
 ===========
 
+There are many different queries you can perform using Piccolo. For starters,
+focus on `select`, `insert` and `update`.
+
 .. toctree::
     :maxdepth: 0
 

docs/src/piccolo/query_types/insert.rst

@@ -9,3 +9,25 @@ This is used to insert rows into the table.
 
     >>> Band.insert(Band(name="Pythonistas")).run_sync()
     [{'id': 3}]
+
+We can insert multiple rows in one go:
+
+.. code-block:: python
+
+    Band.insert(
+        Band(name="Darts"),
+        Band(name="Gophers")
+    ).run_sync()
+
+add
+---
+
+You can also compose it as follows:
+
+.. code-block:: python
+
+    Band.insert().add(
+        Band(name="Darts")
+    ).add(
+        Band(name="Gophers")
+    ).run_sync()

docs/src/piccolo/schema/defining.rst

@@ -22,11 +22,8 @@ columns.
 
 For a full list of columns, see :ref:`ColumnTypes`.
 
-Meta
-----
-
 Connecting to the database
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+--------------------------
 
 In order to create the table and query the database, you need to provide
 Piccolo with your connection details. See :ref:`Engines`.

piccolo/commands/playground.py

@@ -94,7 +94,7 @@ def playground(engine, user, password, database, host, port):
         import IPython
     except ImportError:
         print(
-            "Install iPython using `pip install ipython==7.1.1` to use this "
+            "Install iPython using `pip install ipython==7.6.1` to use this "
             "feature."
         )
         sys.exit(1)

piccolo/query/methods/insert.py

@@ -26,12 +26,6 @@ def run_callback(self, results):
 
     @property
     def sqlite_querystring(self) -> QueryString:
-        if len(self.add_delegate._add) > 1:
-            raise Exception(
-                "The SQLite engine is unable to insert more than one row at a "
-                "time."
-            )
-
         base = f"INSERT INTO {self.table._meta.tablename}"
         columns = ",".join([i._meta.name for i in self.table._meta.columns])
         values = ",".join(["{}" for i in self.add_delegate._add])

piccolo/table.py

@@ -51,7 +51,7 @@ def __str__(cls):
         spacer = "\n    "
         columns = []
         for col in cls._meta.columns:
-            if type(col) == ForeignKey:
+            if isinstance(col, ForeignKey):
                 columns.append(
                     f"{col._meta.name} = ForeignKey({col._foreign_key_meta.references.__name__})"
                 )