query

package
v0.3.0-beta Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 18, 2021 License: GPL-3.0 Imports: 16 Imported by: 0

Documentation

Overview

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Package query contain function to build database query, and also has `Executor` that should return sql.Result or *sql.Rows

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

ZooBC Copyright (C) 2020 Quasisoft Limited - Hong Kong This file is part of ZooBC <https://github.com/zoobc/zoobc-core>

ZooBC is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

ZooBC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with ZooBC. If not, see <http://www.gnu.org/licenses/>.

Additional Permission Under GNU GPL Version 3 section 7. As the special exception permitted under Section 7b, c and e, in respect with the Author’s copyright, please refer to this section:

  1. You are free to convey this Program according to GNU GPL Version 3, as long as you respect and comply with the Author’s copyright by showing in its user interface an Appropriate Notice that the derivate program and its source code are “powered by ZooBC”. This is an acknowledgement for the copyright holder, ZooBC, as the implementation of appreciation of the exclusive right of the creator and to avoid any circumvention on the rights under trademark law for use of some trade names, trademarks, or service marks.
  1. Complying to the GNU GPL Version 3, you may distribute the program without any permission from the Author. However a prior notification to the authors will be appreciated.

ZooBC is architected by Roberto Capodieci & Barton Johnston 

contact us at roberto.capodieci[at]blockchainzoo.com
and barton.johnston[at]blockchainzoo.com

Core developers that contributed to the current implementation of the software are: 

Ahmad Ali Abdilah ahmad.abdilah[at]blockchainzoo.com
Allan Bintoro allan.bintoro[at]blockchainzoo.com
Andy Herman
Gede Sukra
Ketut Ariasa
Nawi Kartini nawi.kartini[at]blockchainzoo.com
Stefano Galassi stefano.galassi[at]blockchainzoo.com

IMPORTANT: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func CalculateBulkSize 

func CalculateBulkSize(totalFields, totalRecords int) (recordsPerPeriod, rounds, remaining int)

CalculateBulkSize calculating max records might allowed in single sqlite transaction, since sqlite3 has maximum variables in single transactions called SQLITE_LIMIT_VARIABLE_NUMBER in sqlite3-binding.c which is 999

func GetBlocksmithSafeQuery 

func GetBlocksmithSafeQuery(ct chaintype.ChainType) (snapshotQuery map[string]bool)

GetBlocksmithSafeQuery func to get all query repos that must save their full history in snapshots, for a minRollbackHeight number of blocks, to not break blocksmith process logic

func GetSnapshotQuery 

func GetSnapshotQuery(ct chaintype.ChainType) (snapshotQuery map[string]SnapshotQuery)

GetSnapshotQuery func to get all query repos that have a SelectDataForSnapshot method (that have data to be included in snapshots)

func GetTotalRecordOfSelect 

func GetTotalRecordOfSelect(selectQuery string) string

GetTotalRecordOfSelect transacform a select query that is used for getting data into one for getting total record

Types

type AccountBalanceQuery 

type AccountBalanceQuery struct {
	Fields    []string
	TableName string
}

AccountBalanceQuery is struct will implemented AccountBalanceInterface

func NewAccountBalanceQuery 

func NewAccountBalanceQuery() *AccountBalanceQuery

NewAccountBalanceQuery will create a new AccountBalanceQuery

func (*AccountBalanceQuery) AddAccountBalance 

func (q *AccountBalanceQuery) AddAccountBalance(balance int64, causedFields map[string]interface{}) [][]interface{}

func (*AccountBalanceQuery) AddAccountSpendableBalance 

func (q *AccountBalanceQuery) AddAccountSpendableBalance(balance int64, causedFields map[string]interface{}) (
	str string, args []interface{})

func (*AccountBalanceQuery) BuildModel 

func (*AccountBalanceQuery) BuildModel(accountBalances []*model.AccountBalance, rows *sql.Rows) ([]*model.AccountBalance, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*AccountBalanceQuery) ExtractModel 

func (*AccountBalanceQuery) ExtractModel(account *model.AccountBalance) []interface{}

func (*AccountBalanceQuery) GetAccountBalanceByAccountAddress 

func (q *AccountBalanceQuery) GetAccountBalanceByAccountAddress(accountAddress []byte) (str string, args []interface{})

func (*AccountBalanceQuery) GetAccountBalances 

func (q *AccountBalanceQuery) GetAccountBalances() string

func (*AccountBalanceQuery) ImportSnapshot 

func (q *AccountBalanceQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*AccountBalanceQuery) InsertAccountBalance 

func (q *AccountBalanceQuery) InsertAccountBalance(accountBalance *model.AccountBalance) (str string, args []interface{})

func (*AccountBalanceQuery) InsertAccountBalances 

func (q *AccountBalanceQuery) InsertAccountBalances(accountBalances []*model.AccountBalance) (str string, args []interface{})

InsertAccountBalances represents query builder to insert multiple record in single query

func (*AccountBalanceQuery) RecalibrateVersionedTable 

func (q *AccountBalanceQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*AccountBalanceQuery) Rollback 

func (q *AccountBalanceQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "height" and UPDATE latest of the `account_address` clause by `block_height`

func (*AccountBalanceQuery) Scan 

func (*AccountBalanceQuery) Scan(accountBalance *model.AccountBalance, row *sql.Row) error

Scan similar with `sql.Scan`

func (*AccountBalanceQuery) SelectDataForSnapshot 

func (q *AccountBalanceQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*AccountBalanceQuery) TrimDataBeforeSnapshot 

func (q *AccountBalanceQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type AccountBalanceQueryInterface 

type AccountBalanceQueryInterface interface {
	GetAccountBalanceByAccountAddress(accountAddress []byte) (str string, args []interface{})
	GetAccountBalances() string
	InsertAccountBalance(accountBalance *model.AccountBalance) (str string, args []interface{})
	InsertAccountBalances(accountBalances []*model.AccountBalance) (str string, args []interface{})
	AddAccountBalance(balance int64, causedFields map[string]interface{}) [][]interface{}
	AddAccountSpendableBalance(balance int64, causedFields map[string]interface{}) (str string, args []interface{})
	ExtractModel(accountBalance *model.AccountBalance) []interface{}
	BuildModel(accountBalances []*model.AccountBalance, rows *sql.Rows) ([]*model.AccountBalance, error)
	Scan(accountBalance *model.AccountBalance, row *sql.Row) error
}

AccountBalanceQueryInterface interface that implemented by AccountBalanceQuery

type AccountDatasetQuery 

type AccountDatasetQuery struct {
	Fields    []string
	TableName string
}

AccountDatasetQuery fields that must have

func NewAccountDatasetsQuery 

func NewAccountDatasetsQuery() *AccountDatasetQuery

NewAccountDatasetsQuery will create a new AccountDatasetQuery

func (*AccountDatasetQuery) BuildModel 

func (adq *AccountDatasetQuery) BuildModel(
	datasets []*model.AccountDataset,
	rows *sql.Rows,
) ([]*model.AccountDataset, error)

BuildModel allowing to extract *rows into list of model.AccountDataset

func (*AccountDatasetQuery) ExtractModel 

func (adq *AccountDatasetQuery) ExtractModel(dataset *model.AccountDataset) []interface{}

ExtractModel allowing to extracting the values

func (*AccountDatasetQuery) GetAccountDatasetEscrowApproval 

func (adq *AccountDatasetQuery) GetAccountDatasetEscrowApproval(accountAddress []byte) (qStr string, args []interface{})

GetAccountDatasetEscrowApproval represents query for get account dataset for AccountDatasetEscrowApproval property SetterAccountAddress and RecipientAccountAddress must be the same person

func (*AccountDatasetQuery) GetLatestAccountDataset 

func (adq *AccountDatasetQuery) GetLatestAccountDataset(
	setterAccountAddress, recipientAccountAddress []byte, property string,
) (str string, args []interface{})

GetLatestAccountDataset represents query builder to get the latest record of account_dataset

func (*AccountDatasetQuery) ImportSnapshot 

func (adq *AccountDatasetQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*AccountDatasetQuery) InsertAccountDataset 

func (adq *AccountDatasetQuery) InsertAccountDataset(dataset *model.AccountDataset) (str [][]interface{})

InsertAccountDataset represents a query builder to insert new record and set old version as latest is false and active is false to account_dataset table. Perhaps *model.AccountDataset.IsActive already set to false

func (*AccountDatasetQuery) InsertAccountDatasets 

func (adq *AccountDatasetQuery) InsertAccountDatasets(datasets []*model.AccountDataset) (str string, args []interface{})

InsertAccountDatasets represents query builder to insert multiple record in single query

func (*AccountDatasetQuery) RecalibrateVersionedTable 

func (adq *AccountDatasetQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*AccountDatasetQuery) Rollback 

func (adq *AccountDatasetQuery) Rollback(height uint32) (multiQueries [][]interface{})

func (*AccountDatasetQuery) Scan 

func (*AccountDatasetQuery) Scan(dataset *model.AccountDataset, row *sql.Row) error

Scan represents *sql.Scan

func (*AccountDatasetQuery) SelectDataForSnapshot 

func (adq *AccountDatasetQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*AccountDatasetQuery) TrimDataBeforeSnapshot 

func (adq *AccountDatasetQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type AccountDatasetQueryInterface 

type AccountDatasetQueryInterface interface {
	GetLatestAccountDataset(setterAccountAddress, recipientAccountAddress []byte, property string) (str string, args []interface{})
	InsertAccountDatasets(datasets []*model.AccountDataset) (str string, args []interface{})
	InsertAccountDataset(dataset *model.AccountDataset) [][]interface{}
	GetAccountDatasetEscrowApproval(accountAddress []byte) (qStr string, args []interface{})
	ExtractModel(dataset *model.AccountDataset) []interface{}
	BuildModel(datasets []*model.AccountDataset, rows *sql.Rows) ([]*model.AccountDataset, error)
	Scan(dataset *model.AccountDataset, row *sql.Row) error
}

AccountDatasetQueryInterface methods must have

type AccountLedgerQuery 

type AccountLedgerQuery struct {
	Fields    []string
	TableName string
}

AccountLedgerQuery schema of AccountLedger

func NewAccountLedgerQuery 

func NewAccountLedgerQuery() *AccountLedgerQuery

NewAccountLedgerQuery func that return AccountLedger schema with value

func (*AccountLedgerQuery) BuildModel 

func (*AccountLedgerQuery) BuildModel(accountLedgers []*model.AccountLedger, rows *sql.Rows) ([]*model.AccountLedger, error)

BuildModel will create or build models that extracted from rows

func (*AccountLedgerQuery) ExtractModel 

func (*AccountLedgerQuery) ExtractModel(accountLedger *model.AccountLedger) []interface{}

ExtractModel will extract accountLedger model to []interface

func (*AccountLedgerQuery) InsertAccountLedger 

func (q *AccountLedgerQuery) InsertAccountLedger(accountLedger *model.AccountLedger) (qStr string, args []interface{})

InsertAccountLedger represents insert query for AccountLedger

func (*AccountLedgerQuery) Rollback 

func (q *AccountLedgerQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback represents delete query in block_height n

type AccountLedgerQueryInterface 

type AccountLedgerQueryInterface interface {
	ExtractModel(accountLedger *model.AccountLedger) []interface{}
	BuildModel(accountLedgers []*model.AccountLedger, rows *sql.Rows) ([]*model.AccountLedger, error)
	InsertAccountLedger(accountLedger *model.AccountLedger) (qStr string, args []interface{})
}

AccountLedgerQueryInterface includes interface methods for AccountLedgerQuery

type BatchReceiptQuery 

type BatchReceiptQuery struct {
	Fields    []string
	TableName string
}

func NewBatchReceiptQuery 

func NewBatchReceiptQuery() *BatchReceiptQuery

NewBatchReceiptQuery returns BatchReceiptQuery instance

func (*BatchReceiptQuery) BuildModel 

func (*BatchReceiptQuery) BuildModel(batchReceipts []*model.BatchReceipt, rows *sql.Rows) ([]*model.BatchReceipt, error)

func (*BatchReceiptQuery) ExtractModel 

func (*BatchReceiptQuery) ExtractModel(receipt *model.BatchReceipt) []interface{}

ExtractModel extract the model struct fields to the order of BatchReceiptQuery.Fields

func (*BatchReceiptQuery) GetReceiptByRoot 

func (rq *BatchReceiptQuery) GetReceiptByRoot(
	lowerHeight, upperHeight uint32, root []byte) (str string, args []interface{})

GetReceiptByRoot return sql query to fetch pas by its merkle root, the datum_hash should not already exists in published_receipt table

func (*BatchReceiptQuery) GetReceipts 

func (rq *BatchReceiptQuery) GetReceipts(paginate model.Pagination) string

GetReceipts get a set of receipts that satisfies the params from DB

func (*BatchReceiptQuery) GetReceiptsWithUniqueRecipient 

func (rq *BatchReceiptQuery) GetReceiptsWithUniqueRecipient(
	limit, lowerBlockHeight, upperBlockHeight uint32) string

GetReceiptsWithUniqueRecipient get receipt with unique recipient_public_key lowerBlockHeight and upperBlockHeight is passed as window limit of receipt reference_block_height to pick

func (*BatchReceiptQuery) InsertReceipt 

func (rq *BatchReceiptQuery) InsertReceipt(receipt *model.BatchReceipt) (str string, args []interface{})

InsertReceipt inserts a new pas into DB

func (*BatchReceiptQuery) InsertReceipts 

func (rq *BatchReceiptQuery) InsertReceipts(receipts []*model.BatchReceipt) (str string, args []interface{})

InsertReceipts build query for bulk store pas

func (*BatchReceiptQuery) PruneData 

func (rq *BatchReceiptQuery) PruneData(blockHeight, limit uint32) (qStr string, args []interface{})

PruneData handle query for remove by reference_block_height with limit

func (*BatchReceiptQuery) Rollback 

func (rq *BatchReceiptQuery) Rollback(height uint32) (multiQueries [][]interface{})

func (*BatchReceiptQuery) Scan 

func (*BatchReceiptQuery) Scan(batchReceipt *model.BatchReceipt, row *sql.Row) error

func (*BatchReceiptQuery) SelectReceipt 

func (rq *BatchReceiptQuery) SelectReceipt(
	lowerHeight, upperHeight, limit uint32,
) (str string)

SelectReceipt select list of receipt by some filter

type BatchReceiptQueryInterface 

type BatchReceiptQueryInterface interface {
	InsertReceipt(receipt *model.BatchReceipt) (str string, args []interface{})
	InsertReceipts(receipts []*model.BatchReceipt) (str string, args []interface{})
	GetReceipts(paginate model.Pagination) string
	GetReceiptByRoot(lowerHeight, upperHeight uint32, root []byte) (str string, args []interface{})
	GetReceiptsWithUniqueRecipient(limit, lowerBlockHeight, upperBlockHeight uint32) string
	SelectReceipt(lowerHeight, upperHeight, limit uint32) (str string)
	PruneData(blockHeight, limit uint32) (string, []interface{})
	ExtractModel(receipt *model.BatchReceipt) []interface{}
	BuildModel(receipts []*model.BatchReceipt, rows *sql.Rows) ([]*model.BatchReceipt, error)
	Scan(receipt *model.BatchReceipt, row *sql.Row) error
}

type BlockQuery 

type BlockQuery struct {
	Fields    []string
	TableName string
	ChainType chaintype.ChainType
}

func NewBlockQuery 

func NewBlockQuery(chaintype chaintype.ChainType) *BlockQuery

NewBlockQuery returns BlockQuery instance

func (*BlockQuery) BuildModel 

func (*BlockQuery) BuildModel(blocks []*model.Block, rows *sql.Rows) ([]*model.Block, error)

func (*BlockQuery) ExtractModel 

func (*BlockQuery) ExtractModel(block *model.Block) []interface{}

ExtractModel extract the model struct fields to the order of BlockQuery.Fields

func (*BlockQuery) GetBlockByHeight 

func (bq *BlockQuery) GetBlockByHeight(height uint32) string

GetBlockByHeight returns query string to get block by height

func (*BlockQuery) GetBlockByID 

func (bq *BlockQuery) GetBlockByID(id int64) string

GetBlockByID returns query string to get block by ID

func (*BlockQuery) GetBlockFromHeight 

func (bq *BlockQuery) GetBlockFromHeight(startHeight, limit uint32) string

GetBlockFromHeight returns query string to get blocks from a certain height

func (*BlockQuery) GetBlockFromTimestamp 

func (bq *BlockQuery) GetBlockFromTimestamp(startTimestamp int64, limit uint32) string

GetBlockFromTimestamp returns query string to get blocks from a certain block timestamp

func (*BlockQuery) GetBlocks 

func (bq *BlockQuery) GetBlocks(height, size uint32) string

GetBlocks returns query string to get multiple blocks

func (*BlockQuery) GetGenesisBlock 

func (bq *BlockQuery) GetGenesisBlock() string

func (*BlockQuery) GetLastBlock 

func (bq *BlockQuery) GetLastBlock() string

func (*BlockQuery) ImportSnapshot 

func (bq *BlockQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*BlockQuery) InsertBlock 

func (bq *BlockQuery) InsertBlock(block *model.Block) (str string, args []interface{})

func (*BlockQuery) InsertBlocks 

func (bq *BlockQuery) InsertBlocks(blocks []*model.Block) (str string, args []interface{})

InsertBlocks represents query builder to insert multiple record in single query

func (*BlockQuery) RecalibrateVersionedTable 

func (bq *BlockQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*BlockQuery) Rollback 

func (bq *BlockQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "height"`

func (*BlockQuery) Scan 

func (*BlockQuery) Scan(block *model.Block, row *sql.Row) error

func (*BlockQuery) SelectDataForSnapshot 

func (bq *BlockQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

SelectDataForSnapshot select only the block at snapshot height (fromHeight is unused)

func (*BlockQuery) TrimDataBeforeSnapshot 

func (bq *BlockQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type BlockQueryInterface 

type BlockQueryInterface interface {
	Rollback(height uint32) (multiQueries [][]interface{})
	GetBlocks(height, size uint32) string
	GetLastBlock() string
	GetGenesisBlock() string
	GetBlockByID(id int64) string
	GetBlockByHeight(height uint32) string
	GetBlockFromHeight(startHeight, limit uint32) string
	GetBlockFromTimestamp(startTimestamp int64, limit uint32) string
	InsertBlock(block *model.Block) (str string, args []interface{})
	InsertBlocks(blocks []*model.Block) (str string, args []interface{})
	ExtractModel(block *model.Block) []interface{}
	BuildModel(blocks []*model.Block, rows *sql.Rows) ([]*model.Block, error)
	Scan(block *model.Block, row *sql.Row) error
}

type CaseQuery 

type CaseQuery struct {
	Query *bytes.Buffer
	Args  []interface{}
	Alias string
}

CaseQuery would be as swap `Query` and `Args` those can save the query and args values

func NewCaseQuery 

func NewCaseQuery() CaseQuery

NewCaseQuery initiate New `CaseQuery`

func (*CaseQuery) And 

func (fq *CaseQuery) And(query ...string) *CaseQuery

And represents `expressionFoo AND expressionBar`

func (*CaseQuery) AndOr 

func (fq *CaseQuery) AndOr(expression ...string) *CaseQuery

AndOr represents `AND (expressionFoo OR expressionBar)`

func (*CaseQuery) As 

func (fq *CaseQuery) As(alias string) *CaseQuery

As represents AS ..., and it will join with query string on Build

func (*CaseQuery) Between 

func (fq *CaseQuery) Between(column string, start, end interface{}) string

Between represents `column BETWEEN foo AND bar`

func (*CaseQuery) Build 

func (fq *CaseQuery) Build() (query string, args []interface{})

Build should be called in the end of `CaseQuery` circular. And build buffer query string into string, sub query separated by comma

func (*CaseQuery) Equal 

func (fq *CaseQuery) Equal(column string, value interface{}) string

Equal represents `column` == `value`

func (*CaseQuery) GreaterEqual 

func (fq *CaseQuery) GreaterEqual(column string, value interface{}) string

GreaterEqual represents `column >= value`

func (*CaseQuery) GroupBy 

func (fq *CaseQuery) GroupBy(column ...string) *CaseQuery

GroupBy represents `... GROUP BY column, column ...`

func (*CaseQuery) In 

func (fq *CaseQuery) In(column string, value ...interface{}) string

In represents `column` IN (value...)

func (*CaseQuery) LessEqual 

func (fq *CaseQuery) LessEqual(column string, value interface{}) string

LessEqual represents `column <= value`

func (*CaseQuery) Limit 

func (fq *CaseQuery) Limit(limit uint32) *CaseQuery

Limit represents `... LIMIT ...`

func (*CaseQuery) NotBetween 

func (fq *CaseQuery) NotBetween(column string, start, end interface{}) string

NotBetween represents `column NOT BETWEEN foo AND bar`

func (*CaseQuery) NotEqual 

func (fq *CaseQuery) NotEqual(column string, value interface{}) string

NotEqual represents `column` != `value`

func (*CaseQuery) NotIn 

func (fq *CaseQuery) NotIn(column string, value ...interface{}) string

NotIn represents `column NOT IN (value...)`

func (*CaseQuery) Or 

func (fq *CaseQuery) Or(expression ...string) *CaseQuery

Or represents `expressionFoo OR expressionBar`

func (*CaseQuery) OrderBy 

func (fq *CaseQuery) OrderBy(column string, order model.OrderBy) *CaseQuery

OrderBy represents `... ORDER BY column DESC|ASC`

func (*CaseQuery) Paginate 

func (fq *CaseQuery) Paginate(limit, currentPage uint32) *CaseQuery

Paginate represents `limit = ? offset = ?` default limit = 30, page start from 1

func (*CaseQuery) QueryString 

func (fq *CaseQuery) QueryString() string

QueryString allow to get buffer as string, sub query separated by comma

func (*CaseQuery) Select 

func (fq *CaseQuery) Select(tableName string, columns ...string) *CaseQuery

Select build buffer query string

func (*CaseQuery) SubBuild 

func (fq *CaseQuery) SubBuild() (query string, args []interface{})

SubBuild represents sub query builder without break the struct values, make sure call this method in separate declaration of CaseQuery

func (*CaseQuery) Where 

func (fq *CaseQuery) Where(query ...string) *CaseQuery

Where build buffer query string, can combine with `In(), NotIn() ...`

type CaseQueryInterface 

type CaseQueryInterface interface {
	Select(tableName string, columns ...string) *CaseQuery
	Where(query ...string) *CaseQuery
	And(expression ...string) *CaseQuery
	Or(expression ...string) *CaseQuery
	AndOr(expression ...string) *CaseQuery
	In(column string, value ...interface{}) string
	NotIn(column string, value ...interface{}) string
	Equal(column string, value interface{}) string
	NotEqual(column string, value interface{}) string
	Between(column string, start, end interface{}) string
	NotBetween(column string, start, end interface{}) string
	GroupBy(column ...string) *CaseQuery
	OrderBy(column string, order model.OrderBy) *CaseQuery
	Limit(limit uint32) *CaseQuery
	Paginate(limit, currentPage uint32) *CaseQuery
	QueryString() string
	Build() (query string, args []interface{})
	SubBuild() (query string, args []interface{})
	As(alias string) *CaseQuery
}

CaseQueryInterface is interface includes `func` that handle Operand CaseQueryInterface for complex query builder

type DerivedQuery 

type DerivedQuery interface {
	// Rollback return query string to rollback table to `height`
	Rollback(height uint32) (multiQueries [][]interface{})
}

DerivedQuery represent query that can be rolled back

func GetDerivedQuery 

func GetDerivedQuery(ct chaintype.ChainType) (derivedQuery []DerivedQuery)

GetDerivedQuery func to get the whole queries has has rollback method

type EscrowTransactionQuery 

type EscrowTransactionQuery struct {
	Fields    []string
	TableName string
}

EscrowTransactionQuery fields must have

func NewEscrowTransactionQuery 

func NewEscrowTransactionQuery() *EscrowTransactionQuery

NewEscrowTransactionQuery build an EscrowTransactionQuery

func (*EscrowTransactionQuery) BuildModels 

func (et *EscrowTransactionQuery) BuildModels(rows *sql.Rows) ([]*model.Escrow, error)

BuildModels extract sqlRaw into []*model.Escrow

func (*EscrowTransactionQuery) ExtractModel 

func (et *EscrowTransactionQuery) ExtractModel(escrow *model.Escrow) []interface{}

ExtractModel will extract values of escrow as []interface{}

func (*EscrowTransactionQuery) GetEscrowTransactions 

func (et *EscrowTransactionQuery) GetEscrowTransactions(fields map[string]interface{}) (qStr string, args []interface{})

GetEscrowTransactions represents SELECT with multiple clauses connected via AND operand

func (*EscrowTransactionQuery) GetEscrowTransactionsByTransactionIdsAndStatus 

func (et *EscrowTransactionQuery) GetEscrowTransactionsByTransactionIdsAndStatus(
	transactionIds []string, status model.EscrowStatus,
) string

func (*EscrowTransactionQuery) GetExpiredEscrowTransactionsAtCurrentBlock 

func (et *EscrowTransactionQuery) GetExpiredEscrowTransactionsAtCurrentBlock(blockTimestamp int64) string

GetExpiredEscrowTransactionsAtCurrentBlock fetch provided block height expired escrow transaction

func (*EscrowTransactionQuery) GetLatestEscrowTransactionByID 

func (et *EscrowTransactionQuery) GetLatestEscrowTransactionByID(id int64) (qStr string, args []interface{})

GetLatestEscrowTransactionByID represents getting latest escrow by id

func (*EscrowTransactionQuery) ImportSnapshot 

func (et *EscrowTransactionQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*EscrowTransactionQuery) InsertEscrowTransaction 

func (et *EscrowTransactionQuery) InsertEscrowTransaction(escrow *model.Escrow) [][]interface{}

InsertEscrowTransaction represents insert query for escrow_transaction table. There 2 queries result:

  1. Update the previous record to latest = false
  2. Insert new record which is the newest

func (*EscrowTransactionQuery) InsertEscrowTransactions 

func (et *EscrowTransactionQuery) InsertEscrowTransactions(escrows []*model.Escrow) (str string, args []interface{})

InsertEscrowTransactions represents query builder to insert multiple record in single query

func (*EscrowTransactionQuery) RecalibrateVersionedTable 

func (et *EscrowTransactionQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*EscrowTransactionQuery) Rollback 

func (et *EscrowTransactionQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "height"

func (*EscrowTransactionQuery) Scan 

func (et *EscrowTransactionQuery) Scan(escrow *model.Escrow, row *sql.Row) error

Scan extract sqlRaw *sql.Row into model.Escrow

func (*EscrowTransactionQuery) SelectDataForSnapshot 

func (et *EscrowTransactionQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*EscrowTransactionQuery) TrimDataBeforeSnapshot 

func (et *EscrowTransactionQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type EscrowTransactionQueryInterface 

type EscrowTransactionQueryInterface interface {
	InsertEscrowTransaction(escrow *model.Escrow) [][]interface{}
	InsertEscrowTransactions(escrows []*model.Escrow) (str string, args []interface{})
	GetLatestEscrowTransactionByID(int64) (string, []interface{})
	GetEscrowTransactions(fields map[string]interface{}) (string, []interface{})
	GetExpiredEscrowTransactionsAtCurrentBlock(blockTimestamp int64) string
	GetEscrowTransactionsByTransactionIdsAndStatus(
		transactionIds []string, status model.EscrowStatus,
	) string
	ExtractModel(*model.Escrow) []interface{}
	BuildModels(*sql.Rows) ([]*model.Escrow, error)
	Scan(escrow *model.Escrow, row *sql.Row) error
}

EscrowTransactionQueryInterface methods must have

type Executor 

type Executor struct {
	Db           *sql.DB
	sync.RWMutex // mutex should only lock tx
	Tx           *sql.Tx
}

Executor struct

func NewQueryExecutor 

func NewQueryExecutor(db *sql.DB, pL queue.PriorityLock) *Executor

NewQueryExecutor create new query executor instance

func (*Executor) BeginTx 

func (qe *Executor) BeginTx(highPriorityLock bool, ownerProcess int) error

BeginTx begin database transaction and assign it to the Executor.Tx lock the struct on begin

func (*Executor) CommitTx 

func (qe *Executor) CommitTx(highPriorityLock bool) error

CommitTx commit on every transaction stacked in Executor.Tx note: rollback is called in this function if commit fail, to avoid locking complication

func (*Executor) Execute 

func (qe *Executor) Execute(query string) (sql.Result, error)

Execute execute a single query string return error if query not executed successfully error will be nil otherwise.

func (*Executor) ExecuteSelect 

func (qe *Executor) ExecuteSelect(query string, tx bool, args ...interface{}) (*sql.Rows, error)

ExecuteSelect execute with select method that if you want to get `sql.Rows`.

And ***need to `Close()` the rows***.

This function is necessary if you want to processing the rows, otherwise you can use `Execute` or `ExecuteTransactions`

func (*Executor) ExecuteSelectRow 

func (qe *Executor) ExecuteSelectRow(query string, tx bool, args ...interface{}) (*sql.Row, error)

ExecuteSelectRow execute with select method that if you want to get `sql.Row` (single). This function is necessary if you want to processing the row, otherwise you can use `Execute` or `ExecuteTransactions`

func (*Executor) ExecuteStatement 

func (qe *Executor) ExecuteStatement(query string, args ...interface{}) (sql.Result, error)

ExecuteStatement execute a single query string return error if query not executed successfully error will be nil otherwise.

func (*Executor) ExecuteTransaction 

func (qe *Executor) ExecuteTransaction(qStr string, args ...interface{}) error

ExecuteTransaction execute a single transaction without committing it to database ExecuteTransaction should only be called after BeginTx and before CommitTx

func (*Executor) ExecuteTransactions 

func (qe *Executor) ExecuteTransactions(queries [][]interface{}) error

ExecuteTransactions execute multiple transactions without committing it to database ExecuteTransactions should only be called after BeginTx and before CommitTx

func (*Executor) RollbackTx 

func (qe *Executor) RollbackTx(highPriorityLock bool) error

RollbackTx rollback and unlock executor in case any single tx fail

type ExecutorInterface 

type ExecutorInterface interface {
	BeginTx(highPriorityLock bool, ownerProcess int) error
	Execute(string) (sql.Result, error)
	ExecuteSelect(query string, tx bool, args ...interface{}) (*sql.Rows, error)
	ExecuteSelectRow(query string, tx bool, args ...interface{}) (*sql.Row, error)
	ExecuteStatement(query string, args ...interface{}) (sql.Result, error)
	ExecuteTransaction(query string, args ...interface{}) error
	ExecuteTransactions(queries [][]interface{}) error
	// CommitTx commit on every transaction stacked in Executor.Tx
	// note: rollback is called in this function if commit fail, to avoid locking complication
	CommitTx(highPriorityLock bool) error
	RollbackTx(highPriorityLock bool) error
}

ExecutorInterface interface

type FeeScaleQuery 

type FeeScaleQuery struct {
	Fields    []string
	TableName string
	ChainType chaintype.ChainType
}

func NewFeeScaleQuery 

func NewFeeScaleQuery() *FeeScaleQuery

NewFeeScaleQuery returns FeeScaleQuery instance

func (*FeeScaleQuery) BuildModel 

func (*FeeScaleQuery) BuildModel(
	feeScales []*model.FeeScale,
	rows *sql.Rows,
) ([]*model.FeeScale, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*FeeScaleQuery) ExtractModel 

func (*FeeScaleQuery) ExtractModel(feeScale *model.FeeScale) []interface{}

ExtractModel extract the model struct fields to the order of MempoolQuery.Fields

func (*FeeScaleQuery) GetLatestFeeScale 

func (fsq *FeeScaleQuery) GetLatestFeeScale() string

GetLatestFeeScale return the latest fee scale

func (*FeeScaleQuery) ImportSnapshot 

func (fsq *FeeScaleQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*FeeScaleQuery) InsertFeeScale 

func (fsq *FeeScaleQuery) InsertFeeScale(feeScale *model.FeeScale) [][]interface{}

InsertFeeScale insert new fee scale record

func (*FeeScaleQuery) InsertFeeScales 

func (fsq *FeeScaleQuery) InsertFeeScales(feeScales []*model.FeeScale) (str string, args []interface{})

func (*FeeScaleQuery) RecalibrateVersionedTable 

func (fsq *FeeScaleQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*FeeScaleQuery) Rollback 

func (fsq *FeeScaleQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "block_height"

func (*FeeScaleQuery) Scan 

func (*FeeScaleQuery) Scan(feeScale *model.FeeScale, row *sql.Row) error

Scan similar with `sql.Scan`

func (*FeeScaleQuery) SelectDataForSnapshot 

func (fsq *FeeScaleQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

SelectDataForSnapshot select only the block at snapshot block_height (fromHeight is unused)

func (*FeeScaleQuery) TrimDataBeforeSnapshot 

func (fsq *FeeScaleQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type FeeScaleQueryInterface 

type FeeScaleQueryInterface interface {
	GetLatestFeeScale() string
	InsertFeeScale(feeScale *model.FeeScale) [][]interface{}
	InsertFeeScales(feeScales []*model.FeeScale) (qry string, args []interface{})
	ExtractModel(feeScale *model.FeeScale) []interface{}
	BuildModel(feeScales []*model.FeeScale, rows *sql.Rows) ([]*model.FeeScale, error)
	Scan(feeScale *model.FeeScale, row *sql.Row) error
}

type FeeVoteCommitmentVoteQuery 

type FeeVoteCommitmentVoteQuery struct {
	Fields    []string
	TableName string
}

FeeVoteCommitmentVoteQuery struct that have string query for FeeVoteCommitmentVotes

func NewFeeVoteCommitmentVoteQuery 

func NewFeeVoteCommitmentVoteQuery() *FeeVoteCommitmentVoteQuery

NewFeeVoteCommitmentVoteQuery returns FeeVoteCommitmentVotesQuery instance

func (*FeeVoteCommitmentVoteQuery) BuildModel 

func (*FeeVoteCommitmentVoteQuery) BuildModel(
	feeVoteCommitmentVotes []*model.FeeVoteCommitmentVote,
	rows *sql.Rows,
) ([]*model.FeeVoteCommitmentVote, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*FeeVoteCommitmentVoteQuery) ExtractModel 

func (*FeeVoteCommitmentVoteQuery) ExtractModel(voteCommit *model.FeeVoteCommitmentVote) []interface{}

ExtractModel to extract FeeVoteCommitmentVote model to []interface

func (*FeeVoteCommitmentVoteQuery) GetVoteCommitByAccountAddressAndHeight 

func (fsvc *FeeVoteCommitmentVoteQuery) GetVoteCommitByAccountAddressAndHeight(
	accountAddress []byte, height uint32,
) (
	qStr string, args []interface{},
)

GetVoteCommitByAccountAddressAndHeight to get vote commit by account address & block height

func (*FeeVoteCommitmentVoteQuery) ImportSnapshot 

func (fsvc *FeeVoteCommitmentVoteQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*FeeVoteCommitmentVoteQuery) InsertCommitVote 

func (fsvc *FeeVoteCommitmentVoteQuery) InsertCommitVote(voteCommit *model.FeeVoteCommitmentVote) (
	qStr string, args []interface{},
)

InsertCommitVote to build insert query for `fee_vote_commitment_vote` table

func (*FeeVoteCommitmentVoteQuery) InsertCommitVotes 

func (fsvc *FeeVoteCommitmentVoteQuery) InsertCommitVotes(voteCommits []*model.FeeVoteCommitmentVote) (str string, args []interface{})

func (*FeeVoteCommitmentVoteQuery) RecalibrateVersionedTable 

func (fsvc *FeeVoteCommitmentVoteQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*FeeVoteCommitmentVoteQuery) Rollback 

func (fsvc *FeeVoteCommitmentVoteQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "block_height"`

func (*FeeVoteCommitmentVoteQuery) Scan 

func (*FeeVoteCommitmentVoteQuery) Scan(voteCommit *model.FeeVoteCommitmentVote, row *sql.Row) error

Scan similar with `sql.Scan`

func (*FeeVoteCommitmentVoteQuery) SelectDataForSnapshot 

func (fsvc *FeeVoteCommitmentVoteQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

SelectDataForSnapshot select only the block at snapshot block_height (fromHeight is unused)

func (*FeeVoteCommitmentVoteQuery) TrimDataBeforeSnapshot 

func (fsvc *FeeVoteCommitmentVoteQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type FeeVoteCommitmentVoteQueryInterface 

type FeeVoteCommitmentVoteQueryInterface interface {
	GetVoteCommitByAccountAddressAndHeight(
		accountAddress []byte,
		height uint32,
	) (qStr string, args []interface{})
	InsertCommitVote(voteCommit *model.FeeVoteCommitmentVote) (qStr string, args []interface{})
	InsertCommitVotes(voteCommits []*model.FeeVoteCommitmentVote) (qStr string, args []interface{})
	ExtractModel(voteCommit *model.FeeVoteCommitmentVote) []interface{}
	Scan(voteCommit *model.FeeVoteCommitmentVote, row *sql.Row) error
	BuildModel(
		feeVoteCommitmentVotes []*model.FeeVoteCommitmentVote,
		rows *sql.Rows,
	) ([]*model.FeeVoteCommitmentVote, error)
	Rollback(height uint32) (multiQueries [][]interface{})
}

FeeVoteCommitmentVoteQueryInterface interface that implemented by FeeVoteCommitmentVoteQuery

type FeeVoteRevealVoteQuery 

type FeeVoteRevealVoteQuery struct {
	Fields    []string
	TableName string
}

func NewFeeVoteRevealVoteQuery 

func NewFeeVoteRevealVoteQuery() *FeeVoteRevealVoteQuery

func (*FeeVoteRevealVoteQuery) BuildModel 

func (fvr *FeeVoteRevealVoteQuery) BuildModel(
	votes []*model.FeeVoteRevealVote, rows *sql.Rows,
) ([]*model.FeeVoteRevealVote, error)

func (*FeeVoteRevealVoteQuery) ExtractModel 

func (*FeeVoteRevealVoteQuery) ExtractModel(revealVote *model.FeeVoteRevealVote) []interface{}

ExtractModel extracting model.FeeVoteRevealVote values

func (*FeeVoteRevealVoteQuery) GetFeeVoteRevealByAccountAddressAndRecentBlockHeight 

func (fvr *FeeVoteRevealVoteQuery) GetFeeVoteRevealByAccountAddressAndRecentBlockHeight(
	accountAddress []byte,
	blockHeight uint32,
) (qry string, args []interface{})

GetFeeVoteRevealByAccountAddressAndRecentBlockHeight represents getting fee_vote_reveal by account address

func (*FeeVoteRevealVoteQuery) GetFeeVoteRevealsInPeriod 

func (fvr *FeeVoteRevealVoteQuery) GetFeeVoteRevealsInPeriod(
	lowerBlockHeight, upperBlockHeight uint32,
) (qry string, args []interface{})

GetFeeVoteRevealsInPeriod select reveals within block-height range blockHeight limit are inclusive

func (*FeeVoteRevealVoteQuery) ImportSnapshot 

func (fvr *FeeVoteRevealVoteQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*FeeVoteRevealVoteQuery) InsertRevealVote 

func (fvr *FeeVoteRevealVoteQuery) InsertRevealVote(revealVote *model.FeeVoteRevealVote) (qry string, args []interface{})

InsertRevealVote represents insert new record to fee_vote_reveal

func (*FeeVoteRevealVoteQuery) InsertRevealVotes 

func (fvr *FeeVoteRevealVoteQuery) InsertRevealVotes(revealVotes []*model.FeeVoteRevealVote) (str string, args []interface{})

func (*FeeVoteRevealVoteQuery) RecalibrateVersionedTable 

func (fvr *FeeVoteRevealVoteQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*FeeVoteRevealVoteQuery) Rollback 

func (fvr *FeeVoteRevealVoteQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "block_height"`

func (*FeeVoteRevealVoteQuery) Scan 

func (fvr *FeeVoteRevealVoteQuery) Scan(vote *model.FeeVoteRevealVote, row *sql.Row) error

Scan build model.FeeVoteRevealVote from sql.Row

func (*FeeVoteRevealVoteQuery) SelectDataForSnapshot 

func (fvr *FeeVoteRevealVoteQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

SelectDataForSnapshot select only the block at snapshot block_height

func (*FeeVoteRevealVoteQuery) TrimDataBeforeSnapshot 

func (fvr *FeeVoteRevealVoteQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type FeeVoteRevealVoteQueryInterface 

type FeeVoteRevealVoteQueryInterface interface {
	GetFeeVoteRevealByAccountAddressAndRecentBlockHeight(accountAddress []byte, blockHeight uint32) (string, []interface{})
	GetFeeVoteRevealsInPeriod(
		lowerBlockHeight, upperBlockHeight uint32,
	) (string, []interface{})
	InsertRevealVote(revealVote *model.FeeVoteRevealVote) (string, []interface{})
	InsertRevealVotes(revealVotes []*model.FeeVoteRevealVote) (str string, args []interface{})
	Scan(vote *model.FeeVoteRevealVote, row *sql.Row) error
	BuildModel(votes []*model.FeeVoteRevealVote, rows *sql.Rows) ([]*model.FeeVoteRevealVote, error)
}

type LiquidPaymentTransactionQuery 

type LiquidPaymentTransactionQuery struct {
	Fields    []string
	TableName string
}

LiquidPaymentTransactionQuery fields must have

func NewLiquidPaymentTransactionQuery 

func NewLiquidPaymentTransactionQuery() *LiquidPaymentTransactionQuery

NewLiquidPaymentTransactionQuery build a LiquidPaymentTransactionQuery

func (*LiquidPaymentTransactionQuery) BuildModels 

func (lpt *LiquidPaymentTransactionQuery) BuildModels(rows *sql.Rows) ([]*model.LiquidPayment, error)

BuildModels extract sqlRaw into []*model.LiquidPayment

func (*LiquidPaymentTransactionQuery) CompleteLiquidPaymentTransaction 

func (lpt *LiquidPaymentTransactionQuery) CompleteLiquidPaymentTransaction(id int64, causedFields map[string]interface{}) [][]interface{}

func (*LiquidPaymentTransactionQuery) ExtractModel 

func (lpt *LiquidPaymentTransactionQuery) ExtractModel(liquidPayment *model.LiquidPayment) []interface{}

ExtractModel will extract values of LiquidPayment as []interface{}

func (*LiquidPaymentTransactionQuery) GetPassedTimePendingLiquidPaymentTransactions 

func (lpt *LiquidPaymentTransactionQuery) GetPassedTimePendingLiquidPaymentTransactions(timestamp int64) (qStr string, args []interface{})

func (*LiquidPaymentTransactionQuery) GetPendingLiquidPaymentTransactionByID 

func (lpt *LiquidPaymentTransactionQuery) GetPendingLiquidPaymentTransactionByID(id int64,
	status model.LiquidPaymentStatus) (str string, args []interface{})

GetPendingLiquidPaymentTransactionByID fetches the latest Liquid payment record that matches with the ID and have pending status

func (*LiquidPaymentTransactionQuery) ImportSnapshot 

func (lpt *LiquidPaymentTransactionQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*LiquidPaymentTransactionQuery) InsertLiquidPaymentTransaction 

func (lpt *LiquidPaymentTransactionQuery) InsertLiquidPaymentTransaction(liquidPayment *model.LiquidPayment) [][]interface{}

func (*LiquidPaymentTransactionQuery) InsertLiquidPaymentTransactions 

func (lpt *LiquidPaymentTransactionQuery) InsertLiquidPaymentTransactions(liquidPayments []*model.LiquidPayment) (str string, args []interface{})

func (*LiquidPaymentTransactionQuery) RecalibrateVersionedTable 

func (lpt *LiquidPaymentTransactionQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*LiquidPaymentTransactionQuery) Rollback 

func (lpt *LiquidPaymentTransactionQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "height"

func (*LiquidPaymentTransactionQuery) Scan 

func (lpt *LiquidPaymentTransactionQuery) Scan(liquidPayment *model.LiquidPayment, row *sql.Row) error

Scan extract sqlRaw *sql.Row into model.LiquidPayment

func (*LiquidPaymentTransactionQuery) SelectDataForSnapshot 

func (lpt *LiquidPaymentTransactionQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*LiquidPaymentTransactionQuery) TrimDataBeforeSnapshot 

func (lpt *LiquidPaymentTransactionQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type LiquidPaymentTransactionQueryInterface 

type LiquidPaymentTransactionQueryInterface interface {
	InsertLiquidPaymentTransaction(liquidPayment *model.LiquidPayment) [][]interface{}
	InsertLiquidPaymentTransactions(liquidPayments []*model.LiquidPayment) (str string, args []interface{})
	GetPendingLiquidPaymentTransactionByID(id int64, status model.LiquidPaymentStatus) (str string, args []interface{})
	GetPassedTimePendingLiquidPaymentTransactions(timestamp int64) (qStr string, args []interface{})
	CompleteLiquidPaymentTransaction(id int64, causedFields map[string]interface{}) [][]interface{}
	ExtractModel(*model.LiquidPayment) []interface{}
	BuildModels(*sql.Rows) ([]*model.LiquidPayment, error)
	Scan(liquidPayment *model.LiquidPayment, row *sql.Row) error
}

LiquidPaymentTransactionQueryInterface methods must have

type MempoolQuery 

type MempoolQuery struct {
	Fields    []string
	TableName string
	ChainType chaintype.ChainType
}

func NewMempoolQuery 

func NewMempoolQuery(chaintype chaintype.ChainType) *MempoolQuery

NewMempoolQuery returns MempoolQuery instance

func (*MempoolQuery) BuildModel 

func (*MempoolQuery) BuildModel(
	mempools []*model.MempoolTransaction,
	rows *sql.Rows,
) ([]*model.MempoolTransaction, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*MempoolQuery) DeleteExpiredMempoolTransactions 

func (mpq *MempoolQuery) DeleteExpiredMempoolTransactions(expiration int64) string

DeleteExpiredMempoolTransactions delete expired mempool transactions

func (*MempoolQuery) DeleteMempoolTransaction 

func (mpq *MempoolQuery) DeleteMempoolTransaction() string

DeleteMempoolTransaction delete one mempool transaction by id

func (*MempoolQuery) DeleteMempoolTransactions 

func (mpq *MempoolQuery) DeleteMempoolTransactions(idsStr []string) string

DeleteMempoolTransactions delete one mempool transaction by id

func (*MempoolQuery) ExtractModel 

func (*MempoolQuery) ExtractModel(mempool *model.MempoolTransaction) []interface{}

ExtractModel extract the model struct fields to the order of MempoolQuery.Fields

func (*MempoolQuery) GetMempoolTransaction 

func (mpq *MempoolQuery) GetMempoolTransaction() string

GetMempoolTransaction returns query string to get multiple mempool transactions

func (*MempoolQuery) GetMempoolTransactions 

func (mpq *MempoolQuery) GetMempoolTransactions() string

GetMempoolTransactions returns query string to get multiple mempool transactions

func (*MempoolQuery) GetMempoolTransactionsWantToByHeight 

func (mpq *MempoolQuery) GetMempoolTransactionsWantToByHeight(height uint32) (qStr string)

func (*MempoolQuery) InsertMempoolTransaction 

func (mpq *MempoolQuery) InsertMempoolTransaction(mempoolTx *model.MempoolTransaction) (qStr string, args []interface{})

func (*MempoolQuery) Rollback 

func (mpq *MempoolQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "block_height"

func (*MempoolQuery) Scan 

func (*MempoolQuery) Scan(mempool *model.MempoolTransaction, row *sql.Row) error

Scan similar with `sql.Scan`

Example 
var (
	mempool  model.MempoolTransaction
	mempoolQ MempoolQueryInterface
	err      error
)
mempoolQ = NewMempoolQuery(&chaintype.MainChain{})
err = mempoolQ.Scan(&mempool, (&mockRowMempoolQueryScan{}).ExecuteSelectRow("", ""))
fmt.Println(err)

Output:

<nil>

type MempoolQueryInterface 

type MempoolQueryInterface interface {
	GetMempoolTransactions() string
	GetMempoolTransaction() string
	InsertMempoolTransaction(mempoolTx *model.MempoolTransaction) (qStr string, args []interface{})
	DeleteMempoolTransaction() string
	DeleteMempoolTransactions([]string) string
	DeleteExpiredMempoolTransactions(expiration int64) string
	GetMempoolTransactionsWantToByHeight(height uint32) (qStr string)
	ExtractModel(block *model.MempoolTransaction) []interface{}
	BuildModel(mempools []*model.MempoolTransaction, rows *sql.Rows) ([]*model.MempoolTransaction, error)
	Scan(mempool *model.MempoolTransaction, row *sql.Row) error
}

type MerkleTreeQuery 

type MerkleTreeQuery struct {
	Fields    []string
	TableName string
}

MerkleTreeQuery fields and table name

func NewMerkleTreeQuery 

func NewMerkleTreeQuery() *MerkleTreeQuery

NewMerkleTreeQuery func to create new MerkleTreeInterface

func (*MerkleTreeQuery) BuildTree 

func (mrQ *MerkleTreeQuery) BuildTree(rows *sql.Rows) (map[string][]byte, error)

func (*MerkleTreeQuery) GetLastMerkleRoot 

func (mrQ *MerkleTreeQuery) GetLastMerkleRoot() (qStr string)

func (*MerkleTreeQuery) GetMerkleTreeByRoot 

func (mrQ *MerkleTreeQuery) GetMerkleTreeByRoot(root []byte) (qStr string, args []interface{})

GetMerkleTreeByRoot is used to retrieve merkle table record, to check if the merkle root specified exist

func (*MerkleTreeQuery) InsertMerkleTree 

func (mrQ *MerkleTreeQuery) InsertMerkleTree(
	root, tree []byte, timestamp int64, blockHeight uint32,
) (qStr string, args []interface{})

InsertMerkleTree func build insert Query for MerkleTree

func (*MerkleTreeQuery) PruneData 

func (mrQ *MerkleTreeQuery) PruneData(blockHeight, limit uint32) (qStr string, args []interface{})

PruneData represents query remove in range block_height with limit

func (*MerkleTreeQuery) Rollback 

func (mrQ *MerkleTreeQuery) Rollback(height uint32) (multiQueries [][]interface{})

func (*MerkleTreeQuery) ScanRoot 

func (mrQ *MerkleTreeQuery) ScanRoot(row *sql.Row) ([]byte, error)

func (*MerkleTreeQuery) ScanTree 

func (mrQ *MerkleTreeQuery) ScanTree(row *sql.Row) ([]byte, error)

func (*MerkleTreeQuery) SelectMerkleTree 

func (mrQ *MerkleTreeQuery) SelectMerkleTree(
	lowerHeight, upperHeight, limit uint32,
) string

SelectMerkleTree represents get merkle tree in range of block_height and order by block_height ascending test_expression >= low_expression AND test_expression <= high_expression

type MerkleTreeQueryInterface 

type MerkleTreeQueryInterface interface {
	InsertMerkleTree(
		root, tree []byte, timestamp int64, blockHeight uint32) (qStr string, args []interface{})
	GetMerkleTreeByRoot(root []byte) (qStr string, args []interface{})
	SelectMerkleTree(
		lowerHeight, upperHeight, limit uint32,
	) string
	GetLastMerkleRoot() (qStr string)
	PruneData(blockHeight, limit uint32) (string, []interface{})
	ScanTree(row *sql.Row) ([]byte, error)
	ScanRoot(row *sql.Row) ([]byte, error)
	BuildTree(row *sql.Rows) (map[string][]byte, error)
}

MerkleTreeQueryInterface contain builder func for MerkleTree

type MultiSignatureParticipantQuery 

type MultiSignatureParticipantQuery struct {
	Fields    []string
	TableName string
}

func NewMultiSignatureParticipantQuery 

func NewMultiSignatureParticipantQuery() *MultiSignatureParticipantQuery

func (*MultiSignatureParticipantQuery) BuildModel 

func (msq *MultiSignatureParticipantQuery) BuildModel(rows *sql.Rows) (participants []*model.MultiSignatureParticipant, err error)

func (*MultiSignatureParticipantQuery) ExtractModel 

func (msq *MultiSignatureParticipantQuery) ExtractModel(participant *model.MultiSignatureParticipant) []interface{}

func (*MultiSignatureParticipantQuery) GetMultiSignatureParticipantsByMultisigAddressAndHeightRange 

func (msq *MultiSignatureParticipantQuery) GetMultiSignatureParticipantsByMultisigAddressAndHeightRange(
	multisigAddress []byte,
	fromHeight,
	toHeight uint32,
) (str string, args []interface{})

func (*MultiSignatureParticipantQuery) InsertMultisignatureParticipants 

func (msq *MultiSignatureParticipantQuery) InsertMultisignatureParticipants(
	participants []*model.MultiSignatureParticipant,
) (queries [][]interface{})

func (*MultiSignatureParticipantQuery) Rollback 

func (msq *MultiSignatureParticipantQuery) Rollback(blockHeight uint32) [][]interface{}

func (*MultiSignatureParticipantQuery) Scan 

func (msq *MultiSignatureParticipantQuery) Scan(participant *model.MultiSignatureParticipant, row *sql.Row) error

func (*MultiSignatureParticipantQuery) SelectDataForSnapshot 

func (msq *MultiSignatureParticipantQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*MultiSignatureParticipantQuery) TrimDataBeforeSnapshot 

func (msq *MultiSignatureParticipantQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type MultiSignatureParticipantQueryInterface 

type MultiSignatureParticipantQueryInterface interface {
	ExtractModel(participant *model.MultiSignatureParticipant) []interface{}
	InsertMultisignatureParticipants(participants []*model.MultiSignatureParticipant) (queries [][]interface{})
	Scan(participant *model.MultiSignatureParticipant, row *sql.Row) error
	BuildModel(rows *sql.Rows) (participants []*model.MultiSignatureParticipant, err error)
	GetMultiSignatureParticipantsByMultisigAddressAndHeightRange(
		multisigAddress []byte,
		fromHeight,
		toHeight uint32,
	) (str string, args []interface{})
}

type MultisignatureInfoQuery 

type MultisignatureInfoQuery struct {
	Fields    []string
	TableName string
}

func NewMultisignatureInfoQuery 

func NewMultisignatureInfoQuery() *MultisignatureInfoQuery

NewMultisignatureInfoQuery returns PendingTransactionQuery instance

func (*MultisignatureInfoQuery) BuildModel 

func (msi *MultisignatureInfoQuery) BuildModel(
	mss []*model.MultiSignatureInfo, rows *sql.Rows,
) ([]*model.MultiSignatureInfo, error)

BuildModel will build model from *sql.Rows

func (*MultisignatureInfoQuery) BuildModelWithParticipant 

func (msi *MultisignatureInfoQuery) BuildModelWithParticipant(
	mss []*model.MultiSignatureInfo, rows *sql.Rows,
) ([]*model.MultiSignatureInfo, error)

BuildModelWithParticipant will build model from *sql.Rows that expect has addresses column which is result from sub query of multisignature_participant

func (*MultisignatureInfoQuery) ExtractModel 

func (*MultisignatureInfoQuery) ExtractModel(multisigInfo *model.MultiSignatureInfo) []interface{}

ExtractModel will get values exclude addresses, perfectly used while inserting new record.

func (*MultisignatureInfoQuery) GetMultisignatureInfoByAddressWithParticipants 

func (msi *MultisignatureInfoQuery) GetMultisignatureInfoByAddressWithParticipants(
	multisigAddress []byte,
	currentHeight, limit uint32,
) (str string, args []interface{})

GetMultisignatureInfoByAddressWithParticipants get multi signature info and participants

func (*MultisignatureInfoQuery) ImportSnapshot 

func (msi *MultisignatureInfoQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*MultisignatureInfoQuery) InsertMultiSignatureInfos 

func (msi *MultisignatureInfoQuery) InsertMultiSignatureInfos(multiSignatureInfos []*model.MultiSignatureInfo) [][]interface{}

InsertMultiSignatureInfos represents query builder to insert multiple records into multisignature_info and multisignature_participant table without updating the version

func (*MultisignatureInfoQuery) InsertMultisignatureInfo 

func (msi *MultisignatureInfoQuery) InsertMultisignatureInfo(multisigInfo *model.MultiSignatureInfo) [][]interface{}

InsertMultisignatureInfo inserts a new pending transaction into DB

func (*MultisignatureInfoQuery) RecalibrateVersionedTable 

func (msi *MultisignatureInfoQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*MultisignatureInfoQuery) Rollback 

func (msi *MultisignatureInfoQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "height"`

func (*MultisignatureInfoQuery) Scan 

func (*MultisignatureInfoQuery) Scan(multisigInfo *model.MultiSignatureInfo, row *sql.Row) error

Scan will build model from *sql.Row

func (*MultisignatureInfoQuery) SelectDataForSnapshot 

func (msi *MultisignatureInfoQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*MultisignatureInfoQuery) TrimDataBeforeSnapshot 

func (msi *MultisignatureInfoQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type MultisignatureInfoQueryInterface 

type MultisignatureInfoQueryInterface interface {
	GetMultisignatureInfoByAddressWithParticipants(
		multisigAddress []byte,
		currentHeight, limit uint32,
	) (str string, args []interface{})
	InsertMultisignatureInfo(multisigInfo *model.MultiSignatureInfo) [][]interface{}
	InsertMultiSignatureInfos(multiSignatureInfos []*model.MultiSignatureInfo) [][]interface{}
	Scan(multisigInfo *model.MultiSignatureInfo, row *sql.Row) error
	ExtractModel(multisigInfo *model.MultiSignatureInfo) []interface{}
	BuildModel(multisigInfos []*model.MultiSignatureInfo, rows *sql.Rows) ([]*model.MultiSignatureInfo, error)
	BuildModelWithParticipant(multisigInfos []*model.MultiSignatureInfo, rows *sql.Rows) ([]*model.MultiSignatureInfo, error)
}

type NodeAddressInfoQuery 

type NodeAddressInfoQuery struct {
	Fields    []string
	TableName string
}

func NewNodeAddressInfoQuery 

func NewNodeAddressInfoQuery() *NodeAddressInfoQuery

func (*NodeAddressInfoQuery) BuildModel 

func (paq *NodeAddressInfoQuery) BuildModel(
	nodeAddressesInfo []*model.NodeAddressInfo,
	rows *sql.Rows,
) ([]*model.NodeAddressInfo, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*NodeAddressInfoQuery) ConfirmNodeAddressInfo 

func (paq *NodeAddressInfoQuery) ConfirmNodeAddressInfo(nodeAddressInfo *model.NodeAddressInfo) [][]interface{}

ConfirmNodeAddressInfo returns a slice of queries/query parameters containing the insert/delete queries to be executed.

func (*NodeAddressInfoQuery) DeleteNodeAddressInfoByNodeID 

func (paq *NodeAddressInfoQuery) DeleteNodeAddressInfoByNodeID(
	nodeID int64,
	addressStatuses []model.NodeAddressStatus,
) (str string, args []interface{})

DeleteNodeAddressInfoByNodeID returns the query string and parameters to be executed to delete a peerAddress record

func (*NodeAddressInfoQuery) ExtractModel 

func (paq *NodeAddressInfoQuery) ExtractModel(pa *model.NodeAddressInfo) []interface{}

ExtractModel extract the model struct fields to the order of NodeAddressInfoQuery.Fields

func (*NodeAddressInfoQuery) GetNodeAddressInfo 

func (paq *NodeAddressInfoQuery) GetNodeAddressInfo() string

GetNodeAddressInfo returns query string to get contents of node_address_info table

func (*NodeAddressInfoQuery) GetNodeAddressInfoByAddressPort 

func (paq *NodeAddressInfoQuery) GetNodeAddressInfoByAddressPort(
	address string, port uint32,
	addressStatuses []model.NodeAddressStatus,
) (str string, args []interface{})

GetNodeAddressInfoByAddressPort returns query string to get peerAddress by node ID

func (*NodeAddressInfoQuery) GetNodeAddressInfoByNodeID 

func (paq *NodeAddressInfoQuery) GetNodeAddressInfoByNodeID(nodeID int64, addressStatuses []model.NodeAddressStatus) string

GetNodeAddressInfoByID returns query string to get peerAddress by node ID and address statuses

func (*NodeAddressInfoQuery) GetNodeAddressInfoByNodeIDs 

func (paq *NodeAddressInfoQuery) GetNodeAddressInfoByNodeIDs(nodeIDs []int64, addressStatuses []model.NodeAddressStatus) string

GetNodeAddressInfoByIDs returns query string to get peerAddress by node IDs and address statuses

func (*NodeAddressInfoQuery) GetNodeAddressInfoByStatus 

func (paq *NodeAddressInfoQuery) GetNodeAddressInfoByStatus(addressStatuses []model.NodeAddressStatus) string

GetNodeAddressInfoByStatus returns query string to get contents of node_address_info table

func (*NodeAddressInfoQuery) InsertNodeAddressInfo 

func (paq *NodeAddressInfoQuery) InsertNodeAddressInfo(peerAddress *model.NodeAddressInfo) (str string, args []interface{})

InsertNodeAddressInfo inserts a new peer address into DB. if an old ip/port peer is found with different nodeId, replace the old entry with the new one.

func (*NodeAddressInfoQuery) Scan 

func (paq *NodeAddressInfoQuery) Scan(pa *model.NodeAddressInfo, row *sql.Row) error

Scan represents `sql.Scan`

func (*NodeAddressInfoQuery) UpdateNodeAddressInfo 

func (paq *NodeAddressInfoQuery) UpdateNodeAddressInfo(peerAddress *model.NodeAddressInfo) (qry string, args []interface{})

UpdateNodeAddressInfo returns a slice of queries/query parameters containing the update query to be executed.

type NodeAddressInfoQueryInterface 

type NodeAddressInfoQueryInterface interface {
	InsertNodeAddressInfo(peerAddress *model.NodeAddressInfo) (str string, args []interface{})
	UpdateNodeAddressInfo(peerAddress *model.NodeAddressInfo) (string, []interface{})
	ConfirmNodeAddressInfo(nodeAddressInfo *model.NodeAddressInfo) [][]interface{}
	DeleteNodeAddressInfoByNodeID(nodeID int64, addressStatuses []model.NodeAddressStatus) (str string, args []interface{})
	GetNodeAddressInfoByNodeIDs(nodeIDs []int64, addressStatuses []model.NodeAddressStatus) string
	GetNodeAddressInfoByNodeID(nodeID int64, addressStatuses []model.NodeAddressStatus) string
	GetNodeAddressInfo() string
	GetNodeAddressInfoByStatus(addressStatuses []model.NodeAddressStatus) string
	GetNodeAddressInfoByAddressPort(
		address string, port uint32,
		addressStatuses []model.NodeAddressStatus,
	) (str string, args []interface{})
	ExtractModel(pa *model.NodeAddressInfo) []interface{}
	BuildModel(peerAddresss []*model.NodeAddressInfo, rows *sql.Rows) ([]*model.NodeAddressInfo, error)
	Scan(pa *model.NodeAddressInfo, row *sql.Row) error
}

type NodeAdmissionTimestampQuery 

type NodeAdmissionTimestampQuery struct {
	Fields    []string
	TableName string
}

NodeAdmissionTimestampQuery fields must have

func NewNodeAdmissionTimestampQuery 

func NewNodeAdmissionTimestampQuery() *NodeAdmissionTimestampQuery

NewNodeAdmissionTimestampQuery returns NewNodeAdmissionTimestampQuery instance

func (*NodeAdmissionTimestampQuery) BuildModel 

func (*NodeAdmissionTimestampQuery) BuildModel(
	nodeAdmissionTimestamps []*model.NodeAdmissionTimestamp,
	rows *sql.Rows,
) ([]*model.NodeAdmissionTimestamp, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*NodeAdmissionTimestampQuery) ExtractModel 

func (*NodeAdmissionTimestampQuery) ExtractModel(
	nextNodeAdmission *model.NodeAdmissionTimestamp,
) []interface{}

ExtractModel extract the model struct fields to the order of NodeAdmissionTimestampQuery.Fields

func (*NodeAdmissionTimestampQuery) GetNextNodeAdmision 

func (natq *NodeAdmissionTimestampQuery) GetNextNodeAdmision() string

GetNextNodeAdmision return the next node admission timestamp

func (*NodeAdmissionTimestampQuery) ImportSnapshot 

func (natq *NodeAdmissionTimestampQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*NodeAdmissionTimestampQuery) InsertNextNodeAdmission 

func (natq *NodeAdmissionTimestampQuery) InsertNextNodeAdmission(
	nodeAdmissionTimestamp *model.NodeAdmissionTimestamp,
) [][]interface{}

InsertNextNodeAdmission insert next timestamp node admission

func (*NodeAdmissionTimestampQuery) InsertNextNodeAdmissions 

func (natq *NodeAdmissionTimestampQuery) InsertNextNodeAdmissions(
	nodeAdmissionTimestamps []*model.NodeAdmissionTimestamp,
) (str string, args []interface{})

InsertNextNodeAdmissions represents query builder to insert multiple record in single query note: this query only use for inserting snapshot (applaying some lastest version of this table).

func (*NodeAdmissionTimestampQuery) RecalibrateVersionedTable 

func (natq *NodeAdmissionTimestampQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*NodeAdmissionTimestampQuery) Rollback 

func (natq *NodeAdmissionTimestampQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "block_height"

func (*NodeAdmissionTimestampQuery) Scan 

func (natq *NodeAdmissionTimestampQuery) Scan(
	nextNodeAdmission *model.NodeAdmissionTimestamp,
	row *sql.Row,
) error

Scan similar with `sql.Scan`

func (*NodeAdmissionTimestampQuery) SelectDataForSnapshot 

func (natq *NodeAdmissionTimestampQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

SelectDataForSnapshot select only the block at snapshot block_height (fromHeight is unused)

func (*NodeAdmissionTimestampQuery) TrimDataBeforeSnapshot 

func (natq *NodeAdmissionTimestampQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type NodeAdmissionTimestampQueryInterface 

type NodeAdmissionTimestampQueryInterface interface {
	GetNextNodeAdmision() string
	InsertNextNodeAdmission(nodeAdmissionTimestamp *model.NodeAdmissionTimestamp) [][]interface{}
	InsertNextNodeAdmissions(
		nodeAdmissionTimestamps []*model.NodeAdmissionTimestamp,
	) (str string, args []interface{})
	ExtractModel(nextNodeAdmission *model.NodeAdmissionTimestamp) []interface{}
	BuildModel(
		nodeAdmissionTimestamps []*model.NodeAdmissionTimestamp,
		rows *sql.Rows,
	) ([]*model.NodeAdmissionTimestamp, error)
	Scan(nextNodeAdmission *model.NodeAdmissionTimestamp, row *sql.Row) error
}

NodeAdmissionTimestampQueryInterface methods must have

type NodeRegistrationQuery 

type NodeRegistrationQuery struct {
	Fields                  []string
	JoinedAddressInfoFields []string
	TableName               string
}

func NewNodeRegistrationQuery 

func NewNodeRegistrationQuery() *NodeRegistrationQuery

func (*NodeRegistrationQuery) BuildBlocksmith 

func (*NodeRegistrationQuery) BuildBlocksmith(
	blocksmiths []*model.Blocksmith, rows *sql.Rows,
) ([]*model.Blocksmith, error)

func (*NodeRegistrationQuery) BuildModel 

func (nrq *NodeRegistrationQuery) BuildModel(
	nodeRegistrations []*model.NodeRegistration,
	rows *sql.Rows,
) ([]*model.NodeRegistration, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*NodeRegistrationQuery) BuildModelWithParticipationScore 

func (nrq *NodeRegistrationQuery) BuildModelWithParticipationScore(
	nodeRegistries []storage.NodeRegistry,
	rows *sql.Rows,
) ([]storage.NodeRegistry, error)

BuildModelWithParticipationScore build the rows to `storage.NodeRegistry` model

func (*NodeRegistrationQuery) ClearDeletedNodeRegistration 

func (nrq *NodeRegistrationQuery) ClearDeletedNodeRegistration(nodeRegistration *model.NodeRegistration) [][]interface{}

ClearDeletedNodeRegistration used when registering a new node from and account that has previously deleted another one to avoid having multiple node registrations with same account id and latest = true

func (*NodeRegistrationQuery) ExtractModel 

func (nrq *NodeRegistrationQuery) ExtractModel(tx *model.NodeRegistration) []interface{}

ExtractModel extract the model struct fields to the order of NodeRegistrationQuery.Fields

func (*NodeRegistrationQuery) GetActiveNodeRegistrationsByHeight 

func (nrq *NodeRegistrationQuery) GetActiveNodeRegistrationsByHeight(height uint32) string

func (*NodeRegistrationQuery) GetActiveNodeRegistrationsWithNodeAddress 

func (nrq *NodeRegistrationQuery) GetActiveNodeRegistrationsWithNodeAddress() string

GetNodeRegistryAtHeightWithNodeAddress returns unique latest node registry record at specific height, with peer addresses too. Note: this query is to be used during node scrambling. Only nodes that have a peerAddress will be selected

func (*NodeRegistrationQuery) GetAllNodeRegistryByStatus 

func (nrq *NodeRegistrationQuery) GetAllNodeRegistryByStatus(status model.NodeRegistrationState, active bool) string

GetAllNodeRegistryByStatus fetch node registries with latest = 1 joined with participation_score table active will strictly require data to have participation score, if set to false, it means node can be pending registry

func (*NodeRegistrationQuery) GetLastVersionedNodeRegistrationByPublicKey 

func (nrq *NodeRegistrationQuery) GetLastVersionedNodeRegistrationByPublicKey(nodePublicKey []byte,
	height uint32) (str string, args []interface{})

GetLastVersionedNodeRegistrationByPublicKey returns query string to get Node Registration by node public key at a given height (versioned)

func (*NodeRegistrationQuery) GetLastVersionedNodeRegistrationByPublicKeyWithNodeAddress 

func (nrq *NodeRegistrationQuery) GetLastVersionedNodeRegistrationByPublicKeyWithNodeAddress(nodePublicKey []byte,
	height uint32) (str string, args []interface{})

GetLastVersionedNodeRegistrationByPublicKey returns query string to get Node Registration by node public key at a given height (versioned)

func (*NodeRegistrationQuery) GetNodeRegistrationByAccountAddress 

func (nrq *NodeRegistrationQuery) GetNodeRegistrationByAccountAddress(accountAddress []byte) (str string, args []interface{})

GetNodeRegistrationByAccountAddress returns query string to get Node Registration by account public key

func (*NodeRegistrationQuery) GetNodeRegistrationByID 

func (nrq *NodeRegistrationQuery) GetNodeRegistrationByID(id int64) (str string, args []interface{})

GetNodeRegistrationByID returns query string to get Node Registration by node ID

func (*NodeRegistrationQuery) GetNodeRegistrationByNodePublicKey 

func (nrq *NodeRegistrationQuery) GetNodeRegistrationByNodePublicKey() string

GetNodeRegistrationByNodePublicKey returns query string to get Node Registration by node public key

func (*NodeRegistrationQuery) GetNodeRegistrations 

func (nrq *NodeRegistrationQuery) GetNodeRegistrations(registrationHeight, size uint32) string

GetNodeRegistrations returns query string to get multiple node registrations

func (*NodeRegistrationQuery) GetNodeRegistrationsByBlockHeightInterval 

func (nrq *NodeRegistrationQuery) GetNodeRegistrationsByBlockHeightInterval(fromHeight, toHeight uint32) string

GetNodeRegistrationsByBlockTimestampInterval returns query string to get multiple node registrations Note: toHeight (limit) is excluded from selection to avoid selecting duplicates

func (*NodeRegistrationQuery) GetNodeRegistrationsByBlockTimestampInterval 

func (nrq *NodeRegistrationQuery) GetNodeRegistrationsByBlockTimestampInterval(fromTimestamp, toTimestamp int64) string

GetNodeRegistrationsByBlockTimestampInterval returns query string to get multiple node registrations Note: toTimestamp (limit) is excluded from selection to avoid selecting duplicates

func (*NodeRegistrationQuery) GetNodeRegistrationsByHighestLockedBalance 

func (nrq *NodeRegistrationQuery) GetNodeRegistrationsByHighestLockedBalance(limit uint32,
	registrationStatus model.NodeRegistrationState) string

GetNodeRegistrationsByHighestLockedBalance returns query string to get the list of Node Registrations with highest locked balance registration_status or not registration_status

func (*NodeRegistrationQuery) GetNodeRegistryAtHeight 

func (nrq *NodeRegistrationQuery) GetNodeRegistryAtHeight(height uint32) string

GetNodeRegistryAtHeight returns unique latest node registry record at specific height

func (*NodeRegistrationQuery) GetNodeRegistryAtHeightWithNodeAddress 

func (nrq *NodeRegistrationQuery) GetNodeRegistryAtHeightWithNodeAddress(height uint32) string

GetNodeRegistryAtHeightWithNodeAddress returns unique latest node registry record at specific height, with peer addresses too. Note: this query is to be used during node scrambling. Only nodes that have a peerAddress will be selected

func (*NodeRegistrationQuery) GetPendingNodeRegistrations 

func (nrq *NodeRegistrationQuery) GetPendingNodeRegistrations(limit uint32) string

GetPendingNodeRegistrations returns pending node registrations sorted by their locked balance (highest to lowest)

func (*NodeRegistrationQuery) ImportSnapshot 

func (nrq *NodeRegistrationQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*NodeRegistrationQuery) InsertNodeRegistration 

func (nrq *NodeRegistrationQuery) InsertNodeRegistration(nodeRegistration *model.NodeRegistration) (str string, args []interface{})

InsertNodeRegistration inserts a new node registration into DB

func (*NodeRegistrationQuery) InsertNodeRegistrations 

func (nrq *NodeRegistrationQuery) InsertNodeRegistrations(nodeRegistrations []*model.NodeRegistration) (str string, args []interface{})

InsertNodeRegistrations represents query builder to insert multiple record in single query

func (*NodeRegistrationQuery) RecalibrateVersionedTable 

func (nrq *NodeRegistrationQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*NodeRegistrationQuery) Rollback 

func (nrq *NodeRegistrationQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > `height` and UPDATE latest of the `account_address` clause by `block_height`

func (*NodeRegistrationQuery) Scan 

func (nrq *NodeRegistrationQuery) Scan(nr *model.NodeRegistration, row *sql.Row) error

Scan represents `sql.Scan`

func (*NodeRegistrationQuery) SelectDataForSnapshot 

func (nrq *NodeRegistrationQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

SelectDataForSnapshot this query selects only node registry latest state from height 0 to 'fromHeight' ( excluded) and all records from 'fromHeight' to 'toHeight', removing from first selection records that have duplicate ids with second second selection. This way we make sure only one version of every id has 'latest' field set to true

func (*NodeRegistrationQuery) TrimDataBeforeSnapshot 

func (nrq *NodeRegistrationQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

func (*NodeRegistrationQuery) UpdateNodeRegistration 

func (nrq *NodeRegistrationQuery) UpdateNodeRegistration(nodeRegistration *model.NodeRegistration) [][]interface{}

UpdateNodeRegistration returns a slice of two queries. 1st update all old noderegistration versions' latest field to 0 2nd insert a new version of the noderegisration with updated data

type NodeRegistrationQueryInterface 

type NodeRegistrationQueryInterface interface {
	InsertNodeRegistration(nodeRegistration *model.NodeRegistration) (str string, args []interface{})
	InsertNodeRegistrations(nodeRegistrations []*model.NodeRegistration) (str string, args []interface{})
	UpdateNodeRegistration(nodeRegistration *model.NodeRegistration) [][]interface{}
	ClearDeletedNodeRegistration(nodeRegistration *model.NodeRegistration) [][]interface{}
	GetNodeRegistrations(registrationHeight, size uint32) (str string)
	GetNodeRegistrationsByBlockTimestampInterval(fromTimestamp, toTimestamp int64) string
	GetNodeRegistrationsByBlockHeightInterval(fromHeight, toHeight uint32) string
	GetAllNodeRegistryByStatus(status model.NodeRegistrationState, active bool) string
	GetActiveNodeRegistrationsByHeight(height uint32) string
	GetActiveNodeRegistrationsWithNodeAddress() string
	GetNodeRegistrationByID(id int64) (str string, args []interface{})
	GetNodeRegistrationByNodePublicKey() string
	GetLastVersionedNodeRegistrationByPublicKey(nodePublicKey []byte, height uint32) (str string, args []interface{})
	GetLastVersionedNodeRegistrationByPublicKeyWithNodeAddress(nodePublicKey []byte, height uint32) (str string, args []interface{})
	GetNodeRegistrationByAccountAddress(accountAddress []byte) (str string, args []interface{})
	GetNodeRegistrationsByHighestLockedBalance(limit uint32, registrationStatus model.NodeRegistrationState) string
	GetNodeRegistryAtHeight(height uint32) string
	GetNodeRegistryAtHeightWithNodeAddress(height uint32) string
	GetPendingNodeRegistrations(limit uint32) string
	ExtractModel(nr *model.NodeRegistration) []interface{}
	BuildModel(nodeRegistrations []*model.NodeRegistration, rows *sql.Rows) ([]*model.NodeRegistration, error)
	BuildBlocksmith(blocksmiths []*model.Blocksmith, rows *sql.Rows) ([]*model.Blocksmith, error)
	BuildModelWithParticipationScore(
		nodeRegistries []storage.NodeRegistry,
		rows *sql.Rows,
	) ([]storage.NodeRegistry, error)
	Scan(nr *model.NodeRegistration, row *sql.Row) error
}

type ParticipationScoreQuery 

type ParticipationScoreQuery struct {
	Fields    []string
	TableName string
}

func NewParticipationScoreQuery 

func NewParticipationScoreQuery() *ParticipationScoreQuery

func (*ParticipationScoreQuery) BuildModel 

func (*ParticipationScoreQuery) BuildModel(
	participationScores []*model.ParticipationScore,
	rows *sql.Rows,
) ([]*model.ParticipationScore, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*ParticipationScoreQuery) ExtractModel 

func (*ParticipationScoreQuery) ExtractModel(ps *model.ParticipationScore) []interface{}

ExtractModel extract the model struct fields to the order of ParticipationScoreQuery.Fields

func (*ParticipationScoreQuery) GetParticipationScoreByNodeID 

func (ps *ParticipationScoreQuery) GetParticipationScoreByNodeID(id int64) (str string, args []interface{})

GetParticipationScoreByNodeID returns query string to get participation score by node id

func (*ParticipationScoreQuery) GetParticipationScoreByNodePublicKey 

func (ps *ParticipationScoreQuery) GetParticipationScoreByNodePublicKey(nodePublicKey []byte) (str string, args []interface{})

func (*ParticipationScoreQuery) GetParticipationScoresByBlockHeightRange 

func (ps *ParticipationScoreQuery) GetParticipationScoresByBlockHeightRange(
	fromBlockHeight, toBlockHeight uint32,
) (str string, args []interface{})

func (*ParticipationScoreQuery) ImportSnapshot 

func (ps *ParticipationScoreQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*ParticipationScoreQuery) InsertParticipationScore 

func (ps *ParticipationScoreQuery) InsertParticipationScore(participationScore *model.ParticipationScore) (str string, args []interface{})

func (*ParticipationScoreQuery) InsertParticipationScores 

func (ps *ParticipationScoreQuery) InsertParticipationScores(scores []*model.ParticipationScore) (str string, args []interface{})

InsertParticipationScores represents query builder to insert multiple record in single query

func (*ParticipationScoreQuery) RecalibrateVersionedTable 

func (ps *ParticipationScoreQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*ParticipationScoreQuery) Rollback 

func (ps *ParticipationScoreQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > `height` and UPDATE latest of the `account_address` clause by `block_height`

func (*ParticipationScoreQuery) Scan 

func (*ParticipationScoreQuery) Scan(ps *model.ParticipationScore, row *sql.Row) error

func (*ParticipationScoreQuery) SelectDataForSnapshot 

func (ps *ParticipationScoreQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*ParticipationScoreQuery) TrimDataBeforeSnapshot 

func (ps *ParticipationScoreQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

func (*ParticipationScoreQuery) UpdateParticipationScore 

func (ps *ParticipationScoreQuery) UpdateParticipationScore(
	nodeID, score int64,
	blockHeight uint32,
) [][]interface{}

type ParticipationScoreQueryInterface 

type ParticipationScoreQueryInterface interface {
	InsertParticipationScore(participationScore *model.ParticipationScore) (str string, args []interface{})
	InsertParticipationScores(scores []*model.ParticipationScore) (str string, args []interface{})
	UpdateParticipationScore(
		nodeID, score int64,
		blockHeight uint32,
	) [][]interface{}
	GetParticipationScoreByNodeID(id int64) (str string, args []interface{})
	GetParticipationScoreByNodePublicKey(nodePublicKey []byte) (str string, args []interface{})
	GetParticipationScoresByBlockHeightRange(
		fromBlockHeight, toBlockHeight uint32) (str string, args []interface{})
	Scan(participationScore *model.ParticipationScore, row *sql.Row) error
	ExtractModel(ps *model.ParticipationScore) []interface{}
	BuildModel(participationScores []*model.ParticipationScore, rows *sql.Rows) ([]*model.ParticipationScore, error)
}

type PendingSignatureQuery 

type PendingSignatureQuery struct {
	Fields    []string
	TableName string
}

func NewPendingSignatureQuery 

func NewPendingSignatureQuery() *PendingSignatureQuery

NewPendingSignatureQuery returns PendingTransactionQuery instance

func (*PendingSignatureQuery) BuildModel 

func (psq *PendingSignatureQuery) BuildModel(
	pss []*model.PendingSignature, rows *sql.Rows,
) ([]*model.PendingSignature, error)

func (*PendingSignatureQuery) ExtractModel 

func (*PendingSignatureQuery) ExtractModel(pendingSig *model.PendingSignature) []interface{}

func (*PendingSignatureQuery) GetPendingSignatureByHash 

func (psq *PendingSignatureQuery) GetPendingSignatureByHash(
	txHash []byte,
	currentHeight, limit uint32,
) (str string, args []interface{})

func (*PendingSignatureQuery) ImportSnapshot 

func (psq *PendingSignatureQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*PendingSignatureQuery) InsertPendingSignature 

func (psq *PendingSignatureQuery) InsertPendingSignature(pendingSig *model.PendingSignature) [][]interface{}

InsertPendingSignature inserts a new pending transaction into DB

func (*PendingSignatureQuery) InsertPendingSignatures 

func (psq *PendingSignatureQuery) InsertPendingSignatures(pendingSigs []*model.PendingSignature) (str string, args []interface{})

InsertPendingSignatures represents query builder to insert multiple record in single query

func (*PendingSignatureQuery) RecalibrateVersionedTable 

func (psq *PendingSignatureQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*PendingSignatureQuery) Rollback 

func (psq *PendingSignatureQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "height"`

func (*PendingSignatureQuery) Scan 

func (*PendingSignatureQuery) Scan(pendingSig *model.PendingSignature, row *sql.Row) error

func (*PendingSignatureQuery) SelectDataForSnapshot 

func (psq *PendingSignatureQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*PendingSignatureQuery) TrimDataBeforeSnapshot 

func (psq *PendingSignatureQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type PendingSignatureQueryInterface 

type PendingSignatureQueryInterface interface {
	GetPendingSignatureByHash(
		txHash []byte,
		currentHeight, limit uint32,
	) (str string, args []interface{})
	InsertPendingSignature(pendingSig *model.PendingSignature) [][]interface{}
	InsertPendingSignatures(pendingSigs []*model.PendingSignature) (str string, args []interface{})
	Scan(pendingSig *model.PendingSignature, row *sql.Row) error
	ExtractModel(pendingSig *model.PendingSignature) []interface{}
	BuildModel(pendingSigs []*model.PendingSignature, rows *sql.Rows) ([]*model.PendingSignature, error)
}

type PendingTransactionQuery 

type PendingTransactionQuery struct {
	Fields    []string
	TableName string
}

func NewPendingTransactionQuery 

func NewPendingTransactionQuery() *PendingTransactionQuery

NewPendingTransactionQuery returns PendingTransactionQuery instance

func (*PendingTransactionQuery) BuildModel 

func (ptq *PendingTransactionQuery) BuildModel(
	pts []*model.PendingTransaction, rows *sql.Rows,
) ([]*model.PendingTransaction, error)

func (*PendingTransactionQuery) ExtractModel 

func (*PendingTransactionQuery) ExtractModel(pendingTx *model.PendingTransaction) []interface{}

func (*PendingTransactionQuery) GetPendingTransactionByHash 

func (ptq *PendingTransactionQuery) GetPendingTransactionByHash(
	txHash []byte,
	statuses []model.PendingTransactionStatus,
	currentHeight, limit uint32,
) (str string, args []interface{})

func (*PendingTransactionQuery) GetPendingTransactionsBySenderAddress 

func (ptq *PendingTransactionQuery) GetPendingTransactionsBySenderAddress(
	multisigAddress []byte,
	status model.PendingTransactionStatus,
	currentHeight, limit uint32,
) (str string, args []interface{})

func (*PendingTransactionQuery) GetPendingTransactionsExpireByHeight 

func (ptq *PendingTransactionQuery) GetPendingTransactionsExpireByHeight(currentHeight uint32) (str string, args []interface{})

GetPendingTransactionsExpireByHeight presents query to get pending_transactions that was expire by block_height

func (*PendingTransactionQuery) ImportSnapshot 

func (ptq *PendingTransactionQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*PendingTransactionQuery) InsertPendingTransaction 

func (ptq *PendingTransactionQuery) InsertPendingTransaction(pendingTx *model.PendingTransaction) [][]interface{}

InsertPendingTransaction inserts a new pending transaction into DB

func (*PendingTransactionQuery) InsertPendingTransactions 

func (ptq *PendingTransactionQuery) InsertPendingTransactions(pendingTXs []*model.PendingTransaction) (str string, args []interface{})

InsertPendingTransactions represents query builder to insert multiple record in single query

func (*PendingTransactionQuery) RecalibrateVersionedTable 

func (ptq *PendingTransactionQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*PendingTransactionQuery) Rollback 

func (ptq *PendingTransactionQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "height"`

func (*PendingTransactionQuery) Scan 

func (*PendingTransactionQuery) Scan(pendingTx *model.PendingTransaction, row *sql.Row) error

func (*PendingTransactionQuery) SelectDataForSnapshot 

func (ptq *PendingTransactionQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*PendingTransactionQuery) TrimDataBeforeSnapshot 

func (ptq *PendingTransactionQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type PendingTransactionQueryInterface 

type PendingTransactionQueryInterface interface {
	GetPendingTransactionByHash(
		txHash []byte,
		statuses []model.PendingTransactionStatus,
		currentHeight, limit uint32,
	) (str string, args []interface{})
	GetPendingTransactionsBySenderAddress(
		multisigAddress []byte,
		status model.PendingTransactionStatus,
		currentHeight, limit uint32,
	) (
		str string, args []interface{},
	)
	GetPendingTransactionsExpireByHeight(blockHeight uint32) (str string, args []interface{})
	InsertPendingTransaction(pendingTx *model.PendingTransaction) [][]interface{}
	InsertPendingTransactions(pendingTXs []*model.PendingTransaction) (str string, args []interface{})
	Scan(pendingTx *model.PendingTransaction, row *sql.Row) error
	ExtractModel(pendingTx *model.PendingTransaction) []interface{}
	BuildModel(pendingTxs []*model.PendingTransaction, rows *sql.Rows) ([]*model.PendingTransaction, error)
}

type PruneQuery 

type PruneQuery interface {
	PruneData(blockHeight, limit uint32) (qStr string, args []interface{})
}

PruneQuery represent query to delete the prunable data from manage table

func GetPruneQuery 

func GetPruneQuery(ct chaintype.ChainType) (pruneQuery []PruneQuery)

GetPruneQuery func to get all query that have PruneData method. Query to delete prunable data

type PublishedReceiptQuery 

type PublishedReceiptQuery struct {
	Fields    []string
	TableName string
}

func NewPublishedReceiptQuery 

func NewPublishedReceiptQuery() *PublishedReceiptQuery

NewPublishedReceiptQuery returns PublishedQuery instance

func (*PublishedReceiptQuery) BuildModel 

func (prq *PublishedReceiptQuery) BuildModel(
	prs []*model.PublishedReceipt, rows *sql.Rows,
) ([]*model.PublishedReceipt, error)

func (*PublishedReceiptQuery) ExtractModel 

func (*PublishedReceiptQuery) ExtractModel(publishedReceipt *model.PublishedReceipt) []interface{}

func (*PublishedReceiptQuery) GetPublishedReceiptByBlockHeight 

func (prq *PublishedReceiptQuery) GetPublishedReceiptByBlockHeight(blockHeight uint32) (str string, args []interface{})

func (*PublishedReceiptQuery) GetPublishedReceiptByBlockHeightRange 

func (prq *PublishedReceiptQuery) GetPublishedReceiptByBlockHeightRange(
	fromBlockHeight, toBlockHeight uint32,
) (str string, args []interface{})

func (*PublishedReceiptQuery) GetPublishedReceiptByLinkedRMR 

func (prq *PublishedReceiptQuery) GetPublishedReceiptByLinkedRMR(root []byte) (str string, args []interface{})

func (*PublishedReceiptQuery) ImportSnapshot 

func (prq *PublishedReceiptQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*PublishedReceiptQuery) InsertPublishedReceipt 

func (prq *PublishedReceiptQuery) InsertPublishedReceipt(publishedReceipt *model.PublishedReceipt) (str string, args []interface{})

InsertPublishedReceipt inserts a new pas into DB

func (*PublishedReceiptQuery) InsertPublishedReceipts 

func (prq *PublishedReceiptQuery) InsertPublishedReceipts(receipts []*model.PublishedReceipt) (str string, args []interface{})

InsertPublishedReceipts represents query builder to insert multiple record in single query

func (*PublishedReceiptQuery) RecalibrateVersionedTable 

func (prq *PublishedReceiptQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*PublishedReceiptQuery) Rollback 

func (prq *PublishedReceiptQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "height"`

func (*PublishedReceiptQuery) Scan 

func (*PublishedReceiptQuery) Scan(receipt *model.PublishedReceipt, row *sql.Row) error

func (*PublishedReceiptQuery) SelectDataForSnapshot 

func (prq *PublishedReceiptQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*PublishedReceiptQuery) TrimDataBeforeSnapshot 

func (prq *PublishedReceiptQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type PublishedReceiptQueryInterface 

type PublishedReceiptQueryInterface interface {
	GetPublishedReceiptByLinkedRMR(root []byte) (str string, args []interface{})
	GetPublishedReceiptByBlockHeight(blockHeight uint32) (str string, args []interface{})
	GetPublishedReceiptByBlockHeightRange(
		fromBlockHeight, toBlockHeight uint32,
	) (str string, args []interface{})
	InsertPublishedReceipt(publishedReceipt *model.PublishedReceipt) (str string, args []interface{})
	InsertPublishedReceipts(receipts []*model.PublishedReceipt) (str string, args []interface{})
	Scan(publishedReceipt *model.PublishedReceipt, row *sql.Row) error
	ExtractModel(publishedReceipt *model.PublishedReceipt) []interface{}
	BuildModel(prs []*model.PublishedReceipt, rows *sql.Rows) ([]*model.PublishedReceipt, error)
}

type SkippedBlocksmithQuery 

type SkippedBlocksmithQuery struct {
	Fields    []string
	TableName string
	ChainType chaintype.ChainType
}

func NewSkippedBlocksmithQuery 

func NewSkippedBlocksmithQuery(ct chaintype.ChainType) *SkippedBlocksmithQuery

NewSkippedBlocksmithQuery will create a new SkippedBlocksmithQuery instance

func (*SkippedBlocksmithQuery) BuildModel 

func (*SkippedBlocksmithQuery) BuildModel(
	skippedBlocksmiths []*model.SkippedBlocksmith,
	rows *sql.Rows,
) ([]*model.SkippedBlocksmith, error)

func (*SkippedBlocksmithQuery) ExtractModel 

func (*SkippedBlocksmithQuery) ExtractModel(skippedModel *model.SkippedBlocksmith) []interface{}

func (*SkippedBlocksmithQuery) GetNumberOfSkippedBlocksmithsByBlockHeight 

func (sbq *SkippedBlocksmithQuery) GetNumberOfSkippedBlocksmithsByBlockHeight(blockHeight uint32) string

func (*SkippedBlocksmithQuery) GetSkippedBlocksmithsByBlockHeight 

func (sbq *SkippedBlocksmithQuery) GetSkippedBlocksmithsByBlockHeight(blockHeight uint32) string

func (*SkippedBlocksmithQuery) ImportSnapshot 

func (sbq *SkippedBlocksmithQuery) ImportSnapshot(payload interface{}) ([][]interface{}, error)

ImportSnapshot takes payload from downloaded snapshot and insert them into database

func (*SkippedBlocksmithQuery) InsertSkippedBlocksmith 

func (sbq *SkippedBlocksmithQuery) InsertSkippedBlocksmith(
	skippedBlocksmith *model.SkippedBlocksmith,
) (qStr string, args []interface{})

func (*SkippedBlocksmithQuery) InsertSkippedBlocksmiths 

func (sbq *SkippedBlocksmithQuery) InsertSkippedBlocksmiths(skippedBlocksmiths []*model.SkippedBlocksmith) (str string, args []interface{})

InsertSkippedBlocksmiths represents query builder to insert multiple record in single query

func (*SkippedBlocksmithQuery) RecalibrateVersionedTable 

func (sbq *SkippedBlocksmithQuery) RecalibrateVersionedTable() []string

RecalibrateVersionedTable recalibrate table to clean up multiple latest rows due to import function

func (*SkippedBlocksmithQuery) Rollback 

func (sbq *SkippedBlocksmithQuery) Rollback(height uint32) (multiQueries [][]interface{})

func (*SkippedBlocksmithQuery) Scan 

func (*SkippedBlocksmithQuery) Scan(skippedBlocksmith *model.SkippedBlocksmith, row *sql.Row) error

func (*SkippedBlocksmithQuery) SelectDataForSnapshot 

func (sbq *SkippedBlocksmithQuery) SelectDataForSnapshot(fromHeight, toHeight uint32) string

func (*SkippedBlocksmithQuery) TrimDataBeforeSnapshot 

func (sbq *SkippedBlocksmithQuery) TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string

TrimDataBeforeSnapshot delete entries to assure there are no duplicates before applying a snapshot

type SkippedBlocksmithQueryInterface 

type SkippedBlocksmithQueryInterface interface {
	GetNumberOfSkippedBlocksmithsByBlockHeight(blockHeight uint32) (qStr string)
	GetSkippedBlocksmithsByBlockHeight(blockHeight uint32) (qStr string)
	InsertSkippedBlocksmith(skippedBlocksmith *model.SkippedBlocksmith) (qStr string, args []interface{})
	InsertSkippedBlocksmiths(skippedBlockSmiths []*model.SkippedBlocksmith) (str string, args []interface{})
	ExtractModel(skippedBlocksmith *model.SkippedBlocksmith) []interface{}
	BuildModel(skippedBlocksmiths []*model.SkippedBlocksmith, rows *sql.Rows) ([]*model.SkippedBlocksmith, error)
	Scan(skippedBlocksmith *model.SkippedBlocksmith, rows *sql.Row) error
	Rollback(height uint32) (multiQueries [][]interface{})
}

type SnapshotQuery 

type SnapshotQuery interface {
	SelectDataForSnapshot(fromHeight, toHeight uint32) string
	TrimDataBeforeSnapshot(fromHeight, toHeight uint32) string
	ImportSnapshot(interface{}) ([][]interface{}, error)
	RecalibrateVersionedTable() []string
}

type SpineBlockManifestQuery 

type SpineBlockManifestQuery struct {
	Fields    []string
	TableName string
}

func NewSpineBlockManifestQuery 

func NewSpineBlockManifestQuery() *SpineBlockManifestQuery

func (*SpineBlockManifestQuery) BuildModel 

func (mbl *SpineBlockManifestQuery) BuildModel(
	spineBlockManifests []*model.SpineBlockManifest,
	rows *sql.Rows,
) ([]*model.SpineBlockManifest, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*SpineBlockManifestQuery) ExtractModel 

func (mbl *SpineBlockManifestQuery) ExtractModel(mb *model.SpineBlockManifest) []interface{}

ExtractModel extract the model struct fields to the order of SpineBlockManifestQuery.Fields

func (*SpineBlockManifestQuery) GetLastSpineBlockManifest 

func (mbl *SpineBlockManifestQuery) GetLastSpineBlockManifest(ct chaintype.ChainType, mbType model.SpineBlockManifestType) string

GetLastSpineBlockManifest returns the last spineBlockManifest

func (*SpineBlockManifestQuery) GetManifestBySpineBlockHeight 

func (mbl *SpineBlockManifestQuery) GetManifestBySpineBlockHeight(spineBlockHeight uint32) string

GetManifestBySpineBlockHeight retrieve manifests of binded to a spineblock height

func (*SpineBlockManifestQuery) GetManifestsFromManifestReferenceHeightRange 

func (mbl *SpineBlockManifestQuery) GetManifestsFromManifestReferenceHeightRange(fromHeight, toHeight uint32) (qry string, args []interface{})

func (*SpineBlockManifestQuery) GetManifestsFromSpineBlockHeight 

func (mbl *SpineBlockManifestQuery) GetManifestsFromSpineBlockHeight(spineBlockHeight uint32) string

func (*SpineBlockManifestQuery) GetSpineBlockManifestTimeInterval 

func (mbl *SpineBlockManifestQuery) GetSpineBlockManifestTimeInterval(fromTimestamp, toTimestamp int64) string

GetSpineBlockManifestTimeInterval retrieve all spineBlockManifests within a time frame Note: it is used to get all entities that have expired between spine blocks

func (*SpineBlockManifestQuery) InsertSpineBlockManifest 

func (mbl *SpineBlockManifestQuery) InsertSpineBlockManifest(
	spineBlockManifest *model.SpineBlockManifest,
) (str string, args []interface{})

InsertSpineBlockManifest insert new spine block manifest Note: a new one with same id will replace a previous one, if present. this is to allow blocks downloaded from peers to override spine block manifests created locally and insure that the correct snapshot is downloaded by the node when first joins the network

func (*SpineBlockManifestQuery) Rollback 

func (mbl *SpineBlockManifestQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > "height - constant.MinRollbackBlocks"` Note: we subtract constant.MinRollbackBlocks from height because that's the block height the snapshot is taken in respect of current block height

func (*SpineBlockManifestQuery) Scan 

func (mbl *SpineBlockManifestQuery) Scan(mb *model.SpineBlockManifest, row *sql.Row) error

Scan represents `sql.Scan`

type SpineBlockManifestQueryInterface 

type SpineBlockManifestQueryInterface interface {
	InsertSpineBlockManifest(spineBlockManifest *model.SpineBlockManifest) (str string, args []interface{})
	GetSpineBlockManifestTimeInterval(fromTimestamp, toTimestamp int64) string
	GetManifestBySpineBlockHeight(spineBlockHeight uint32) string
	GetManifestsFromSpineBlockHeight(spineBlockHeight uint32) string
	GetLastSpineBlockManifest(ct chaintype.ChainType, mbType model.SpineBlockManifestType) string
	GetManifestsFromManifestReferenceHeightRange(fromHeight, toHeight uint32) (qry string, args []interface{})
	ExtractModel(mb *model.SpineBlockManifest) []interface{}
	BuildModel(spineBlockManifests []*model.SpineBlockManifest, rows *sql.Rows) ([]*model.SpineBlockManifest, error)
	Scan(mb *model.SpineBlockManifest, row *sql.Row) error
}

type SpinePublicKeyQuery 

type SpinePublicKeyQuery struct {
	Fields    []string
	TableName string
}

func NewSpinePublicKeyQuery 

func NewSpinePublicKeyQuery() *SpinePublicKeyQuery

func (*SpinePublicKeyQuery) BuildBlocksmith 

func (spkq *SpinePublicKeyQuery) BuildBlocksmith(
	blocksmiths []*model.Blocksmith, rows *sql.Rows,
) ([]*model.Blocksmith, error)

func (*SpinePublicKeyQuery) BuildModel 

func (spkq *SpinePublicKeyQuery) BuildModel(
	spinePublicKeys []*model.SpinePublicKey,
	rows *sql.Rows,
) ([]*model.SpinePublicKey, error)

BuildModel will only be used for mapping the result of `select` query, which will guarantee that the result of build model will be correctly mapped based on the modelQuery.Fields order.

func (*SpinePublicKeyQuery) ExtractModel 

func (spkq *SpinePublicKeyQuery) ExtractModel(spk *model.SpinePublicKey) []interface{}

ExtractModel extract the model struct fields to the order of SpinePublicKeyQuery.Fields

func (*SpinePublicKeyQuery) GetSpinePublicKeysByBlockHeight 

func (spkq *SpinePublicKeyQuery) GetSpinePublicKeysByBlockHeight(height uint32) (str string)

GetSpinePublicKeysByBlockHeight returns query string to get Spine public keys for a given block

func (*SpinePublicKeyQuery) GetValidSpinePublicKeysByHeightInterval 

func (spkq *SpinePublicKeyQuery) GetValidSpinePublicKeysByHeightInterval(fromHeight, toHeight uint32) string

func (*SpinePublicKeyQuery) InsertSpinePublicKey 

func (spkq *SpinePublicKeyQuery) InsertSpinePublicKey(spinePublicKey *model.SpinePublicKey) [][]interface{}

InsertSpinePublicKey

func (*SpinePublicKeyQuery) Rollback 

func (spkq *SpinePublicKeyQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE block_height > `height` and UPDATE latest of the `account_address` clause by `block_height`

func (*SpinePublicKeyQuery) Scan 

func (spkq *SpinePublicKeyQuery) Scan(spk *model.SpinePublicKey, row *sql.Row) error

Scan represents `sql.Scan`

type SpinePublicKeyQueryInterface 

type SpinePublicKeyQueryInterface interface {
	InsertSpinePublicKey(spinePublicKey *model.SpinePublicKey) [][]interface{}
	GetValidSpinePublicKeysByHeightInterval(fromHeight, toHeight uint32) string
	GetSpinePublicKeysByBlockHeight(height uint32) string
	ExtractModel(spk *model.SpinePublicKey) []interface{}
	BuildModel(spinePublicKeys []*model.SpinePublicKey, rows *sql.Rows) ([]*model.SpinePublicKey, error)
	BuildBlocksmith(blocksmiths []*model.Blocksmith, rows *sql.Rows) ([]*model.Blocksmith, error)
	Scan(spk *model.SpinePublicKey, row *sql.Row) error
	Rollback(height uint32) (multiQueries [][]interface{})
}

type TransactionQuery 

type TransactionQuery struct {
	Fields    []string
	TableName string
	ChainType chaintype.ChainType
}

func NewTransactionQuery 

func NewTransactionQuery(chaintype chaintype.ChainType) *TransactionQuery

NewTransactionQuery returns TransactionQuery instance

func (*TransactionQuery) BuildModel 

func (*TransactionQuery) BuildModel(txs []*model.Transaction, rows *sql.Rows) ([]*model.Transaction, error)

func (*TransactionQuery) ExtractModel 

func (*TransactionQuery) ExtractModel(tx *model.Transaction) []interface{}

ExtractModel extract the model struct fields to the order of TransactionQuery.Fields

func (*TransactionQuery) GetTransaction 

func (tq *TransactionQuery) GetTransaction(id int64) string

GetTransaction get a single transaction from DB

func (*TransactionQuery) GetTransactionsByBlockID 

func (tq *TransactionQuery) GetTransactionsByBlockID(blockID int64) (str string, args []interface{})

func (*TransactionQuery) GetTransactionsByIds 

func (tq *TransactionQuery) GetTransactionsByIds(txIds []int64) (str string, args []interface{})

func (*TransactionQuery) InsertTransaction 

func (tq *TransactionQuery) InsertTransaction(tx *model.Transaction) (str string, args []interface{})

InsertTransaction inserts a new transaction into DB

func (*TransactionQuery) Rollback 

func (tq *TransactionQuery) Rollback(height uint32) (multiQueries [][]interface{})

Rollback delete records `WHERE height > "height"

func (*TransactionQuery) Scan 

func (*TransactionQuery) Scan(tx *model.Transaction, row *sql.Row) error

type TransactionQueryInterface 

type TransactionQueryInterface interface {
	InsertTransaction(tx *model.Transaction) (str string, args []interface{})
	GetTransaction(id int64) string
	GetTransactionsByIds(txIds []int64) (str string, args []interface{})
	GetTransactionsByBlockID(blockID int64) (str string, args []interface{})
	ExtractModel(tx *model.Transaction) []interface{}
	BuildModel(txs []*model.Transaction, rows *sql.Rows) ([]*model.Transaction, error)
	Scan(tx *model.Transaction, row *sql.Row) error
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.