hive/db/db_state.py

@@ -107,8 +107,8 @@ class DbState:
             'hive_posts_payout_at_idx',
             'hive_posts_payout_idx',
             'hive_posts_promoted_idx',
-            'hive_posts_sc_trend_idx',
-            'hive_posts_sc_hot_idx',
+            'hive_posts_sc_trend_id_idx',
+            'hive_posts_sc_hot_id_idx',
             'hive_posts_block_num_idx',
 
             'hive_votes_post_id_idx',
@@ -117,6 +117,7 @@ class DbState:
             'hive_votes_last_update_idx',
 
             'hive_subscriptions_block_num_idx',
+            'hive_subscriptions_community_idx',
             'hive_communities_block_num_idx',
             'hive_reblogs_created_at_idx',
 
@@ -139,6 +140,15 @@ class DbState:
         assert not to_locate, "indexes not located: {}".format(to_locate)
         return to_return
 
+    @classmethod
+    def has_index(cls, idx_name):
+        sql = "SELECT count(*) FROM pg_class WHERE relname = :relname"
+        count = cls.db().query_one(sql, relname=idx_name)
+        if count == 1:
+            return True
+        else:
+            return False
+
     @classmethod
     def processing_indexes(cls, is_pre_process, drop, create ):
       DB = cls.db()
@@ -149,15 +159,21 @@ class DbState:
           log.info("%s index %s.%s", ( "Drop" if is_pre_process else "Recreate" ), index.table, index.name)
           try:
             if drop:
-              sql = "SELECT count(*) FROM pg_class WHERE relname = :relname"
-              _count = DB.query_one(sql, relname=index.name)
-              if _count == 1:
+              if cls.has_index(index.name):
+                time_start = perf_counter()
                 index.drop(engine)
+                end_time = perf_counter()
+                elapsed_time = end_time - time_start
+                log.info("Index {} dropped in time {} s".format(index.name, elapsed_time))
           except sqlalchemy.exc.ProgrammingError as ex:
               log.warning("Ignoring ex: {}".format(ex))
 
-          if create:
+          if create and cls.has_index(index.name) == False:
+            time_start = perf_counter()
             index.create(engine)
+            end_time = perf_counter()
+            elapsed_time = end_time - time_start
+            log.info("Index {} created in time {} s".format(index.name, elapsed_time))
 
     @classmethod
     def before_initial_sync(cls, last_imported_block, hived_head_block):
@@ -215,8 +231,12 @@ class DbState:
 
         synced_blocks = current_imported_block - last_imported_block
 
+        force_index_rebuild = False
+        if synced_blocks >= SYNCED_BLOCK_LIMIT:
+            force_index_rebuild = True
+
         #is_pre_process, drop, create
-        cls.processing_indexes( False, True, True )
+        cls.processing_indexes( False, force_index_rebuild, True )
 
         current_work_mem = cls.update_work_mem('2GB')
 

hive/db/schema.py

@@ -143,8 +143,8 @@ def build_metadata():
         sa.Index('hive_posts_payout_at_idx', 'payout_at'),
         sa.Index('hive_posts_payout_idx', 'payout'),
         sa.Index('hive_posts_promoted_idx', 'promoted'),
-        sa.Index('hive_posts_sc_trend_idx', 'sc_trend'),
-        sa.Index('hive_posts_sc_hot_idx', 'sc_hot'),
+        sa.Index('hive_posts_sc_trend_id_idx', 'sc_trend', 'id'),
+        sa.Index('hive_posts_sc_hot_id_idx', 'sc_hot', 'id'),
         sa.Index('hive_posts_created_at_idx', 'created_at'),
         sa.Index('hive_posts_block_num_idx', 'block_num')
     )
@@ -379,7 +379,7 @@ def build_metadata_community(metadata=None):
         sa.Column('block_num', sa.Integer,  nullable=False ),
 
         sa.UniqueConstraint('account_id', 'community_id', name='hive_subscriptions_ux1'),
-        sa.Index('hive_subscriptions_ix1', 'community_id', 'account_id', 'created_at'),
+        sa.Index('hive_subscriptions_community_idx', 'community_id'),
         sa.Index('hive_subscriptions_block_num_idx', 'block_num')
     )
 
@@ -872,9 +872,10 @@ def setup(db):
 
           CREATE OR REPLACE FUNCTION public.update_hive_posts_children_count(in _first_block INTEGER, in _last_block INTEGER)
               RETURNS void
-              LANGUAGE SQL
+              LANGUAGE 'plpgsql'
               VOLATILE
           AS $BODY$
+          BEGIN
           UPDATE hive_posts uhp
           SET children = data_source.children_count
           FROM
@@ -900,6 +901,7 @@ def setup(db):
           ) data_source
           WHERE uhp.id = data_source.queried_parent
           ;
+          END
           $BODY$;
           """
     db.query_no_return(sql)
@@ -1156,9 +1158,9 @@ def setup(db):
               hive_posts_view hp
           INNER JOIN
           (
-              SELECT 
+              SELECT
                   hp1.id
-              FROM 
+              FROM
                   hive_posts hp1
               WHERE
                   hp1.counter_deleted = 0
@@ -1257,13 +1259,13 @@ def setup(db):
             hp.max_accepted_payout, hp.percent_hbd, hp.allow_replies, hp.allow_votes,
             hp.allow_curation_rewards, hp.beneficiaries, hp.url, hp.root_title, hp.abs_rshares,
             hp.active, hp.author_rewards
-          FROM 
+          FROM
             hive_posts_view hp
           INNER JOIN
           (
-            SELECT 
+            SELECT
               hp2.id
-            FROM 
+            FROM
               hive_posts hp2
             WHERE
               hp2.counter_deleted = 0
@@ -1424,7 +1426,7 @@ def setup(db):
               hive_posts_view hp
           INNER JOIN
           (
-            SELECT 
+            SELECT
               hp1.id
             FROM
               hive_posts hp1
@@ -2016,182 +2018,22 @@ def setup(db):
     db.query_no_return(sql)
 
     sql = """
-        DROP TYPE IF EXISTS bridge_api_post CASCADE;
-        CREATE TYPE bridge_api_post AS (
-            id INTEGER,
-            author VARCHAR,
-            parent_author VARCHAR,
-            author_rep FLOAT4,
-            root_title VARCHAR,
-            beneficiaries JSON,
-            max_accepted_payout VARCHAR,
-            percent_hbd INTEGER,
-            url TEXT,
-            permlink VARCHAR,
-            parent_permlink_or_category VARCHAR,
-            title VARCHAR,
-            body TEXT,
-            category VARCHAR,
-            depth SMALLINT,
-            promoted DECIMAL(10,3),
-            payout DECIMAL(10,3),
-            pending_payout DECIMAL(10,3),
-            payout_at TIMESTAMP,
-            is_paidout BOOLEAN,
-            children INTEGER,
-            votes INTEGER,
-            created_at TIMESTAMP,
-            updated_at TIMESTAMP,
-            rshares NUMERIC,
-            abs_rshares NUMERIC,
-            json TEXT,
-            is_hidden BOOLEAN,
-            is_grayed BOOLEAN,
-            total_votes BIGINT,
-            sc_trend FLOAT4,
-            role_title VARCHAR,
-            community_title VARCHAR,
-            role_id SMALLINT,
-            is_pinned BOOLEAN,
-            curator_payout_value VARCHAR
-        );
-    """
-    db.query_no_return(sql)
-
-    sql = """
-        DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_trends;
-        CREATE FUNCTION bridge_get_ranked_post_by_trends( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
-        RETURNS SETOF bridge_api_post
-        AS
-        $function$
-        DECLARE
-        	__post_id INTEGER = -1;
-        	__trending_limit FLOAT = -1.0;
-        BEGIN
-            IF _author <> '' THEN
-                __post_id = find_comment_id( _author, _permlink, True );
-                SELECT hp.sc_trend INTO __trending_limit FROM hive_posts hp WHERE hp.id = __post_id;
-            END IF;
-            RETURN QUERY SELECT
-            hp.id,
-            hp.author,
-            hp.parent_author,
-            hp.author_rep,
-            hp.root_title,
-            hp.beneficiaries,
-            hp.max_accepted_payout,
-            hp.percent_hbd,
-            hp.url,
-            hp.permlink,
-            hp.parent_permlink_or_category,
-            hp.title,
-            hp.body,
-            hp.category,
-            hp.depth,
-            hp.promoted,
-            hp.payout,
-            hp.pending_payout,
-            hp.payout_at,
-            hp.is_paidout,
-            hp.children,
-            hp.votes,
-            hp.created_at,
-            hp.updated_at,
-            hp.rshares,
-            hp.abs_rshares,
-            hp.json,
-            hp.is_hidden,
-            hp.is_grayed,
-            hp.total_votes,
-            hp.sc_trend,
-            hp.role_title,
-            hp.community_title,
-            hp.role_id,
-            hp.is_pinned,
-            hp.curator_payout_value
-        FROM
+        DROP TYPE IF EXISTS notification
+        ;
+        CREATE TYPE notification AS
         (
-        SELECT
-            hp1.id
-          , hp1.sc_trend as trend
-        FROM
-            hive_posts hp1
-        WHERE NOT hp1.is_paidout AND hp1.depth = 0
-            AND ( __post_id = -1 OR hp1.sc_trend < __trending_limit OR ( hp1.sc_trend = __trending_limit AND hp1.id < __post_id  ) )
-        ORDER BY hp1.sc_trend DESC
-        LIMIT _limit
-        ) as trends
-        JOIN hive_posts_view hp ON hp.id = trends.id
-        ORDER BY trends.trend DESC, trends.id LIMIT _limit;
-        END
-        $function$
-        language plpgsql STABLE
-    """
-    db.query_no_return(sql)
-
-    sql = """
-        DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_created;
-        CREATE FUNCTION bridge_get_ranked_post_by_created( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
-        RETURNS SETOF bridge_api_post
-        AS
-        $function$
-        DECLARE
-          __post_id INTEGER = -1;
-        BEGIN
-          IF _author <> '' THEN
-              __post_id = find_comment_id( _author, _permlink, True );
-          END IF;
-          RETURN QUERY SELECT
-              hp.id,
-              hp.author,
-              hp.parent_author,
-              hp.author_rep,
-              hp.root_title,
-              hp.beneficiaries,
-              hp.max_accepted_payout,
-              hp.percent_hbd,
-              hp.url,
-              hp.permlink,
-              hp.parent_permlink_or_category,
-              hp.title,
-              hp.body,
-              hp.category,
-              hp.depth,
-              hp.promoted,
-              hp.payout,
-              hp.pending_payout,
-              hp.payout_at,
-              hp.is_paidout,
-              hp.children,
-              hp.votes,
-              hp.created_at,
-              hp.updated_at,
-              hp.rshares,
-              hp.abs_rshares,
-              hp.json,
-              hp.is_hidden,
-              hp.is_grayed,
-              hp.total_votes,
-              hp.sc_trend,
-              hp.role_title,
-              hp.community_title,
-              hp.role_id,
-              hp.is_pinned,
-              hp.curator_payout_value
-        	FROM
-          (
-              SELECT
-                hp1.id
-              , hp1.created_at as created_at
-              FROM hive_posts hp1 WHERE hp1.depth = 0 AND NOT hp1.is_grayed AND ( __post_id = -1 OR hp1.id < __post_id  )
-              ORDER BY hp1.id DESC
-              LIMIT _limit
-          ) as created
-          JOIN hive_posts_view hp ON hp.id = created.id
-          ORDER BY created.created_at DESC, created.id LIMIT _limit;
-          END
-          $function$
-          language plpgsql STABLE
+          id BIGINT
+        , type_id SMALLINT
+        , created_at TIMESTAMP
+        , src VARCHAR
+        , dst VARCHAR
+        , author VARCHAR
+        , permlink VARCHAR
+        , community VARCHAR
+        , community_title VARCHAR
+        , payload VARCHAR
+        , score SMALLINT
+        );
     """
     db.query_no_return(sql)
 
@@ -2391,7 +2233,13 @@ def setup(db):
       "update_feed_cache.sql",
       "get_account_post_replies.sql",
       "payout_stats_view.sql",
-      "update_hive_posts_mentions.sql"
+      "update_hive_posts_mentions.sql",
+      "find_tag_id.sql",
+      "bridge_get_ranked_post_type.sql",
+      "bridge_get_ranked_post_for_communities.sql",
+      "bridge_get_ranked_post_for_observer_communities.sql",
+      "bridge_get_ranked_post_for_tag.sql",
+      "bridge_get_ranked_post_for_all.sql"
     ]
     from os.path import dirname, realpath
     dir_path = dirname(realpath(__file__))

hive/db/sql_scripts/bridge_get_ranked_post_for_all.sql

+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_created;
+CREATE FUNCTION bridge_get_ranked_post_by_created( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+BEGIN
+  IF _author <> '' THEN
+      __post_id = find_comment_id( _author, _permlink, True );
+  END IF;
+  RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+      SELECT
+        hp1.id
+      FROM hive_posts hp1 WHERE hp1.depth = 0 AND NOT hp1.is_grayed AND ( __post_id = -1 OR hp1.id < __post_id  )
+      ORDER BY hp1.id DESC
+      LIMIT _limit
+  ) as created
+  JOIN hive_posts_view hp ON hp.id = created.id
+  ORDER BY created.id DESC LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_hot;
+  CREATE FUNCTION bridge_get_ranked_post_by_hot( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __hot_limit FLOAT = -1.0;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.sc_hot INTO __hot_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.sc_hot as hot
+  FROM
+      hive_posts hp1
+  WHERE NOT hp1.is_paidout AND hp1.depth = 0
+      AND ( __post_id = -1 OR hp1.sc_hot < __hot_limit OR ( hp1.sc_hot = __hot_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.sc_hot DESC
+  LIMIT _limit
+  ) as hot
+  JOIN hive_posts_view hp ON hp.id = hot.id
+  ORDER BY hot.hot DESC, hot.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_muted;
+  CREATE FUNCTION bridge_get_ranked_post_by_muted( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+      hive_posts hp1
+  WHERE NOT hp1.is_paidout AND hp1.is_grayed AND hp1.payout > 0
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_comments;
+  CREATE FUNCTION bridge_get_ranked_post_by_payout_comments( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+      hive_posts hp1
+  WHERE NOT hp1.is_paidout AND hp1.depth > 0
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout;
+  CREATE FUNCTION bridge_get_ranked_post_by_payout( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+      hive_posts hp1
+  WHERE NOT hp1.is_paidout AND hp1.payout_at BETWEEN __head_block_time + interval '12 hours' AND __head_block_time + interval '36 hours'
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_promoted;
+  CREATE FUNCTION bridge_get_ranked_post_by_promoted( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __promoted_limit hive_posts.promoted%TYPE = -1.0;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.promoted INTO __promoted_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.promoted as promoted
+  FROM
+      hive_posts hp1
+  WHERE NOT hp1.is_paidout AND hp1.depth > 0 AND hp1.promoted > 0
+      AND ( __post_id = -1 OR hp1.promoted < __promoted_limit OR ( hp1.promoted = __promoted_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.promoted DESC
+  LIMIT _limit
+  ) as promoted
+  JOIN hive_posts_view hp ON hp.id = promoted.id
+  ORDER BY promoted.promoted DESC, promoted.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_trends;
+  CREATE FUNCTION bridge_get_ranked_post_by_trends( in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __trending_limit FLOAT = -1.0;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.sc_trend INTO __trending_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.sc_trend as trend
+  FROM
+      hive_posts hp1
+  WHERE NOT hp1.is_paidout AND hp1.depth = 0
+      AND ( __post_id = -1 OR hp1.sc_trend < __trending_limit OR ( hp1.sc_trend = __trending_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.sc_trend DESC, hp1.id DESC
+  LIMIT _limit
+  ) as trends
+  JOIN hive_posts_view hp ON hp.id = trends.id
+  ORDER BY trends.trend DESC, trends.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;

hive/db/sql_scripts/bridge_get_ranked_post_for_communities.sql

+DROP FUNCTION IF EXISTS bridge_get_ranked_post_pinned_for_community;
+CREATE FUNCTION bridge_get_ranked_post_pinned_for_community( in _community VARCHAR )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+  SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+    hive_posts_view hp
+    JOIN hive_communities hc ON hc.id = hp.community_id
+    WHERE hc.name = _community AND hp.is_pinned
+  ORDER BY hp.id DESC;
+  $function$
+  language sql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_trends_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_trends_for_community( in _community VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __trending_limit FLOAT = -1.0;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.sc_trend INTO __trending_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.sc_trend as trend
+  FROM
+    hive_posts hp1
+    JOIN hive_communities hc ON hp1.community_id = hc.id
+  WHERE hc.name = _community AND NOT hp1.is_paidout AND hp1.depth = 0
+      AND ( __post_id = -1 OR hp1.sc_trend < __trending_limit OR ( hp1.sc_trend = __trending_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.sc_trend DESC, hp1.id DESC
+  LIMIT _limit
+  ) as trends
+  JOIN hive_posts_view hp ON hp.id = trends.id
+  ORDER BY trends.trend DESC, trends.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_promoted_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_promoted_for_community( in _community VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __promoted_limit hive_posts.promoted%TYPE = -1.0;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.promoted INTO __promoted_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.promoted as promoted
+  FROM
+    hive_posts hp1
+    JOIN hive_communities hc ON hp1.community_id = hc.id
+  WHERE hc.name = _community AND NOT hp1.is_paidout AND hp1.depth > 0 AND hp1.promoted > 0
+      AND ( __post_id = -1 OR hp1.promoted < __promoted_limit OR ( hp1.promoted = __promoted_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.promoted DESC
+  LIMIT _limit
+  ) as promoted
+  JOIN hive_posts_view hp ON hp.id = promoted.id
+  ORDER BY promoted.promoted DESC, promoted.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_payout_for_community(in _community VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      RAISE NOTICE 'post_id=%',__post_id;
+      RAISE NOTICE 'payout_limit=%',__payout_limit;
+      RAISE NOTICE 'time=%',__head_block_time;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+    hive_posts hp1
+    JOIN hive_communities hc ON hp1.community_id = hc.id
+  WHERE hc.name = _community AND NOT hp1.is_paidout AND hp1.payout_at BETWEEN __head_block_time + interval '12 hours' AND __head_block_time + interval '36 hours'
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC, hp1.id DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id DESC LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_comments_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_payout_comments_for_community( in _community VARCHAR,  in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+    hive_posts hp1
+    JOIN hive_communities hc ON hp1.community_id = hc.id
+  WHERE hc.name = _community AND NOT hp1.is_paidout AND hp1.depth > 0
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC, hp1.id DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id DESC LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_muted_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_muted_for_community( in _community VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+    hive_posts hp1
+    JOIN hive_communities hc ON hp1.community_id = hc.id
+  WHERE hc.name = _community AND NOT hp1.is_paidout AND hp1.is_grayed AND hp1.payout > 0
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_hot_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_hot_for_community( in _community VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __hot_limit FLOAT = -1.0;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.sc_hot INTO __hot_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.sc_hot as hot
+  FROM
+      hive_posts hp1
+      JOIN hive_communities hc ON hp1.community_id = hc.id
+  WHERE hc.name = _community AND NOT hp1.is_paidout AND hp1.depth = 0
+      AND ( __post_id = -1 OR hp1.sc_hot < __hot_limit OR ( hp1.sc_hot = __hot_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.sc_hot DESC, hp1.id DESC
+  LIMIT _limit
+  ) as hot
+  JOIN hive_posts_view hp ON hp.id = hot.id
+  ORDER BY hot.hot DESC, hot.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_created_for_community;
+  CREATE FUNCTION bridge_get_ranked_post_by_created_for_community( in _community VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+  BEGIN
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+    END IF;
+    RETURN QUERY SELECT
+        hp.id,
+        hp.author,
+        hp.parent_author,
+        hp.author_rep,
+        hp.root_title,
+        hp.beneficiaries,
+        hp.max_accepted_payout,
+        hp.percent_hbd,
+        hp.url,
+        hp.permlink,
+        hp.parent_permlink_or_category,
+        hp.title,
+        hp.body,
+        hp.category,
+        hp.depth,
+        hp.promoted,
+        hp.payout,
+        hp.pending_payout,
+        hp.payout_at,
+        hp.is_paidout,
+        hp.children,
+        hp.votes,
+        hp.created_at,
+        hp.updated_at,
+        hp.rshares,
+        hp.abs_rshares,
+        hp.json,
+        hp.is_hidden,
+        hp.is_grayed,
+        hp.total_votes,
+        hp.sc_trend,
+        hp.role_title,
+        hp.community_title,
+        hp.role_id,
+        hp.is_pinned,
+        hp.curator_payout_value
+    FROM
+    (
+        SELECT
+          hp1.id
+        , hp1.created_at as created_at
+        FROM
+          hive_posts hp1
+          JOIN hive_communities hc ON hp1.community_id = hc.id
+        WHERE hc.name = _community AND hp1.depth = 0 AND NOT hp1.is_grayed AND ( __post_id = -1 OR hp1.id < __post_id  )
+        ORDER BY hp1.id DESC
+        LIMIT _limit
+    ) as created
+    JOIN hive_posts_view hp ON hp.id = created.id
+    ORDER BY created.created_at DESC, created.id LIMIT _limit;
+    END
+    $function$
+    language plpgsql STABLE;

hive/db/sql_scripts/bridge_get_ranked_post_for_observer_communities.sql

+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_created_for_observer_communities;
+CREATE FUNCTION bridge_get_ranked_post_by_created_for_observer_communities( in _observer VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __enable_sort BOOLEAN;
+BEGIN
+  SHOW enable_sort INTO __enable_sort;
+  IF _author <> '' THEN
+      __post_id = find_comment_id( _author, _permlink, True );
+  END IF;
+  SET enable_sort=false;
+  RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+FROM
+   hive_posts_view hp
+   JOIN hive_subscriptions hs ON hp.community_id = hs.community_id
+   JOIN hive_accounts ha ON ha.id = hs.account_id
+WHERE ha.name = _observer AND  hp.depth = 0 AND NOT hp.is_grayed AND ( __post_id = -1 OR hp.id < __post_id  )
+ORDER BY hp.id DESC LIMIT _limit;
+IF __enable_sort THEN
+	SET enable_sort=true;
+ELSE
+	SET enable_sort=false;
+END IF;
+END
+$function$
+language plpgsql VOLATILE;
+
+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_hot_for_observer_communities;
+CREATE FUNCTION bridge_get_ranked_post_by_hot_for_observer_communities( in _observer VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __hot_limit FLOAT;
+  __enable_sort BOOLEAN;
+BEGIN
+    SHOW enable_sort INTO __enable_sort;
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+        SELECT hp.sc_hot INTO __hot_limit FROM hive_posts hp WHERE hp.id = __post_id;
+    END IF;
+    SET enable_sort=false;
+    RETURN QUERY SELECT
+    hp.id,
+    hp.author,
+    hp.parent_author,
+    hp.author_rep,
+    hp.root_title,
+    hp.beneficiaries,
+    hp.max_accepted_payout,
+    hp.percent_hbd,
+    hp.url,
+    hp.permlink,
+    hp.parent_permlink_or_category,
+    hp.title,
+    hp.body,
+    hp.category,
+    hp.depth,
+    hp.promoted,
+    hp.payout,
+    hp.pending_payout,
+    hp.payout_at,
+    hp.is_paidout,
+    hp.children,
+    hp.votes,
+    hp.created_at,
+    hp.updated_at,
+    hp.rshares,
+    hp.abs_rshares,
+    hp.json,
+    hp.is_hidden,
+    hp.is_grayed,
+    hp.total_votes,
+    hp.sc_trend,
+    hp.role_title,
+    hp.community_title,
+    hp.role_id,
+    hp.is_pinned,
+    hp.curator_payout_value
+  FROM
+     hive_posts_view hp
+     JOIN hive_subscriptions hs ON hp.community_id = hs.community_id
+     JOIN hive_accounts ha ON ha.id = hs.account_id
+  WHERE ha.name = _observer AND NOT hp.is_paidout AND hp.depth = 0
+  AND ( __post_id = -1 OR hp.sc_hot < __hot_limit OR ( hp.sc_hot = __hot_limit AND hp.id < __post_id  ) )
+  ORDER BY hp.sc_hot DESC, hp.id DESC
+  LIMIT _limit;
+  IF __enable_sort THEN
+  	SET enable_sort=true;
+  ELSE
+  	SET enable_sort=false;
+  END IF;
+END
+$function$
+language plpgsql VOLATILE;
+
+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_hot_for_observer_communities;
+CREATE FUNCTION bridge_get_ranked_post_by_hot_for_observer_communities( in _observer VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __hot_limit FLOAT;
+  __enable_sort BOOLEAN;
+BEGIN
+    SHOW enable_sort INTO __enable_sort;
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+        SELECT hp.sc_hot INTO __hot_limit FROM hive_posts hp WHERE hp.id = __post_id;
+    END IF;
+    SET enable_sort=false;
+    RETURN QUERY SELECT
+    hp.id,
+    hp.author,
+    hp.parent_author,
+    hp.author_rep,
+    hp.root_title,
+    hp.beneficiaries,
+    hp.max_accepted_payout,
+    hp.percent_hbd,
+    hp.url,
+    hp.permlink,
+    hp.parent_permlink_or_category,
+    hp.title,
+    hp.body,
+    hp.category,
+    hp.depth,
+    hp.promoted,
+    hp.payout,
+    hp.pending_payout,
+    hp.payout_at,
+    hp.is_paidout,
+    hp.children,
+    hp.votes,
+    hp.created_at,
+    hp.updated_at,
+    hp.rshares,
+    hp.abs_rshares,
+    hp.json,
+    hp.is_hidden,
+    hp.is_grayed,
+    hp.total_votes,
+    hp.sc_trend,
+    hp.role_title,
+    hp.community_title,
+    hp.role_id,
+    hp.is_pinned,
+    hp.curator_payout_value
+  FROM
+     hive_posts_view hp
+     JOIN hive_subscriptions hs ON hp.community_id = hs.community_id
+     JOIN hive_accounts ha ON ha.id = hs.account_id
+  WHERE ha.name = _observer AND NOT hp.is_paidout AND hp.depth = 0
+  AND ( __post_id = -1 OR hp.sc_hot < __hot_limit OR ( hp.sc_hot = __hot_limit AND hp.id < __post_id  ) )
+  ORDER BY hp.sc_hot DESC
+  LIMIT _limit;
+  IF __enable_sort THEN
+  	SET enable_sort=true;
+  ELSE
+  	SET enable_sort=false;
+  END IF;
+END
+$function$
+language plpgsql VOLATILE;
+
+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_comments_for_observer_communities;
+CREATE FUNCTION bridge_get_ranked_post_by_payout_comments_for_observer_communities( in _observer VARCHAR,  in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __payout_limit hive_posts.payout%TYPE;
+  __head_block_time TIMESTAMP;
+  __enable_sort BOOLEAN;
+BEGIN
+    SHOW enable_sort INTO __enable_sort;
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+        SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+    END IF;
+    SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+    SET enable_sort=false;
+    RETURN QUERY SELECT
+    hp.id,
+    hp.author,
+    hp.parent_author,
+    hp.author_rep,
+    hp.root_title,
+    hp.beneficiaries,
+    hp.max_accepted_payout,
+    hp.percent_hbd,
+    hp.url,
+    hp.permlink,
+    hp.parent_permlink_or_category,
+    hp.title,
+    hp.body,
+    hp.category,
+    hp.depth,
+    hp.promoted,
+    hp.payout,
+    hp.pending_payout,
+    hp.payout_at,
+    hp.is_paidout,
+    hp.children,
+    hp.votes,
+    hp.created_at,
+    hp.updated_at,
+    hp.rshares,
+    hp.abs_rshares,
+    hp.json,
+    hp.is_hidden,
+    hp.is_grayed,
+    hp.total_votes,
+    hp.sc_trend,
+    hp.role_title,
+    hp.community_title,
+    hp.role_id,
+    hp.is_pinned,
+    hp.curator_payout_value
+FROM
+	(
+	SELECT
+	    hp1.id
+	  , hp1.payout as payout
+	FROM
+	  hive_posts hp1
+	  JOIN hive_subscriptions hs ON hp1.community_id = hs.community_id
+	  JOIN hive_accounts ha ON ha.id = hs.account_id
+	WHERE ha.name = _observer AND NOT hp1.is_paidout AND hp1.depth > 0
+     AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+	ORDER BY hp1.payout DESC, hp1.id DESC
+	LIMIT _limit
+) as payout
+JOIN hive_posts_view hp ON hp.id = payout.id
+ORDER BY payout.payout DESC, payout.id DESC LIMIT _limit;
+IF __enable_sort THEN
+	SET enable_sort=true;
+ELSE
+	SET enable_sort=false;
+END IF;
+END
+$function$
+language plpgsql VOLATILE;
+
+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_for_observer_communities;
+CREATE FUNCTION bridge_get_ranked_post_by_payout_for_observer_communities( in _observer VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __payout_limit hive_posts.payout%TYPE;
+  __head_block_time TIMESTAMP;
+  __enable_sort BOOLEAN;
+BEGIN
+    SHOW enable_sort INTO __enable_sort;
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+        SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+    END IF;
+    SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+    SET enable_sort=false;
+    RETURN QUERY SELECT
+    hp.id,
+    hp.author,
+    hp.parent_author,
+    hp.author_rep,
+    hp.root_title,
+    hp.beneficiaries,
+    hp.max_accepted_payout,
+    hp.percent_hbd,
+    hp.url,
+    hp.permlink,
+    hp.parent_permlink_or_category,
+    hp.title,
+    hp.body,
+    hp.category,
+    hp.depth,
+    hp.promoted,
+    hp.payout,
+    hp.pending_payout,
+    hp.payout_at,
+    hp.is_paidout,
+    hp.children,
+    hp.votes,
+    hp.created_at,
+    hp.updated_at,
+    hp.rshares,
+    hp.abs_rshares,
+    hp.json,
+    hp.is_hidden,
+    hp.is_grayed,
+    hp.total_votes,
+    hp.sc_trend,
+    hp.role_title,
+    hp.community_title,
+    hp.role_id,
+    hp.is_pinned,
+    hp.curator_payout_value
+FROM
+   hive_posts_view hp
+   JOIN hive_subscriptions hs ON hp.community_id = hs.community_id
+   JOIN hive_accounts ha ON ha.id = hs.account_id
+WHERE ha.name = _observer AND NOT hp.is_paidout AND hp.payout_at BETWEEN __head_block_time + interval '12 hours' AND __head_block_time + interval '36 hours'
+AND ( __post_id = -1 OR hp.payout < __payout_limit OR ( hp.payout = __payout_limit AND hp.id < __post_id  ) )
+ORDER BY hp.payout DESC, hp.id DESC;
+IF __enable_sort THEN
+	SET enable_sort=true;
+ELSE
+	SET enable_sort=false;
+END IF;
+END
+$function$
+language plpgsql VOLATILE;
+
+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_promoted_for_observer_communities;
+CREATE FUNCTION bridge_get_ranked_post_by_promoted_for_observer_communities( in _observer VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __promoted_limit hive_posts.promoted%TYPE;
+  __enable_sort BOOLEAN;
+BEGIN
+    SHOW enable_sort INTO __enable_sort;
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+        SELECT hp.promoted INTO __promoted_limit FROM hive_posts hp WHERE hp.id = __post_id;
+    END IF;
+    SET enable_sort=false;
+    RETURN QUERY SELECT
+    hp.id,
+    hp.author,
+    hp.parent_author,
+    hp.author_rep,
+    hp.root_title,
+    hp.beneficiaries,
+    hp.max_accepted_payout,
+    hp.percent_hbd,
+    hp.url,
+    hp.permlink,
+    hp.parent_permlink_or_category,
+    hp.title,
+    hp.body,
+    hp.category,
+    hp.depth,
+    hp.promoted,
+    hp.payout,
+    hp.pending_payout,
+    hp.payout_at,
+    hp.is_paidout,
+    hp.children,
+    hp.votes,
+    hp.created_at,
+    hp.updated_at,
+    hp.rshares,
+    hp.abs_rshares,
+    hp.json,
+    hp.is_hidden,
+    hp.is_grayed,
+    hp.total_votes,
+    hp.sc_trend,
+    hp.role_title,
+    hp.community_title,
+    hp.role_id,
+    hp.is_pinned,
+    hp.curator_payout_value
+FROM
+   hive_posts_view hp
+   JOIN hive_subscriptions hs ON hp.community_id = hs.community_id
+   JOIN hive_accounts ha ON ha.id = hs.account_id
+WHERE ha.name = _observer AND NOT hp.is_paidout AND hp.depth > 0 AND hp.promoted > 0
+    AND ( __post_id = -1 OR hp.promoted < __promoted_limit OR ( hp.promoted = __promoted_limit AND hp.id < __post_id  ) )
+ORDER BY hp.promoted DESC
+LIMIT _limit;
+IF __enable_sort THEN
+	SET enable_sort=true;
+ELSE
+	SET enable_sort=false;
+END IF;
+END
+$function$
+language plpgsql VOLATILE;
+
+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_trends_for_observer_community;
+CREATE FUNCTION bridge_get_ranked_post_by_trends_for_observer_community( in _observer VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __trending_limit FLOAT;
+  __enable_sort BOOLEAN;
+BEGIN
+    SHOW enable_sort INTO __enable_sort;
+    IF _author <> '' THEN
+        __post_id = find_comment_id( _author, _permlink, True );
+        SELECT hp.sc_trend INTO __trending_limit FROM hive_posts hp WHERE hp.id = __post_id;
+    END IF;
+    SET enable_sort=false;
+    RETURN QUERY SELECT
+    hp.id,
+    hp.author,
+    hp.parent_author,
+    hp.author_rep,
+    hp.root_title,
+    hp.beneficiaries,
+    hp.max_accepted_payout,
+    hp.percent_hbd,
+    hp.url,
+    hp.permlink,
+    hp.parent_permlink_or_category,
+    hp.title,
+    hp.body,
+    hp.category,
+    hp.depth,
+    hp.promoted,
+    hp.payout,
+    hp.pending_payout,
+    hp.payout_at,
+    hp.is_paidout,
+    hp.children,
+    hp.votes,
+    hp.created_at,
+    hp.updated_at,
+    hp.rshares,
+    hp.abs_rshares,
+    hp.json,
+    hp.is_hidden,
+    hp.is_grayed,
+    hp.total_votes,
+    hp.sc_trend,
+    hp.role_title,
+    hp.community_title,
+    hp.role_id,
+    hp.is_pinned,
+    hp.curator_payout_value
+FROM
+   hive_posts_view hp
+   JOIN hive_subscriptions hs ON hp.community_id = hs.community_id
+   JOIN hive_accounts ha ON ha.id = hs.account_id
+WHERE ha.name = _observer AND NOT hp.is_paidout AND hp.depth = 0
+    AND ( __post_id = -1 OR hp.sc_trend < __trending_limit OR ( hp.sc_trend = __trending_limit AND hp.id < __post_id  ) )
+ORDER BY hp.sc_trend DESC, hp.id DESC
+LIMIT _limit;
+IF __enable_sort THEN
+	SET enable_sort=true;
+ELSE
+	SET enable_sort=false;
+END IF;
+END
+$function$
+language plpgsql VOLATILE;

hive/db/sql_scripts/bridge_get_ranked_post_for_tag.sql

+DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_created_for_tag;
+CREATE FUNCTION bridge_get_ranked_post_by_created_for_tag( in tag VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+RETURNS SETOF bridge_api_post
+AS
+$function$
+DECLARE
+  __post_id INTEGER = -1;
+  __hive_tag INTEGER = -1;
+BEGIN
+  IF _author <> '' THEN
+      __post_id = find_comment_id( _author, _permlink, True );
+  END IF;
+  __hive_tag = find_tag_id( tag, True );
+  RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+      SELECT
+        hp1.id
+      , hp1.created_at as created_at
+      FROM
+        hive_post_tags hpt
+        JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+      WHERE hpt.tag_id = __hive_tag AND hp1.depth = 0 AND NOT hp1.is_grayed AND ( __post_id = -1 OR hp1.id < __post_id  )
+      ORDER BY hp1.id DESC
+      LIMIT _limit
+  ) as created
+  JOIN hive_posts_view hp ON hp.id = created.id
+  ORDER BY created.created_at DESC, created.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_hot_for_tag;
+  CREATE FUNCTION bridge_get_ranked_post_by_hot_for_tag( in tag VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __hot_limit FLOAT = -1.0;
+    __hive_tag INTEGER = -1;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.sc_hot INTO __hot_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      __hive_tag = find_tag_id( tag, True );
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.sc_hot as hot
+  FROM
+  	hive_post_tags hpt
+    JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+  WHERE hpt.tag_id = __hive_tag AND NOT hp1.is_paidout AND hp1.depth = 0
+      AND ( __post_id = -1 OR hp1.sc_hot < __hot_limit OR ( hp1.sc_hot = __hot_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.sc_hot DESC, hp1.id DESC
+  LIMIT _limit
+  ) as hot
+  JOIN hive_posts_view hp ON hp.id = hot.id
+  ORDER BY hot.hot DESC, hot.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_muted_for_tag;
+  CREATE FUNCTION bridge_get_ranked_post_by_muted_for_tag( in tag VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __hive_tag INTEGER = -1;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      __hive_tag = find_tag_id( tag, True );
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+    hive_post_tags hpt
+    JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+  WHERE hpt.tag_id = __hive_tag AND NOT hp1.is_paidout AND hp1.is_grayed AND hp1.payout > 0
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_comments_for_tag;
+  CREATE FUNCTION bridge_get_ranked_post_by_payout_comments_for_tag( in tag VARCHAR,  in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+    __hive_tag INTEGER = -1;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      __hive_tag = find_tag_id( tag, True );
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+    hive_post_tags hpt
+    JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+  WHERE hpt.tag_id = __hive_tag AND NOT hp1.is_paidout AND hp1.depth > 0
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_payout_for_tag;
+  CREATE FUNCTION bridge_get_ranked_post_by_payout_for_tag( in tag VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __payout_limit hive_posts.payout%TYPE;
+    __head_block_time TIMESTAMP;
+    __hive_tag INTEGER = -1;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.payout INTO __payout_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      SELECT blck.created_at INTO __head_block_time FROM hive_blocks blck ORDER BY blck.num DESC LIMIT 1;
+      __hive_tag = find_tag_id( tag, True );
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.payout as payout
+  FROM
+    hive_post_tags hpt
+    JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+  WHERE hpt.tag_id = __hive_tag AND NOT hp1.is_paidout AND hp1.payout_at BETWEEN __head_block_time + interval '12 hours' AND __head_block_time + interval '36 hours'
+      AND ( __post_id = -1 OR hp1.payout < __payout_limit OR ( hp1.payout = __payout_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.payout DESC
+  LIMIT _limit
+  ) as payout
+  JOIN hive_posts_view hp ON hp.id = payout.id
+  ORDER BY payout.payout DESC, payout.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_promoted_for_tag;
+  CREATE FUNCTION bridge_get_ranked_post_by_promoted_for_tag( in tag VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __promoted_limit hive_posts.promoted%TYPE = -1.0;
+    __hive_tag INTEGER = -1;
+  BEGIN
+      RAISE NOTICE 'author=%',_author;
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.promoted INTO __promoted_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      __hive_tag = find_tag_id( tag, True );
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.promoted as promoted
+  FROM
+  	  hive_post_tags hpt
+      JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+  WHERE hpt.tag_id = __hive_tag AND NOT hp1.is_paidout AND hp1.depth > 0 AND hp1.promoted > 0
+      AND ( __post_id = -1 OR hp1.promoted < __promoted_limit OR ( hp1.promoted = __promoted_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.promoted DESC
+  LIMIT _limit
+  ) as promoted
+  JOIN hive_posts_view hp ON hp.id = promoted.id
+  ORDER BY promoted.promoted DESC, promoted.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;
+
+  DROP FUNCTION IF EXISTS bridge_get_ranked_post_by_trends_for_tag;
+  CREATE FUNCTION bridge_get_ranked_post_by_trends_for_tag( in tag VARCHAR, in _author VARCHAR, in _permlink VARCHAR, in _limit SMALLINT )
+  RETURNS SETOF bridge_api_post
+  AS
+  $function$
+  DECLARE
+    __post_id INTEGER = -1;
+    __trending_limit FLOAT = -1.0;
+    __hive_tag INTEGER = -1;
+  BEGIN
+      IF _author <> '' THEN
+          __post_id = find_comment_id( _author, _permlink, True );
+          SELECT hp.sc_trend INTO __trending_limit FROM hive_posts hp WHERE hp.id = __post_id;
+      END IF;
+      __hive_tag = find_tag_id( tag, True );
+      RETURN QUERY SELECT
+      hp.id,
+      hp.author,
+      hp.parent_author,
+      hp.author_rep,
+      hp.root_title,
+      hp.beneficiaries,
+      hp.max_accepted_payout,
+      hp.percent_hbd,
+      hp.url,
+      hp.permlink,
+      hp.parent_permlink_or_category,
+      hp.title,
+      hp.body,
+      hp.category,
+      hp.depth,
+      hp.promoted,
+      hp.payout,
+      hp.pending_payout,
+      hp.payout_at,
+      hp.is_paidout,
+      hp.children,
+      hp.votes,
+      hp.created_at,
+      hp.updated_at,
+      hp.rshares,
+      hp.abs_rshares,
+      hp.json,
+      hp.is_hidden,
+      hp.is_grayed,
+      hp.total_votes,
+      hp.sc_trend,
+      hp.role_title,
+      hp.community_title,
+      hp.role_id,
+      hp.is_pinned,
+      hp.curator_payout_value
+  FROM
+  (
+  SELECT
+      hp1.id
+    , hp1.sc_trend as trend
+  FROM
+    hive_post_tags hpt
+    JOIN hive_posts hp1 ON hp1.id = hpt.post_id
+  WHERE hpt.tag_id = __hive_tag AND NOT hp1.is_paidout AND hp1.depth = 0
+      AND ( __post_id = -1 OR hp1.sc_trend < __trending_limit OR ( hp1.sc_trend = __trending_limit AND hp1.id < __post_id  ) )
+  ORDER BY hp1.sc_trend DESC, hp1.id DESC
+  LIMIT _limit
+  ) as trends
+  JOIN hive_posts_view hp ON hp.id = trends.id
+  ORDER BY trends.trend DESC, trends.id LIMIT _limit;
+  END
+  $function$
+  language plpgsql STABLE;

hive/db/sql_scripts/bridge_get_ranked_post_type.sql

+DROP TYPE IF EXISTS bridge_api_post CASCADE;
+CREATE TYPE bridge_api_post AS (
+    id INTEGER,
+    author VARCHAR,
+    parent_author VARCHAR,
+    author_rep FLOAT4,
+    root_title VARCHAR,
+    beneficiaries JSON,
+    max_accepted_payout VARCHAR,
+    percent_hbd INTEGER,
+    url TEXT,
+    permlink VARCHAR,
+    parent_permlink_or_category VARCHAR,
+    title VARCHAR,
+    body TEXT,
+    category VARCHAR,
+    depth SMALLINT,
+    promoted DECIMAL(10,3),
+    payout DECIMAL(10,3),
+    pending_payout DECIMAL(10,3),
+    payout_at TIMESTAMP,
+    is_paidout BOOLEAN,
+    children INTEGER,
+    votes INTEGER,
+    created_at TIMESTAMP,
+    updated_at TIMESTAMP,
+    rshares NUMERIC,
+    abs_rshares NUMERIC,
+    json TEXT,
+    is_hidden BOOLEAN,
+    is_grayed BOOLEAN,
+    total_votes BIGINT,
+    sc_trend FLOAT4,
+    role_title VARCHAR,
+    community_title VARCHAR,
+    role_id SMALLINT,
+    is_pinned BOOLEAN,
+    curator_payout_value VARCHAR
+);

hive/db/sql_scripts/find_tag_id.sql

+DROP FUNCTION IF EXISTS public.find_tag_id CASCADE;
+CREATE OR REPLACE FUNCTION public.find_tag_id(
+	in _tag_name hive_tag_data.tag%TYPE,
+	in _check BOOLEAN
+)
+RETURNS INTEGER
+LANGUAGE 'plpgsql' STABLE
+AS
+$BODY$
+DECLARE
+	__tag_id INTEGER;
+BEGIN
+	SELECT INTO __tag_id COALESCE( ( SELECT id FROM hive_tag_data WHERE tag=_tag_name ), 0 );
+     IF _check AND __tag_id = 0 THEN
+       RAISE EXCEPTION 'Tag % does not exist', _tag_name;
+     END IF;
+     RETURN __tag_id;
+END
+$BODY$
+;

hive/server/bridge_api/methods.py

@@ -114,140 +114,194 @@ async def get_post(context, author, permlink, observer=None):
     return post
 
 @return_error_info
-async def get_ranked_posts(context, sort:str, start_author:str='', start_permlink:str='',
-                           limit:int=20, tag:str=None, observer:str=None):
-    """Query posts, sorted by given method."""
+async def _get_ranked_posts_for_observer_communities( db, sort:str, start_author:str, start_permlink:str, limit, observer:str):
+    async def execute_observer_community_query(db, sql, limit):
+        return await db.query_all(sql, observer=observer, author=start_author, permlink=start_permlink, limit=limit )
 
-    assert sort in ['trending', 'hot', 'created', 'promoted',
-                    'payout', 'payout_comments', 'muted'], 'invalid sort'
+    if not observer:
+        return []
 
-    valid_account(start_author, allow_empty=True)
-    valid_permlink(start_permlink, allow_empty=True)
-    valid_limit(limit, 100, 20)
-    valid_tag(tag, allow_empty=True)
+    if sort == 'trending':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_trends_for_observer_community( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
 
-    db = context['db']
+    if sort == 'created':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_created_for_observer_communities( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
+
+    if sort == 'hot':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_hot_for_observer_communities( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
+
+    if sort == 'promoted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_promoted_for_observer_communities( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
+
+    if sort == 'payout':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_for_observer_communities( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
 
-    if ( not observer ) and ( not tag or tag == 'all' ):
-        async def execute_query(db, sql, limit):
-            posts = []
-            sql_result = await db.query_all(sql, author=start_author, permlink=start_permlink, limit=limit )
-            for row in sql_result:
-                post = _bridge_post_object(row)
-                post['active_votes'] = await find_votes_impl(db, row['author'], row['permlink'], VotesPresentation.BridgeApi)
-                post = await append_statistics_to_post(post, row, False, None)
-                posts.append(post)
-            return posts
+    if sort == 'payout_comments':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_comments_for_observer_communities( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
 
-        if sort == 'trending':
-            sql = "SELECT * FROM bridge_get_ranked_post_by_trends( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
-            return await execute_query(db, sql, limit)
+    if sort == 'muted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_comments_for_observer_communities( (:observer)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_observer_community_query(db, sql, limit)
 
-        if sort == 'created':
-            sql = "SELECT * FROM bridge_get_ranked_post_by_created( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
-            return await execute_query(db, sql, limit)
+    assert False, "Unknown sort order"
 
-    sql = ''
-    pinned_sql = ''
+@return_error_info
+async def _get_ranked_posts_for_communities( db, sort:str, community, start_author:str, start_permlink:str, limit):
+    async def execute_community_query(db, sql, limit):
+        return await db.query_all(sql, community=community, author=start_author, permlink=start_permlink, limit=limit )
+
+    pinned_sql = "SELECT * FROM bridge_get_ranked_post_pinned_for_community( (:community)::VARCHAR )"
+    if sort == 'hot':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_hot_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_community_query(db, sql, limit)
 
     if sort == 'trending':
-        sql = SQL_TEMPLATE + """ NOT hp.is_paidout AND hp.depth = 0
-                                    %s ORDER BY hp.sc_trend DESC, hp.id LIMIT :limit """
-    elif sort == 'hot':
-        sql = SQL_TEMPLATE + """ NOT hp.is_paidout AND hp.depth = 0
-                                    %s ORDER BY hp.sc_hot DESC, hp.id LIMIT :limit """
-    elif sort == 'created':
-        sql = SQL_TEMPLATE + """ hp.depth = 0 AND NOT hp.is_grayed
-                                    %s ORDER BY hp.created_at DESC, hp.id LIMIT :limit """
-    elif sort == 'promoted':
-        sql = SQL_TEMPLATE + """ hp.depth > 0 AND hp.promoted > 0
-                                    AND NOT hp.is_paidout %s ORDER BY hp.promoted DESC, hp.id LIMIT :limit """
-    elif sort == 'payout':
-        sql = SQL_TEMPLATE + """ NOT hp.is_paidout %s
-                                    AND hp.payout_at BETWEEN now() + interval '12 hours' AND now() + interval '36 hours'
-                                    ORDER BY hp.payout DESC, hp.id LIMIT :limit """
-    elif sort == 'payout_comments':
-        sql = SQL_TEMPLATE + """ NOT hp.is_paidout AND hp.depth > 0
-                                    %s ORDER BY hp.payout DESC, hp.id LIMIT :limit """
-    elif sort == 'muted':
-        sql = SQL_TEMPLATE + """ NOT hp.is_paidout AND hp.is_grayed
-                                    AND hp.payout > 0 %s ORDER BY hp.payout DESC, hp.id LIMIT :limit """
-
-    sql = "---bridge_api.get_ranked_posts\n" + sql
+        result_with_pinned_posts = []
+        sql = "SELECT * FROM bridge_get_ranked_post_by_trends_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        result_with_pinned_posts = await execute_community_query(db, pinned_sql, limit)
+        result_with_pinned_posts += await execute_community_query(db, sql, limit)
+        return result_with_pinned_posts
 
-    if start_author and start_permlink:
-        if sort == 'trending':
-            sql = sql % """ AND hp.sc_trend <= (SELECT sc_trend FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink))
-                            AND hp.id != (SELECT id FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink)) %s """
-        elif sort == 'hot':
-            sql = sql % """ AND hp.sc_hot <= (SELECT sc_hot FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink))
-                            AND hp.id != (SELECT id FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink)) %s """
-        elif sort == 'created':
-            sql = sql % """ AND hp.id < (SELECT id FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink)) %s """
-        elif sort == 'promoted':
-            sql = sql % """ AND hp.promoted <= (SELECT promoted FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink))
-                                AND hp.id != (SELECT id FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink)) %s """
-        else:
-            sql = sql % """ AND hp.payout <= (SELECT payout FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink))
-                                AND hp.id != (SELECT id FROM hive_posts WHERE author_id = (SELECT id FROM hive_accounts WHERE name = :author) AND permlink_id = (SELECT id FROM hive_permlink_data WHERE permlink = :permlink)) %s """
-    else:
-        sql = sql % """ %s """
+    if sort == 'promoted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_promoted_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_community_query(db, sql, limit)
 
-    if not tag or tag == 'all':
-        sql = sql % """ """
-    elif tag == 'my':
-        sql = sql % """ AND hp.community_id IN (SELECT community_id FROM hive_subscriptions WHERE account_id =
-                        (SELECT id FROM hive_accounts WHERE name = :observer) ) """
-    elif tag[:5] == 'hive-':
-        if start_author and start_permlink:
-            sql = sql % """ AND hp.community_id = (SELECT hive_communities.id FROM hive_communities WHERE name = :community_name ) """
-        else:
-            sql = sql % """ AND hp.community_name = :community_name """
+    if sort == 'created':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_created_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        result_with_pinned_posts = await execute_community_query(db, pinned_sql, limit)
+        result_with_pinned_posts += await execute_community_query(db, sql, limit)
+        return result_with_pinned_posts
 
-        if sort == 'trending' or sort == 'created':
-            pinned_sql = SQL_TEMPLATE + """ hp.is_pinned AND hp.community_name = :community_name ORDER BY hp.created_at DESC """
+    if sort == 'muted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_muted_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_community_query(db, sql, limit)
 
-    else:
-        if sort in ['payout', 'payout_comments']:
-            sql = sql % """ AND hp.category = :tag """
-        else:
-            sql = sql % """ AND EXISTS
-                (SELECT NULL
-                    FROM hive_post_tags hpt
-                    INNER JOIN hive_tag_data htd ON hpt.tag_id=htd.id
-                    WHERE hp.id = hpt.post_id AND htd.tag = :tag
-                ) """
+    if sort == 'payout':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_community_query(db, sql, limit)
 
-    if not observer:
-        observer = ''
+    if sort == 'payout_comments':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_comments_for_community( (:community)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_community_query(db, sql, limit)
 
-    posts = []
-    pinned_post_ids = []
+    assert False, "Unknown sort order"
 
-    blacklists_for_user = None
 
-    if observer and context:
-        blacklists_for_user = await Mutes.get_blacklists_for_observer(observer, context)
+@return_error_info
+async def _get_ranked_posts_for_tag( db, sort:str, tag, start_author:str, start_permlink:str, limit):
+    async def execute_tags_query(db, sql, limit):
+        return await db.query_all(sql, tag=tag, author=start_author, permlink=start_permlink, limit=limit )
+
+    if sort == 'hot':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_hot_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
+
+    if sort == 'promoted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_promoted_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
+
+    if sort == 'payout':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
+
+    if sort == 'payout_comments':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_comments_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
+
+    if sort == 'muted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_muted_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
+
+    if sort == 'trending':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_trends_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
+
+    if sort == 'created':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_created_for_tag( (:tag)::VARCHAR, (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_tags_query(db, sql, limit)
 
-    if pinned_sql:
-        pinned_result = await db.query_all(pinned_sql, author=start_author, limit=limit, tag=tag, permlink=start_permlink, community_name=tag, observer=observer)
-        for row in pinned_result:
+    assert False, "Unknown sort order"
+
+@return_error_info
+async def _get_ranked_posts_for_all( db, sort:str, start_author:str, start_permlink:str, limit):
+    async def execute_query(db, sql, limit):
+        return await db.query_all(sql, author=start_author, permlink=start_permlink, limit=limit )
+
+    if sort == 'trending':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_trends( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    if sort == 'created':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_created( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    if sort == 'hot':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_hot( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    if sort == 'promoted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_promoted( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    if sort == 'payout':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    if sort == 'payout_comments':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_payout_comments( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    if sort == 'muted':
+        sql = "SELECT * FROM bridge_get_ranked_post_by_muted( (:author)::VARCHAR, (:permlink)::VARCHAR, (:limit)::SMALLINT )"
+        return await execute_query(db, sql, limit)
+
+    assert False, "Unknown sort order"
+
+@return_error_info
+async def get_ranked_posts(context, sort:str, start_author:str='', start_permlink:str='',
+                           limit:int=20, tag:str=None, observer:str=None):
+    """Query posts, sorted by given method."""
+
+    assert sort in ['trending', 'hot', 'created', 'promoted',
+                    'payout', 'payout_comments', 'muted'], 'invalid sort'
+
+    async def process_query_results( sql_result ):
+        posts = []
+        for row in sql_result:
             post = _bridge_post_object(row)
             post['active_votes'] = await find_votes_impl(db, row['author'], row['permlink'], VotesPresentation.BridgeApi)
-            post = await append_statistics_to_post(post, row, True, blacklists_for_user)
-            limit = limit - 1
+            post = await append_statistics_to_post(post, row, False, None)
             posts.append(post)
-            pinned_post_ids.append(post['post_id'])
+        return posts
 
-    sql_result = await db.query_all(sql, author=start_author, limit=limit, tag=tag, permlink=start_permlink, community_name=tag, observer=observer)
-    for row in sql_result:
-        post = _bridge_post_object(row)
-        post['active_votes'] = await find_votes_impl(db, row['author'], row['permlink'], VotesPresentation.BridgeApi)
-        post = await append_statistics_to_post(post, row, False, blacklists_for_user)
-        if post['post_id'] in pinned_post_ids:
-            continue
-        posts.append(post)
-    return posts
+    valid_account(start_author, allow_empty=True)
+    valid_permlink(start_permlink, allow_empty=True)
+    valid_limit(limit, 100, 20)
+    valid_tag(tag, allow_empty=True)
+
+    db = context['db']
+
+    if tag == "my":
+        result = await _get_ranked_posts_for_observer_communities(db, sort, start_author, start_permlink, limit, observer)
+        return await process_query_results(result)
+
+    if tag and tag[:5] == 'hive-':
+        result = await _get_ranked_posts_for_communities(db, sort, tag, start_author, start_permlink, limit)
+        return await process_query_results(result)
+
+    if ( tag and tag != "all" ):
+        result = await _get_ranked_posts_for_tag(db, sort, tag, start_author, start_permlink, limit)
+        return await process_query_results(result)
+
+
+    result = await _get_ranked_posts_for_all(db, sort, start_author, start_permlink, limit)
+    return await process_query_results(result)
 
 async def append_statistics_to_post(post, row, is_pinned, blacklists_for_user=None):
     """ apply information such as blacklists and community names/roles to a given post """

tests_api @ 9d949311

-Subproject commit fa2ffe7fe6cd7ca9c2d4039c6bcf4a21d1842985
+Subproject commit 9d94931178ff0e20ce409014d56520d1baf687c5